diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perlnumber.pod')
-rwxr-xr-x | Master/tlpkg/tlperl/lib/pods/perlnumber.pod | 209 |
1 files changed, 209 insertions, 0 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perlnumber.pod b/Master/tlpkg/tlperl/lib/pods/perlnumber.pod new file mode 100755 index 00000000000..ffe3ed5b432 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/pods/perlnumber.pod @@ -0,0 +1,209 @@ +=head1 NAME + +perlnumber - semantics of numbers and numeric operations in Perl + +=head1 SYNOPSIS + + $n = 1234; # decimal integer + $n = 0b1110011; # binary integer + $n = 01234; # octal integer + $n = 0x1234; # hexadecimal integer + $n = 12.34e-56; # exponential notation + $n = "-12.34e56"; # number specified as a string + $n = "1234"; # number specified as a string + +=head1 DESCRIPTION + +This document describes how Perl internally handles numeric values. + +Perl's operator overloading facility is completely ignored here. Operator +overloading allows user-defined behaviors for numbers, such as operations +over arbitrarily large integers, floating points numbers with arbitrary +precision, operations over "exotic" numbers such as modular arithmetic or +p-adic arithmetic, and so on. See L<overload> for details. + +=head1 Storing numbers + +Perl can internally represent numbers in 3 different ways: as native +integers, as native floating point numbers, and as decimal strings. +Decimal strings may have an exponential notation part, as in C<"12.34e-56">. +I<Native> here means "a format supported by the C compiler which was used +to build perl". + +The term "native" does not mean quite as much when we talk about native +integers, as it does when native floating point numbers are involved. +The only implication of the term "native" on integers is that the limits for +the maximal and the minimal supported true integral quantities are close to +powers of 2. However, "native" floats have a most fundamental +restriction: they may represent only those numbers which have a relatively +"short" representation when converted to a binary fraction. For example, +0.9 cannot be represented by a native float, since the binary fraction +for 0.9 is infinite: + + binary0.1110011001100... + +with the sequence C<1100> repeating again and again. In addition to this +limitation, the exponent of the binary number is also restricted when it +is represented as a floating point number. On typical hardware, floating +point values can store numbers with up to 53 binary digits, and with binary +exponents between -1024 and 1024. In decimal representation this is close +to 16 decimal digits and decimal exponents in the range of -304..304. +The upshot of all this is that Perl cannot store a number like +12345678901234567 as a floating point number on such architectures without +loss of information. + +Similarly, decimal strings can represent only those numbers which have a +finite decimal expansion. Being strings, and thus of arbitrary length, there +is no practical limit for the exponent or number of decimal digits for these +numbers. (But realize that what we are discussing the rules for just the +I<storage> of these numbers. The fact that you can store such "large" numbers +does not mean that the I<operations> over these numbers will use all +of the significant digits. +See L<"Numeric operators and numeric conversions"> for details.) + +In fact numbers stored in the native integer format may be stored either +in the signed native form, or in the unsigned native form. Thus the limits +for Perl numbers stored as native integers would typically be -2**31..2**32-1, +with appropriate modifications in the case of 64-bit integers. Again, this +does not mean that Perl can do operations only over integers in this range: +it is possible to store many more integers in floating point format. + +Summing up, Perl numeric values can store only those numbers which have +a finite decimal expansion or a "short" binary expansion. + +=head1 Numeric operators and numeric conversions + +As mentioned earlier, Perl can store a number in any one of three formats, +but most operators typically understand only one of those formats. When +a numeric value is passed as an argument to such an operator, it will be +converted to the format understood by the operator. + +Six such conversions are possible: + + native integer --> native floating point (*) + native integer --> decimal string + native floating_point --> native integer (*) + native floating_point --> decimal string (*) + decimal string --> native integer + decimal string --> native floating point (*) + +These conversions are governed by the following general rules: + +=over 4 + +=item * + +If the source number can be represented in the target form, that +representation is used. + +=item * + +If the source number is outside of the limits representable in the target form, +a representation of the closest limit is used. (I<Loss of information>) + +=item * + +If the source number is between two numbers representable in the target form, +a representation of one of these numbers is used. (I<Loss of information>) + +=item * + +In C<< native floating point --> native integer >> conversions the magnitude +of the result is less than or equal to the magnitude of the source. +(I<"Rounding to zero".>) + +=item * + +If the C<< decimal string --> native integer >> conversion cannot be done +without loss of information, the result is compatible with the conversion +sequence C<< decimal_string --> native_floating_point --> native_integer >>. +In particular, rounding is strongly biased to 0, though a number like +C<"0.99999999999999999999"> has a chance of being rounded to 1. + +=back + +B<RESTRICTION>: The conversions marked with C<(*)> above involve steps +performed by the C compiler. In particular, bugs/features of the compiler +used may lead to breakage of some of the above rules. + +=head1 Flavors of Perl numeric operations + +Perl operations which take a numeric argument treat that argument in one +of four different ways: they may force it to one of the integer/floating/ +string formats, or they may behave differently depending on the format of +the operand. Forcing a numeric value to a particular format does not +change the number stored in the value. + +All the operators which need an argument in the integer format treat the +argument as in modular arithmetic, e.g., C<mod 2**32> on a 32-bit +architecture. C<sprintf "%u", -1> therefore provides the same result as +C<sprintf "%u", ~0>. + +=over 4 + +=item Arithmetic operators + +The binary operators C<+> C<-> C<*> C</> C<%> C<==> C<!=> C<E<gt>> C<E<lt>> +C<E<gt>=> C<E<lt>=> and the unary operators C<-> C<abs> and C<--> will +attempt to convert arguments to integers. If both conversions are possible +without loss of precision, and the operation can be performed without +loss of precision then the integer result is used. Otherwise arguments are +converted to floating point format and the floating point result is used. +The caching of conversions (as described above) means that the integer +conversion does not throw away fractional parts on floating point numbers. + +=item ++ + +C<++> behaves as the other operators above, except that if it is a string +matching the format C</^[a-zA-Z]*[0-9]*\z/> the string increment described +in L<perlop> is used. + +=item Arithmetic operators during C<use integer> + +In scopes where C<use integer;> is in force, nearly all the operators listed +above will force their argument(s) into integer format, and return an integer +result. The exceptions, C<abs>, C<++> and C<-->, do not change their +behavior with C<use integer;> + +=item Other mathematical operators + +Operators such as C<**>, C<sin> and C<exp> force arguments to floating point +format. + +=item Bitwise operators + +Arguments are forced into the integer format if not strings. + +=item Bitwise operators during C<use integer> + +forces arguments to integer format. Also shift operations internally use +signed integers rather than the default unsigned. + +=item Operators which expect an integer + +force the argument into the integer format. This is applicable +to the third and fourth arguments of C<sysread>, for example. + +=item Operators which expect a string + +force the argument into the string format. For example, this is +applicable to C<printf "%s", $value>. + +=back + +Though forcing an argument into a particular form does not change the +stored number, Perl remembers the result of such conversions. In +particular, though the first such conversion may be time-consuming, +repeated operations will not need to redo the conversion. + +=head1 AUTHOR + +Ilya Zakharevich C<ilya@math.ohio-state.edu> + +Editorial adjustments by Gurusamy Sarathy <gsar@ActiveState.com> + +Updates for 5.8.0 by Nicholas Clark <nick@ccl4.org> + +=head1 SEE ALSO + +L<overload>, L<perlop> |