sub is_int {
  $_[0] == int $_[0];
}
[download]

-- Randal L. Schwartz, Perl hacker

For regular numbers, this is works, but it also claims 'integerness' for things like '2na' and '4ever'. Would a regexp be a reliable way of catching this, or is there something better?

sub is_int
{
        ($_[0] =~ /^\-?\d+(?:\.\d+)?(?:e\+\d+)?$/
        && $_[0] == int $_[0]);
}
[download]

Maybe something like this:

sub is_int {
  my $warned = 0;
  local $SIG{__WARN__} = sub { $warned++ };
  local $^W = 1;
  $_[0] == int $_[0] and not $warned;
}
[download]

-- Randal L. Schwartz, Perl hacker

I realized this after I pushed 'submit'... I'm a dolt.

Well, I can think of quite a few meanings of "is an integer".

1. Fits in a Perl UV:

   sub isUV {
       my( $i )= @_; 
       return  isIntVal($i) &&  $i == (0|$i);
   }
   [download]

2. Fits in a Perl IV (no test provided)
3. Fits in a Perl NV but has no fractional part:

   sub isNVint {
       my( $i )= @_;
       return  isIntVal($i)  &&  $i == int($i);
   }
   [download]

4. Is the (string) representation of an integer that may not fit into (1), (2), or (3):

   sub isInt {
       my( $i )= @_;
       return  $i =~ /^-?\d+\z/;
   }
   [download]

5. A scalar that will result in (1), (2), or (3) w/o warning when used in a "numeric context":

   sub isIntVal {
       my( $i )= @_;
       return  $i =~ /^\s*[-+]?\d+\s*$/;
   }
   [download]

   But (update) that doesn't cover "1.2e4", for example, so you can also use (updated):

   sub isIntVal2 {
       my( $i )= @_;
       my $warn= 0;
       {
           local( $^W )= 1;
           # my $warn= 0;
           local( $SIG{__WARN__} )= sub { $warn++ };
           $i= 0+$i;
       }
       return  ! $warn  &&  int($i) == $i;
   }
   [download]

6. A string that will result in literal (1), (2), or (3) w/o warning when used in Perl code (for example, with eval). This one has to allow for _ in the middle, "0x" or "0b" at the start, etc.

I really think that the best solution involves making the looks_like_number() C subroutine that Perl itself uses available to scripts.

No. 5 looks like a pretty cool solution to the problem. There's one thing with this code though that I can't figure out. It looks to me that you're using a closure, but it doesn't work. When I try to run this code Perl complains: Global symbol "$warn" requires explicit package name

I could only make this work by removing the outer { }. Does anyone know why this closure doesn't work?

Sorry, my bad. I fixed the code and left the original broken bit in, just commented out.

        - tye

That's because it's not a closure. Closures are subroutines that maintain the lexical state around them outside the scope of that lexical state. There's no subroutine involved.

The reason for the extra brackets is to provide a scope for the local $^W = 1;.

Being right, does not endow the right to be rude; politeness costs nothing.
Being unknowing, is not the same as being stupid.
Expressing a contrary opinion, whether to the individual or the group, is more often a sign of deeper thought than of cantankerous belligerence.
Do not mistake your goals as the only goals; your opinion as the only opinion; your confidence as correctness. Saying you know better is not the same as explaining you know better.

$x = 17;
for $i (1..10){
  $x = sqrt($x);
}
for $i (1..10){
  $x *= $x;
}
print $x;
[download]

You probably knew that, but it might not be obvious to everyone...

--traveler

Personally I was impressed by Re: Strange (rounding?) problem and think that eq is a better fit...

I'm not computer whizzy enough to explain in detail but I think that if you ask a computer to store a floating point number which is obtained as a fraction (eg. $a = 1/3;) then you get 0.333333333333333 (not 0.3 recurring) to however many decimal places. If yuo then operate on this number, because it does not remain a fraction, the results are "rounded". So to compare the result of iakobski's sqrt and subsequent squaring to 1/3 would not match using ==.

In this case it is only integers (whole numbers - no decimal places) which are being discussed so they must be stored more sensible and a numerical comparison (==) will be more efficient than comparing the two strings (especially on large numbers, possibly several hundreds of thousands of times through a loop).

I think essentially the eq and ne have to go through both "strings" a character at a time and compare them but == or != can just say these numbers are('nt) the same.

larryk

----------------------------------------------------
$less->{'chars'} = `"time in the pub" | more`; # :-D
[download]

How do I determine whether a scalar is a number/whole/integer/float?

Assuming that you don't care about IEEE notations like "NaN" or "Infinity", you probably just want to use a regular expression.

   ...
   if (/^-?\d+$/)       { print "is an integer\n" }
   if (/^[+-]?\d+$/)    { print "is a +/- integer\n" }
   ...
[download]

C:\>type test.pl
foreach (1.2, foobar){
     print &is_int ($_)?"$_ is an integer\n":"$_ is not an integer\n";
  }

sub is_int{
  my $testvar =shift;
  use integer;
  my $intval=$testvar_*1;
  no integer;
  return $testvar == $intval;
}

C:\>perl test.pl
1.2 is not an integer
foobar is an integer

C:\>

C:\>type test.pl
$_ = 'foobar';
print "'$_' is an integer" if is_int($_);

sub is_int {
  $_[0] == int $_[0];
}

C:\>perl test.pl
'foobar' is an integer
C:\>
[download]