Penguin
Recent Changes
Blame: perlnumber(1)
EditPageHistoryDiffInfoLikePages
Annotated edit history of perlnumber(1) version 1, including all changes. View license author blame.
Rev Author # Line
1 perry 1 PERLNUMBER
2 !!!PERLNUMBER
3 NAME
4 SYNOPSIS
5 DESCRIPTION
6 Storing numbers
7 Numeric operators and numeric conversions
8 Flavors of Perl numeric operations
9 AUTHOR
10 SEE ALSO
11 ----
12 !!NAME
13
14
15 perlnumber - semantics of numbers and numeric operations in Perl
16 !!SYNOPSIS
17
18
19 $n = 1234; # decimal integer
20 $n = 0b1110011; # binary integer
21 $n = 01234; # octal integer
22 $n = 0x1234; # hexadecimal integer
23 $n = 12.34e-56; # exponential notation
24 $n =
25 !!DESCRIPTION
26
27
28 This document describes how Perl internally handles numeric
29 values.
30
31
32 Perl's operator overloading facility is completely ignored
33 here. Operator overloading allows user-defined behaviors for
34 numbers, such as operations over arbitrarily large integers,
35 floating points numbers with arbitrary precision, operations
36 over ``exotic'' numbers such as modular arithmetic or p-adic
37 arithmetic, and so on. See overload for
38 details.
39 !!Storing numbers
40
41
42 Perl can internally represent numbers in 3 different ways:
43 as native integers, as native floating point numbers, and as
44 decimal strings. Decimal strings may have an exponential
45 notation part, as in .
46 ''Native'' here means ``a format supported by the C
47 compiler which was used to build perl''.
48
49
50 The term ``native'' does not mean quite as much when we talk
51 about native integers, as it does when native floating point
52 numbers are involved. The only implication of the term
53 ``native'' on integers is that the limits for the maximal
54 and the minimal supported true integral quantities are close
55 to powers of 2. However, ``native'' floats have a most
56 fundamental restriction: they may represent only those
57 numbers which have a relatively ``short'' representation
58 when converted to a binary fraction. For example, 0.9 cannot
59 be represented by a native float, since the binary fraction
60 for 0.9 is infinite:
61
62
63 binary0.1110011001100...
64 with the sequence 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.
65
66
67 Similarly, decimal strings can represent only those numbers
68 which have a finite decimal expansion. Being strings, and
69 thus of arbitrary length, there is no practical limit for
70 the exponent or number of decimal digits for these numbers.
71 (But realize that what we are discussing the rules for just
72 the ''storage'' of these numbers. The fact that you can
73 store such ``large'' numbers does not mean that the
74 ''operations'' over these numbers will use all of the
75 significant digits. See ``Numeric operators and numeric
76 conversions'' for details.)
77
78
79 In fact numbers stored in the native integer format may be
80 stored either in the signed native form, or in the unsigned
81 native form. Thus the limits for Perl numbers stored as
82 native integers would typically be -2**31..2**32-1, with
83 appropriate modifications in the case of 64-bit integers.
84 Again, this does not mean that Perl can do operations only
85 over integers in this range: it is possible to store many
86 more integers in floating point format.
87
88
89 Summing up, Perl numeric values can store only those numbers
90 which have a finite decimal expansion or a ``short'' binary
91 expansion.
92 !!Numeric operators and numeric conversions
93
94
95 As mentioned earlier, Perl can store a number in any one of
96 three formats, but most operators typically understand only
97 one of those formats. When a numeric value is passed as an
98 argument to such an operator, it will be converted to the
99 format understood by the operator.
100
101
102 Six such conversions are possible:
103
104
105 native integer --
106 These conversions are governed by the following general rules:
107
108
109 If the source number can be represented in the target form,
110 that representation is used.
111
112
113 If the source number is outside of the limits representable
114 in the target form, a representation of the closest limit is
115 used. (''Loss of information'')
116
117
118 If the source number is between two numbers representable in
119 the target form, a representation of one of these numbers is
120 used. (''Loss of information'')
121
122
123 In native floating point --
124 conversions the magnitude of the result is less than or
125 equal to the magnitude of the source. (''``Rounding to
126 zero''.'')
127
128
129 If the decimal string --
130 conversion cannot be done without loss of information, the
131 result is compatible with the conversion sequence
132 decimal_string --
133 . In particular, rounding is strongly
134 biased to 0, though a number like
135 has a chance of
136 being rounded to 1.
137
138
139 __RESTRICTION__ : The conversions marked
140 with (*) above involve steps performed by the C
141 compiler. In particular, bugs/features of the compiler used
142 may lead to breakage of some of the above
143 rules.
144 !!Flavors of Perl numeric operations
145
146
147 Perl operations which take a numeric argument treat that
148 argument in one of four different ways: they may force it to
149 one of the integer/floating/ string formats, or they may
150 behave differently depending on the format of the operand.
151 Forcing a numeric value to a particular format does not
152 change the number stored in the value.
153
154
155 All the operators which need an argument in the integer
156 format treat the argument as in modular arithmetic, e.g.,
157 mod 2**32 on a 32-bit architecture. sprintf
158 therefore provides the same result
159 as sprintf .
160
161
162 Arithmetic operators except, no
163 integer
164
165
166 force the argument into the floating point
167 format.
168
169
170 Arithmetic operators except, use
171 integer
172
173
174 Bitwise operators, no integer
175
176
177 force the argument into the integer format if it is not a
178 string.
179
180
181 Bitwise operators, use integer
182
183
184 force the argument into the integer format
185
186
187 Operators which expect an integer
188
189
190 force the argument into the integer format. This is
191 applicable to the third and fourth arguments of
192 sysread, for example.
193
194
195 Operators which expect a string
196
197
198 force the argument into the string format. For example, this
199 is applicable to printf
200 .
201
202
203 Though forcing an argument into a particular form does not
204 change the stored number, Perl remembers the result of such
205 conversions. In particular, though the first such conversion
206 may be time-consuming, repeated operations will not need to
207 redo the conversion.
208 !!AUTHOR
209
210
211 Ilya Zakharevich
212 ilya@math.ohio-state.edu
213
214
215 Editorial adjustments by Gurusamy Sarathy
216 !!SEE ALSO
217
218
219 overload
220 ----
This page is a man page (or other imported legacy content). We are unable to automatically determine the license status of this page.