1package integer; 2 3=head1 NAME 4 5integer - Perl pragma to use integer arithmetic instead of floating point 6 7=head1 SYNOPSIS 8 9 use integer; 10 $x = 10/3; 11 # $x is now 3, not 3.33333333333333333 12 13=head1 DESCRIPTION 14 15This tells the compiler to use integer operations from here to the end 16of the enclosing BLOCK. On many machines, this doesn't matter a great 17deal for most computations, but on those without floating point 18hardware, it can make a big difference in performance. 19 20Note that this only affects how most of the arithmetic and relational 21B<operators> handle their operands and results, and B<not> how all 22numbers everywhere are treated. Specifically, C<use integer;> has the 23effect that before computing the results of the arithmetic operators 24(+, -, *, /, %, +=, -=, *=, /=, %=, and unary minus), the comparison 25operators (<, <=, >, >=, ==, !=, <=>), and the bitwise operators (|, &, 26^, <<, >>, |=, &=, ^=, <<=, >>=), the operands have their fractional 27portions truncated (or floored), and the result will have its 28fractional portion truncated as well. In addition, the range of 29operands and results is restricted to that of familiar two's complement 30integers, i.e., -(2**31) .. (2**31-1) on 32-bit architectures, and 31-(2**63) .. (2**63-1) on 64-bit architectures. For example, this code 32 33 use integer; 34 $x = 5.8; 35 $y = 2.5; 36 $z = 2.7; 37 $a = 2**31 - 1; # Largest positive integer on 32-bit machines 38 $, = ", "; 39 print $x, -$x, $x + $y, $x - $y, $x / $y, $x * $y, $y == $z, $a, $a + 1; 40 41will print: 5.8, -5, 7, 3, 2, 10, 1, 2147483647, -2147483648 42 43Note that $x is still printed as having its true non-integer value of 445.8 since it wasn't operated on. And note too the wrap-around from the 45largest positive integer to the largest negative one. Also, arguments 46passed to functions and the values returned by them are B<not> affected 47by C<use integer;>. E.g., 48 49 srand(1.5); 50 $, = ", "; 51 print sin(.5), cos(.5), atan2(1,2), sqrt(2), rand(10); 52 53will give the same result with or without C<use integer;> The power 54operator C<**> is also not affected, so that 2 ** .5 is always the 55square root of 2. Now, it so happens that the pre- and post- increment 56and decrement operators, ++ and --, are not affected by C<use integer;> 57either. Some may rightly consider this to be a bug -- but at least it's 58a long-standing one. 59 60Finally, C<use integer;> also has an additional affect on the bitwise 61operators. Normally, the operands and results are treated as 62B<unsigned> integers, but with C<use integer;> the operands and results 63are B<signed>. This means, among other things, that ~0 is -1, and -2 & 64-5 is -6. 65 66Internally, native integer arithmetic (as provided by your C compiler) 67is used. This means that Perl's own semantics for arithmetic 68operations may not be preserved. One common source of trouble is the 69modulus of negative numbers, which Perl does one way, but your hardware 70may do another. 71 72 % perl -le 'print (4 % -3)' 73 -2 74 % perl -Minteger -le 'print (4 % -3)' 75 1 76 77See L<perlmodlib/"Pragmatic Modules">, L<perlop/"Integer Arithmetic"> 78 79=cut 80 81$integer::hint_bits = 0x1; 82 83sub import { 84 $^H |= $integer::hint_bits; 85} 86 87sub unimport { 88 $^H &= ~$integer::hint_bits; 89} 90 911; 92