diff options
author | Gurusamy Sarathy <gsar@cpan.org> | 2000-03-01 00:34:10 +0000 |
---|---|---|
committer | Gurusamy Sarathy <gsar@cpan.org> | 2000-03-01 00:34:10 +0000 |
commit | ac65edd091c58fa56b3dde9505b63579e43340f8 (patch) | |
tree | 0125e03a28f458154f3580c6cd1d17cfe0240070 /pod/perlnumber.pod | |
parent | 1250aba519c4f388317ce9822edbe8ca724e1616 (diff) | |
download | perl-ac65edd091c58fa56b3dde9505b63579e43340f8.tar.gz |
add perlnumber.pod (from Ilya Zakharevich); substantially edited
prose
p4raw-id: //depot/perl@5380
Diffstat (limited to 'pod/perlnumber.pod')
-rw-r--r-- | pod/perlnumber.pod | 185 |
1 files changed, 185 insertions, 0 deletions
diff --git a/pod/perlnumber.pod b/pod/perlnumber.pod new file mode 100644 index 0000000000..c05b066b43 --- /dev/null +++ b/pod/perlnumber.pod @@ -0,0 +1,185 @@ +=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 + $n = v49.50.51.52; # number specified as a string, which in + # turn is specified in terms of numbers :-) + +=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<perlovl> for details. + +=head1 Storing numbers + +Perl can internally represents 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, for "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 respresented 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 may 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 that the I<operations> over these numbers will use all +of the significant digits. +See L<"Numeric operations 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 + +=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 + +=item Arithmetic operators except, C<no integer> + +force the argument into the floating point format. + +=item Arithmetic operators except, C<use integer> + +=item Bitwise operators, C<no integer> + +force the argument into the integer format if it is not a string. + +=item Bitwise operators, C<use integer> + +force the argument into the integer format + +=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> + +=head1 SEE ALSO + +L<perlovl> |