View source for Manual:Representation of numbers in expr parser function

: ''The accuracy and format of numeric results varies with the operating system of the server. Some remarks on this page are specific for Wikimedia.''

==Floats==
As long as no conversion to integer type is carried out by trunc or mod, intermediate results of #expr and #ifexpr (such as q*r in p+q*r, but also the factors 2.1 and 1e-3 in 2.1e-3) are stored as float, i.e. in [[w:Double precision floating-point format|double precision floating-point format]], so they are the integers up to 2<sup>53</sup>=9,007,199,254,740,992, multiplied or divided by a power of 2 (between limits), with the [[w:unit in the last place|unit in the last place]] (ULP, spacing) equal to <math>2^{-52 + \lfloor \log_2 |x| \rfloor} </math>, which is <math>2^{-52}</math> times |''x''|, rounded down to a power of 2. Divided by |''x''|, between each pair of consecutive powers of 2, this gradually decreases from <math>2^{-52}</math> to <math>2^{-53}</math>, somewhat like an inverted [[w:Sawtooth wave|sawtooth wave]], but with increasingly wide "tooths". When rounding ''x'' to the nearest float the rounding error alternately increases and decreases linearly with ''x'', between plus and minus one half of the local ULP. Thus between each pair of consecutive powers of 2 the local maximum relative rounding error gradually decreases from <math>2^{-53}</math> to <math>2^{-54}</math>.

To find the exact value of a float one can use [[Template:Hex]] to show the [[w:significand|significand]] in [[w:hexadecimal|hexadecimal]] format (apart from the sign it consists of a fixed "<code>1.</code>", followed by 13 hexadecimal characters) and the exponent in decimal format.

Thus we can see which numbers and subexpressions are equivalent and which are not:
*{{xpsoc|hex|1+2^-52}}
*{{xpsoc|hex|1.0000000000000002}}
*{{xpsoc|hex|1+2e-16}}
*{{xpsoc|hex|99999999999.99999e-11}}
*{{xpsoc|hex|999999999999.9999e-12}}
*{{xpsoc|hex|999999999999999.9e-15}}

Such internal results can also be shown indirectly with high precision by subtracting a nearby representable number:
*{{xpsoc|#expr:(1+2e-16)-1}}

After producing an internally representable result the system does (while converting from binary to decimal format) a further rounding to a total of 14 digits, in regular or scientific notation, to produce the expanded wikitext.

The maximum relative rounding error due to this is 5e-14:
*{{xpsoc|#expr:1+5e-14}}
This is 450 times as much as for the rounding  to an internally representable result (225 times the spacing):
*{{xpsoc|hex|1+5e-14}}

In terms of number of units of the 17th decimal digit, the spacing of internal numbers is {{#expr:1e16/2^52round2}}  units between 1 and 2:
*{{xpsoc|numfh|1.5}}
increasing to {{#expr:1e16/2^49round1}} between 8 and 10:
*{{xpsoc|numfh|9}}
{{#expr:1e15/2^49round2}} between 10 and 16, increasing to {{#expr:1e15/2^46round1}} between 64 and 100, {{#expr:1e14/2^46round2}} between 100 and 128, increasing to {{#expr:1e14/2^43round2}} between 512 and 1000, {{#expr:1e13/2^43round2}} between 1000 and 1024:
*{{xpsoc|numfh|1010}}
{{#expr:1e13/2^42round2}} between 1024 and 2048, etc. Altogether the minimum is 1.11 units, for numbers which are just above a power of 10 ''and'' just below a power of 2; for example, as mentioned, it is 1.14 between 1000 and 1024). The maximum is 22.2 units, for numbers which are just above a power of 2 ''and'' just below a power of 10; for example, between 9.9e27 and 1e28 it is {{#expr:1e-11/2^-41round1}}.0:
*{{xpsoc|numfh|9.95e27}}
Therefore 17 decimal digits are always sufficient to identify a particular internal number. (This does not mean that further digits are ignored; if two consecutive 17-digit numbers are rounded to different floats, then there is somewhere a borderline between them, see [[Manual:Expr parser function syntax#Numbers as input]].) See also below.

The more accurate result can be displayed with special manipulations, for example:
*{{xpsoc|#expr:1501^5}} 
*<code><nowiki>{{#expr:1000*floor((1501^5)/1000)}} + {{#expr:1501^5)mod1000}}
</nowiki></code> → {{#expr:1000*floor((1501^5)/1000)}} + {{#expr:(1501^5)mod1000}}

Another example:
* {{xpsoc|hex|6/7}} 
* {{xpsoc|#expr:6/7}} 
* {{xpsoc|#expr:6/7-0.85714285714286}}
This gives us indirectly some more digits of 6/7; with 17 digits we get the same internal number as with 6/7 :
* {{xpsoc|hex|0.85714285714285711}}
The 17th digit is that in the mathematical expansion of the internal number to which 6/7 is rounded, which in this case is not equal to that in the mathematical expansion of 6/7. This deviation can occur because the spacing of internal numbers in this range is 1.11e-16, 11.1 times the spacing of the numbers with 17 digits. For example 10 internal numbers onward we have:
* {{xpsoc|hex|0.85714285714285822}}

==Integers==
In the range from 0 through 2^53 all integers are internally exactly representable as float; in the range 2^52 through 2^53  the set of floats is exactly the set of integers. 

They are exactly displayed after conversion to type integer using trunc, as is done in [[Template:Numf]]:

*{{xpsoc|numf|2^53}}

Compare:
*<code><nowiki>{{formatnum:{{#expr:2^53}}}}</nowiki></code> → {{formatnum:{{#expr:2^53}}}}

In the same way larger floats in the range of the numbers of type integer can be displayed exactly, the largest being:
*{{xpsoc|numf|2^63-1024}}

Non-negative integers internally exactly representable as float include:
*as type integer not larger than {{numf|2^53}} (as type integer: until 1024 times this number)
*multiples of 10 not larger than {{numf|{{trunc|2^54/10}}}}e1 (as type integer: until 512 times this number) 
*multiples of 100 not larger than {{numf|{{trunc|2^55/1e2}}}}e2 (as type integer: until 256 times this number)
*multiples of 1e3 not larger than {{numf|{{trunc|2^56/1e3}}}}e3 (as type integer: until 128 times this number)
*multiples of 1e4 not larger than {{numf|{{trunc|2^57/1e4}}}}e4 (as type integer: until 64 times this number)
*multiples of 1e5 not larger than {{numf|{{trunc|2^58/1e5}}}}e5 (as type integer: until 32 times this number)
*multiples of 1e6 not larger than {{numf|{{trunc|2^59/1e6}}}}e6 (as type integer: until 16 times this number)
*multiples of 1e7 not larger than {{numf|{{trunc|2^60/1e7}}}}e7 (as type integer: until 8 times this number)
*multiples of 1e8 not larger than {{numf|{{trunc|2^61/1e8}}}}e8 (as type integer: until 4 times this number)
*multiples of 1e9 not larger than {{numf|{{trunc|2^62/1e9}}}}e9 (as type integer: until 2 times this number)
*multiples of 1e10 not larger than {{numf|{{trunc|2^63/1e10}}}}e10 (as type integer also)
*multiples of 1e11 not larger than {{numf|{{trunc|2^64/1e11}}}}e11
*multiples of 1e12 not larger than {{numf|{{trunc|2^65/1e12}}}}e12
*multiples of 1e13 not larger than {{numf|{{trunc|2^66/1e13}}}}e13
*multiples of 1e14 not larger than {{numf|{{trunc|2^67/1e14}}}}e14
*multiples of 1e15 not larger than {{numf|{{trunc|2^68/1e15}}}}e15
*multiples of 1e16 not larger than {{numf|{{trunc|2^69/1e16}}}}e16
*multiples of 1e17 not larger than {{numf|{{trunc|2^70/1e17}}}}e17
*multiples of 1e18 not larger than {{numf|{{trunc|2^71/1e18}}}}e18
*multiples of 1e19 not larger than {{numf|{{trunc|2^72/1e19}}}}e19
*multiples of 1e20 not larger than {{numf|{{trunc|2^73/1e20}}}}e20
*multiples of 1e21 not larger than {{numf|{{trunc|2^74/1e21}}}}e21
*multiples of 1e22 not larger than 3e22

To make sure that an integer that is internally exactly representable as float is entered exactly, it has to be entered in integer form, or in scientific notation with an integer significand and a non-negative exponent, not in scientific notation with a fraction as significand (see also below):
*{{xpsoc|numf|90071.99254740992e11}}
*{{xpsoc|numf|9007199254740992}}

Large integers which are not exactly representable as float can only be entered indirectly. For 19-digit integers < 2^63, the 6 most compact expressions and the ways they are produced with [[Template:Integer]] are as follows:
*{{xpsoc|integer|9134|067893123456789}}
*{{xpsoc|integer|91340|67893123456789}}
*{{xpsoc|integer|913406|7893123456789}}
*{{xpsoc|integer|9134067|893123456789}}
*{{xpsoc|integer|91340678|93123456789}}
*{{xpsoc|integer|913406789|3123456789}}

*{{xpsoc|numf|{{integer|9134|067893123456789}}}}
*{{xpsoc|numf|{{integer|91340|67893123456789}}}}
*{{xpsoc|numf|{{integer|913406|7893123456789}}}}
*{{xpsoc|numf|{{integer|9134067|893123456789}}}}
*{{xpsoc|numf|{{integer|91340678|93123456789}}}}
*{{xpsoc|numf|{{integer|913406789|3123456789}}}}

This format requires the first term to be representable as float. Compare (exact with an extra trunc operator and parentheses only):
*{{xpsoc|numf|trunc9134067893e9+trunc123456789}}
*{{xpsoc|numf|(trunc9134067893)e trunc9+trunc123456789}}

For 18-digit integers there are 7 compact expressions:
*{{xpsoc|integer|999|999999999999999}}
*{{xpsoc|integer|9999|99999999999999}}
*{{xpsoc|integer|99999|9999999999999}}
*{{xpsoc|integer|999999|999999999999}}
*{{xpsoc|integer|9999999|99999999999}}
*{{xpsoc|integer|99999999|9999999999}}
*{{xpsoc|integer|999999999|999999999}}

*{{xpsoc|numf|{{integer|999|999999999999999}}}}
*{{xpsoc|numf|{{integer|9999|99999999999999}}}}
*{{xpsoc|numf|{{integer|99999|9999999999999}}}}
*{{xpsoc|numf|{{integer|999999|999999999999}}}}
*{{xpsoc|numf|{{integer|9999999|99999999999}}}}
*{{xpsoc|numf|{{integer|99999999|9999999999}}}}
*{{xpsoc|numf|{{integer|999999999|999999999}}}}

For 17-digit integers there are 9 compact expressions:
*{{xpsoc|integer|99|999999999999999}}
*{{xpsoc|integer|999|99999999999999}}
*{{xpsoc|integer|9999|9999999999999}}
*{{xpsoc|integer|99999|999999999999}}
*{{xpsoc|integer|999999|99999999999}}
*{{xpsoc|integer|9999999|9999999999}}
*{{xpsoc|integer|99999999|999999999}}
*{{xpsoc|integer|999999999|99999999}}
*{{xpsoc|integer|9999999999|9999999}}

*{{xpsoc|numf|{{integer|99|999999999999999}}}}
*{{xpsoc|numf|{{integer|999|99999999999999}}}}
*{{xpsoc|numf|{{integer|9999|9999999999999}}}}
*{{xpsoc|numf|{{integer|99999|999999999999}}}}
*{{xpsoc|numf|{{integer|999999|99999999999}}}}
*{{xpsoc|numf|{{integer|9999999|9999999999}}}}
*{{xpsoc|numf|{{integer|99999999|999999999}}}}
*{{xpsoc|numf|{{integer|999999999|99999999}}}}

For 16-digit integers >= 2^53 there are 11 compact expressions:
*{{xpsoc|integer|9|999999999999999}}
*{{xpsoc|integer|99|99999999999999}}
*{{xpsoc|integer|999|9999999999999}}
*{{xpsoc|integer|9999|999999999999}}
*{{xpsoc|integer|99999|99999999999}}
*{{xpsoc|integer|999999|9999999999}}
*{{xpsoc|integer|9999999|999999999}}
*{{xpsoc|integer|99999999|99999999}}
*{{xpsoc|integer|999999999|9999999}}
*{{xpsoc|integer|9999999999|999999}}
*{{xpsoc|integer|99999999999|99999}}

*{{xpsoc|numf|{{integer|9|999999999999999}}}}
*{{xpsoc|numf|{{integer|99|99999999999999}}}}
*{{xpsoc|numf|{{integer|999|9999999999999}}}}
*{{xpsoc|numf|{{integer|9999|999999999999}}}}
*{{xpsoc|numf|{{integer|99999|99999999999}}}}
*{{xpsoc|numf|{{integer|999999|9999999999}}}}
*{{xpsoc|numf|{{integer|9999999|999999999}}}}
*{{xpsoc|numf|{{integer|99999999|99999999}}}}
*{{xpsoc|numf|{{integer|999999999|9999999}}}}
*{{xpsoc|numf|{{integer|9999999999|999999}}}}
*{{xpsoc|numf|{{integer|99999999999|99999}}}}

Summarizing, we can keep the number of digits of the first parameter fixed at 4:
*{{xpsoc|integer|9199|999999999999999}}
*{{xpsoc|integer|9999|99999999999999}}
*{{xpsoc|integer|9999|9999999999999}}
*{{xpsoc|integer|9999|999999999999}}

*{{xpsoc|numf|{{integer|9199|999999999999999}}}}
*{{xpsoc|numf|{{integer|9999|99999999999999}}}}
*{{xpsoc|numf|{{integer|9999|9999999999999}}}}
*{{xpsoc|numf|{{integer|9999|999999999999}}}}

Alternatively, we can keep the number of digits of the second parameter fixed at any number in the range 10 through 15 (although for manual input that is more cumbersome to count than 4):
*{{xpsoc|integer|919999999|9999999999}}
*{{xpsoc|integer|99999999|9999999999}}
*{{xpsoc|integer|9999999|9999999999}}
*{{xpsoc|integer|999999|999999999}}

*{{xpsoc|numf|{{integer|919999999|9999999999}}}}
*{{xpsoc|numf|{{integer|99999999|9999999999}}}}
*{{xpsoc|numf|{{integer|9999999|9999999999}}}}
*{{xpsoc|numf|{{integer|999999|9999999999}}}}

For smaller numbers these formats are allowed, but not needed; also integer with one parameter is allowed:
*{{xpsoc|integer|9999|99999999999}}
*{{xpsoc|integer|99999|9999999999}}
*{{xpsoc|integer|999999999999999}}

*{{xpsoc|numf|{{integer|9999|99999999999}}}}
*{{xpsoc|numf|{{integer|99999|9999999999}}}}
*{{xpsoc|numf|{{integer|999999999999999}}}}
*{{xpsoc|numf|999999999999999}}

===Division===
If the quotient of two integer-type numbers is an integer, the exact value is returned. Otherwise both integers are rounded to float, and the quotient is rounded to float. 

*{{xpsoc|numfh|1e17+12}}
*{{xpsoc|numfh|(trunc1e17+trunc12)/trunc10}}
*{{xpsoc|numfh|(trunc1e17+trunc10)/trunc10}}

*{{xpsoc|numfh|({{integer|9199|999999999999490}})/trunc10}}
*{{xpsoc|numfh|({{integer|9199|999999999999488}})/trunc10}}
*{{xpsoc|numfh|({{integer|9199|999999999999487}})/trunc10}}
*{{xpsoc|numfh|9199999999999999488/10}}
*{{xpsoc|numfh|9199999999999999487/10}}

*{{xpsoc|numfh|({{integer|9199|999999999999488}})/trunc1e4}}
*{{xpsoc|numfh|({{integer|9199|999999999999487}})/trunc1e4}}
*{{xpsoc|numfh|({{integer|9199|999999999990001}})/trunc1e4}}
*{{xpsoc|numfh|({{integer|9199|999999999990000}})/trunc1e4}}
*{{xpsoc|numfh|({{integer|9199|999999999989999}})/trunc1e4}}

===Mod===
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod10}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod100}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e3}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e4}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e5}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e6}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e7}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e8}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e9}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e10}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e11}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e12}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e13}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e14}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e15}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e16}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e17}}
*{{xpsoc|numfh|({{integer|9199|999999999999999}})mod1e18}}

If p is an integer > 2^53 and q is an integer <=2^53, but p/q is not an integer, regular division involves rounding p to float, and rounding the result to float, together giving a maximum relative error of 2^-52. However, if p is first rounded to a multiple of q the absolute error has a maximum of .5. For a quotient >2^51 this is less.

Examples:
*{{xpsoc|numfh|({{integer|9199|999999999999994}}+trunc5-({{integer|9199|999999999999994}}+trunc5)mod10)/trunc10}}
*{{xpsoc|numfh|({{integer|9199|999999999999995}}+trunc5-({{integer|9199|999999999999995}}+trunc5)mod10)/trunc10}}

==Rounding==
Rounding to float occurs when an explicit number, or the result of an operator which should be of type float,  is mathematically not exactly a float, including the case where the result of an operator is of type integer in principal, but outside of the range of integers.

Rounding occurs to the nearest value:
*{{xpsoc|hex|2^52+(.5-2^-53)}}
*{{xpsoc|hex|2^52+(.5+2^-53)}}
*{{xpsoc|hex|2^52+1+(.5-2^-53)}}
*{{xpsoc|hex|2^52+1+(.5+2^-53)}}

*{{xpsoc|hex|2^2+(2^-51-2^-102)}}
*{{xpsoc|hex|2^2+(2^-51+2^-102)}}
*{{xpsoc|hex|2^2+1*(2^-51-2^-102)}}
*{{xpsoc|hex|2^2+1+(2^-51+2^-102)}}

If two floats are equally near, rounding occurs to the one with least-significant bit 0 ([[w:Rounding#Round_half_to_even|round half to even]]):

*{{xpsoc|hex|2^52+2^-1}}
*{{xpsoc|hex|2^52+1+2^-1}}

*{{xpsoc|hex|2^2+2^-51}}
*{{xpsoc|hex|2^2+2^-50+2^-51}}

*{{xpsoc|hex|2^53-1.5}}
*{{xpsoc|hex|2^53-.5}}

A consequence is that applying "x [[Help:Mod, round, floor, ceil, trunc#Round|round]] 0" for an odd number x with absolute value between 2^52 and 2^53 does not give x but an even number, one more in absolute value. This is because .5 is added, the result is rounded to a float as mentioned, and truncated to an integer (not applicable in this range because it is already an integer).

Similarly, applying "x round -1" in the range where the floats are the even numbers, with x not a multiple of 4, we get x + 5, which is rounded up to x + 6, and then rounded down to a multiple of 10, for example:
*{{xpsoc|numf|12345678901234574round-1}}
Also, applying "x round -2" in the range where the floats are the multiples of 4, we get for example:
*{{xpsoc|numf|22345678901234548round-2}}
etc.

==Chain of calculations==
In the case of a chain of calculations, applying #expr and using the output in another expression may affect the result:
*floats are rounded to 14 digits
*displayed integer-type numbers used in another expression are converted to float, which for large integers involves rounding
*for some representable round numbers, notably some multiples of 100,000, scientific notation is produced, which, if reused in an expression, is not exactly equal to the original number (see [[Manual:Expr parser function syntax#Numbers as output]])

Instead of passing on a number to a template as parameter, an expression can be passed on. Similarly a template can produce an expression instead of a number.

Alternatively for a float [[Template:Num]] can be used to produce a number in almost the full precision which is readable by people as well as being allowed in an expression.

==Power==
For an integer raised to a non-negative integer, the result is exact up to 2^63-1, provided that we use integer type numbers, e.g.:
*{{xpsoc|numf|trunc3^trunc39}}

Floats:

A power of 10 is an exact float if and only if the corresponding power of 5 is, so the largest exponent is {{xpsoc|gives==|num|floor(53*ln2/ln5)}}

For the number 1e22 the [[w:unit in the last place|unit in the last place]] (ULP) is 2^21, while 1e22 is a multiple of 2^22. For the number 1e23 the ULP is 2^24, while 1e23 is an odd multiple of 2^23, so the absolute value of the error is {{xpsoc|gives==|#expr:2^23}}. In fact, to determine the error we can subtract 1024e20 (which is exactly representable): {{xpsoc|hex|1e23-1024e20}}. Then we can add 24e20: {{xpsoc|hex|24e20}} (which is also exactly representable), and get {{xpsoc|hex|(1e23-1024e20)+24e20}}, and {{xpsoc|#expr:(1e23-1024e20)+24e20}}. So 1e23 is "rounded" internally to 99,999,999,999,999,991,611,392. This also follows from:
*{{xpsoc|numf|1e23-8e22-1e22-1e22}}
or
*{{xpsoc|numf|1e23-8e22-1e22-8e21-1e21-8e20-1e20-8e19-1e19-8e18-1e18}}
taking into account that 1e22 and hence also 8e20, etc. are exactly representable, and that a subtraction of positive floats is done exactly if the smaller one is not smaller than half the larger one.

Correspondingly 5^23 is rounded to a value that is one less:
*{{xpsoc|numfh|5^23}}
*{{xpsoc|numfh|trunc5^trunc23}}

For  floats as base and exponent, and a mathematical result that is exactly a float, the result of the power operator seems to be always exact (here shown for powers of powers of 10, but applicable in general):

*{{xpsoc|#expr:1e22-100^11}}
*{{xpsoc|#expr:1e21-1000^7}}
*{{xpsoc|#expr:1e20-1e4^5}}
*{{xpsoc|#expr:1e20^.5-1e10}}
*{{xpsoc|#expr:1e20^.25-1e5}}
*{{xpsoc|#expr:1e16^.125-100}}

Using exp and ln is less accurate (even if they are each also very accurate) because of the rounding of the intermediate results to floats:
*{{xpsoc|#expr:exp(11*ln100)-1e22}}
*{{xpsoc|#expr:exp(5*ln1e4)-1e20}}

Example where the exponent is not exactly a float:
*{{xpsoc|#expr:1e20^.2-1e4}}

If a number of type integer is raised to a power, where the exponent is also a number of type integer, and the result is too large for type integer, rounding is not always to the nearest float, i.e., the rounding error can be larger than if base, exponent, or both, are floats:  
*{{xpsoc|numfh|trunc257^trunc7}} (exact)
*{{xpsoc|numfh|257^7}} (rounded to the nearest float; floats are multiples of 16 in this range, the result is one less than the exact result, which is hex 1.07152323150701*2^56)
*{{xpsoc|numfh|trunc257^trunc8}} (rounded to another float than the nearest; floats are multiples of 4096 in this range, the result is 2049 less than the exact result, which is {{hexs|1.081c3846381c0801|64}})
*{{xpsoc|numfh|257^8}} (rounded to the nearest float; the result is 2047 more than the exact result)
The difference may be due to repeated multiplication, used when both the base and the exponent are of type integer, with, beyond the range of type integer, rounding of intermediate values to float. Thus rounding errors cumulate, while when both the base and the exponent are of type real, rounding to the nearest float occurs, perhaps by the use of extended precision in the power routine:

*{{numfh|trunc257^trunc7}} is rounded to {{numfh|0+trunc257^trunc7}}; multiplied by {{numfh|257}} this gives {{numfh|trunc257^trunc7*257}}

==Reconstruction of a float==
As mentioned, 17 decimal digits are always sufficient to identify a particular float. However, not all floats can be reconstructed by a number in scientific notation:

*{{xpsoc|hex|8234567890123457}}
*{{xpsoc|hex|8.2345678901234569e15}}
*{{xpsoc|hex|8.234567890123457e15}}

This is caused by the fact that such a number is actually an expression involving a multiplication and a power, with intermediate rounding of both factors of the multiplication. In this case the rounding of the significand gives a spacing of the product (before rounding) of 1.78, while the spacing of the floats in this range is 1:
*{{xpsoc|hex|8.2345678901234569}}
*{{xpsoc|hex|8.234567890123457}}
*{{xpsoc|#expr:2^-49*1e15}}

Other example: the number 4.5e15+.5 is an exact float, but written in the form (4.5e16+5)/1e1 the number 4.5e16+5 is rounded to a multiple of 8, hence to 4.5e16+8. Dividing this by 10 is rounded to 4.5e15+1 (too high), while the next lower float is 4.5e16, giving 4.5e15 (too low).

In general, if pq=r then, writing each in binary format with a significand between 1 and 2, we can distinguish two cases: the sum of the exponents of p and q is equal to that of r, or one less. If it is one less, then for fixed q the spacing of the floats r corresponds to values r/q with a spacing greater than the spacing of floats in the range of p, so each can be represented. However, if the sum of the exponents of p and q is equal to that of r, the converse is true. For example, for q=10 the relative spacing is multiplied by .8 for p between 1 and 1.6 times a power of 2, and by 1.6 for p between 1.6 and 2 times a power of 2. Correspondingly, for q=.1 the relative spacing is multiplied by .625 for p between 1 and 1.25 times a power of 2, and by 1.25 for p between 1.25 and 2 times a power of 2. On a double-logarithmic scale there is for every q on average no change in the relative spacing, so if for most numbers the spacing gets larger it is only a little larger, etc..

The conclusion is that in general, to reconstruct a float, a number in scientific notation. (at least for a fixed system of normalisation) is inadequate. We have to use the basic number notation (in the example 8234567890123457) or an expression such as here the misleading 8.234567890123457e15-1:
*{{xpsoc|hex|8.234567890123457e15-1}}

As another example, the first number is not representable in the regular scientific notation (and adding an 18th digit does not help):
*{{xpsoc|hex|.00011345678901234566}}
*{{xpsoc|hex|1.1345678901234564e-4}}
*{{xpsoc|hex|1.13456789012345649e-4}}
*{{xpsoc|hex|1.1345678901234565e-4}}
*{{xpsoc|hex|1.1345678901234566e-4}}

However, the single bit can always be added:
*{{xpsoc|hex|1.1345678901234564e-4+2^-66}}
*{{xpsoc|hex|1.1345678901234564e-4+1e-20}}

==Finding the exact decimal representation of a float==
To find the exact decimal representation of a float in the range from 2^52 through 2^63-1 one can apply trunc, then #expr, here done combinedly with [[Template:Numf]]:
*{{xpsoc|numf|1e17/3}}
*{{xpsoc|numf|1e18/3}}
*{{xpsoc|numf|1e19/3}}

To find the exact decimal representation of a larger float, one can find the largest power of 2 which multiplied by 1e22 (the largest power of 10 that is exactly representable) is less or equal the given float. Subtracting that and repeating this with the difference, we get a binary representation for what remains after cutting off the rightmost 22 digits. Then we can apply the same again to the final difference, now to find the 22nd digit from the right, etc.; as seen above:
*{{xpsoc|numf|1e23-8e22-1e22-8e21-1e21-8e20-1e20-8e19-1e19-8e18-1e18}}
Hence the number is like this 18-digit number, with 5 digits 9 in front: 99,999,{{numf|1e23-8e22-1e22-8e21-1e21-8e20-1e20-8e19-1e19-8e18-1e18}}.

For floats in the range from 2^34 to 2^52 we can take the trunc like above, and add the decimal part, as applied in [[Template:Num/3]]:
*{{xpsoc|numfh|1e16/3}}
*{{xpsoc|numfh|1e15+0.25}}
*{{xpsoc|numfh|1e15+0.1}}
*{{xpsoc|numfh|1e15/3}}
*{{xpsoc|numfh|1e14/3}}
*{{xpsoc|numfh|1e13/3}}
*{{xpsoc|numfh|1e12/3}}
*{{xpsoc|numfh|1e11+.25}}
*{{xpsoc|numfh|1e11/3}}
*{{xpsoc|numfh|2^34+2^-18}}

==Comparisons==
Care should be taken that e.g. {{xpsoc|1=#expr:1e17=1e17+1}}. This means also that if x<=1e17 gives "true", this does not imply that x<1e17+1 gives "true".

==Largest and smallest number==
With a significand between 1 and 2 the maximum exponent is 1023:
*{{xpsoc|#expr:(2-2^-52)*2^1023}}
*{{xpsoc|hex|(2-2^-52)*2^1023}}
*{{xpsoc|#expr:2^1024}}
If an intermediate result is INF the final result depends on the operation:
*{{xpsoc|#expr:2^1024/2}}
*{{xpsoc|#expr:(2^1024)*0}}
*{{xpsoc|#expr:(2^1024)mod3}}
If an intermediate result is [[w:NaN|NAN]] the final result depends on the operation:
*{{xpsoc|#expr:((2^1024)*0)mod3}}*{{xpsoc|#expr:((2^1024)*0)/2}}
*{{xpsoc|#expr:((2^1024)*0)*0}}
*{{xpsoc|#expr:((2^1024)*0)mod3}}
However, INF and NAN cannot be entered directly:
*{{xpsoc|#expr:INF*0}}
*{{xpsoc|#expr:(INF)mod3}}
*{{xpsoc|#expr:(NAN)mod3}}

The smallest positive internal value is 2^-1074, the next lower internal value is 0:
*{{xpsoc|#expr:2^-1074}}
*{{xpsoc|#expr:.51*2^-1074}}
*{{xpsoc|#expr:.5*2^-1074}}
*{{xpsoc|hex|2^-1074}}
*{{xpsoc|hex|.51*2^-1074}}
*{{xpsoc|hex|.5*2^-1074}}

Note that for entering this number one can use .5e-323, but not 5e-324:
*{{xpsoc|hex|.5e-323}}
*{{xpsoc|hex|5e-324}}

With a significand between 1 and 2 using the full 53 bits the smallest exponent is -1022:
*{{xpsoc|hex|2^-1020-(2-2^-52)*2^-1021}}
*{{xpsoc|hex|2^-1021-(2-2^-52)*2^-1022}}
*{{xpsoc|hex|2^-1022-(2-2^-52)*2^-1023}}
*{{xpsoc|#expr:(2^-1022-(2-2^-52)*2^-1023)}}
With this exponent the smallest number is:
*{{xpsoc|#expr:2^-1022}}
*{{xpsoc|hex|2^-1022}}

Lower numbers are [[w:Denormal number|denormal numbers]]. They use the lowest value of the exponent register, which would correspond to an exponent of -1023, but they represent values with an exponent of -1022 and a significand with 0 instead of 1 before the point (this requires a separate exponent value because the bit before the point is implicit, not an actual storage location). Thus the least significant bit for numbers below 2^-1021 is 2^-1074=.5e-323 (do not enter it as 5e-324, as this gives 0, even though {{xpsoc|#expr:2^-1074}}
), the smallest positive internal value. As a result the difference of two different internal numbers is never rounded to 0. 

With this lowest register value for the exponent the value 0 is represented by all bits being equal to 0.

Thus of the 2048 available values of the exponent register, 2047 are used for finite positive values and 0, leaving the largest value for INF and NAN.

== Output format ==
The MediaWiki software simply passes on the literal result of the php computation, except that boolean values are changed to 1 and 0. Therefore the format can depend on the server.

A number of type integer is displayed without rounding and in ordinary decimal notation:
*{{xpsoc|#expr:trunc(2^52)}}
*{{xpsoc|#expr:-trunc(2^52)}}

A number of type float is rounded to 14 digits. If a positive number is multiplied by -1 the format remains the same, except that "-" is prefixed. The following applies to positive numbers.

No trailing decimals are produced. In the case of scientific format the significand is greater than or equal to 1 and less than 10. The E is written as capital. In the case of a positive exponent "+" is prefixed. The exponent is 1 to 3 digits (it has no leading zeros). Numbers less than 1e-4 or greater than or equal to 1e18 are in scientific format.

:''Much of what follows was written in 2010, when there were inconsistencies in the use of scientific format, which according to http://bugs.php.net/43053 were due to a bug in the [[w:Zend Engine|Zend Engine]]. This bug seems to have been fixed. The live examples below may show different results than before. The conclusions may have to be updated.''

Numbers greater than or equal to 1e-4 which, after rounding to 14 digits, are not a multiple of 100,000 (which can only apply for numbers less than 1e18), are in ordinary decimal format. 

For numbers which, after rounding to 14 digits, are multiples of 100,000 in the range 100,000 through 99,999,999,900,000, the criterion for using scientific format is not clear, except that if for the exact multiple of 100,000  scientific format is produced, then also for that number multiplied by a power of 10. Even for numbers which are equal after rounding to 14 digits both formats may occur. For exact multiples of 100,000 below 1,200,000 ordinary decimal notation is used.

Examples:
*{{xpsoc|#expr:2^52}}
*{{xpsoc|#expr:-(2^52)}}
*{{xpsoc|#expr:1/7}}

*{{xpsoc|#expr:1e-6}}
*{{xpsoc|#expr:1e-5}}
*{{xpsoc|#expr:1e-4}}
*{{xpsoc|#expr:1e-3}}
*{{xpsoc|#expr:1e-2}}
*{{xpsoc|#expr:1e-1}}
*{{xpsoc|#expr:1e-0}}
*{{xpsoc|#expr:1e1}}
*{{xpsoc|#expr:1e2}}
*{{xpsoc|#expr:1e3}}
*{{xpsoc|#expr:1e4}}
*{{xpsoc|#expr:1e5}}
*{{xpsoc|#expr:1e6}}
*{{xpsoc|#expr:1e7}}
*{{xpsoc|#expr:1e8}}
*{{xpsoc|#expr:1e9}}
*{{xpsoc|#expr:1e10}}
*{{xpsoc|#expr:1e11}}
*{{xpsoc|#expr:1e12}}
*{{xpsoc|#expr:1e13}}
*{{xpsoc|#expr:1e14}}

*{{xpsoc|#expr:12e-6}}
*{{xpsoc|#expr:12e-5}}
*{{xpsoc|#expr:12e-4}}
*{{xpsoc|#expr:12e-3}}
*{{xpsoc|#expr:12e-2}}
*{{xpsoc|#expr:12e-1}}
*{{xpsoc|#expr:12e-0}}
*{{xpsoc|#expr:12e1}}
*{{xpsoc|#expr:12e2}}
*{{xpsoc|#expr:12e3}}
*{{xpsoc|#expr:12e4}}
*{{xpsoc|#expr:12e5}}
*{{xpsoc|#expr:12e6}}
*{{xpsoc|#expr:12e7}}
*{{xpsoc|#expr:12e8}}
*{{xpsoc|#expr:12e9}}
*{{xpsoc|#expr:12e10}}
*{{xpsoc|#expr:12e11}}
*{{xpsoc|#expr:12e12}}
*{{xpsoc|#expr:12e13}}

*{{xpsoc|#expr:123e-7}}
*{{xpsoc|#expr:123e-6}}
*{{xpsoc|#expr:123e-5}}
*{{xpsoc|#expr:123e-4}}
*{{xpsoc|#expr:123e-3}}
*{{xpsoc|#expr:123e-2}}
*{{xpsoc|#expr:123e-1}}
*{{xpsoc|#expr:123e-0}}
*{{xpsoc|#expr:123e1}}
*{{xpsoc|#expr:123e2}}
*{{xpsoc|#expr:123e3}}
*{{xpsoc|#expr:123e4}}
*{{xpsoc|#expr:123e5}}
*{{xpsoc|#expr:123e6}}
*{{xpsoc|#expr:123e7}}
*{{xpsoc|#expr:123e8}}
*{{xpsoc|#expr:123e9}}
*{{xpsoc|#expr:123e10}}
*{{xpsoc|#expr:123e11}}
*{{xpsoc|#expr:123e12}}
*{{xpsoc|#expr:123e13}}

The function formatnum adds commas (on the left of the point only), but does not convert from or to scientific format:

*{{xpsoc|formatnum:1234567.890123}}
*{{xpsoc|formatnum:1234567.890123E16}}

The number output is suitable for many other calculation programs, also the scientific notation. In that sense output like 6E23 is more convenient than 6{{e|23}}.

===Categorizing floats by the mathematical value of the string produced by expr===
Most strings produced by expr (excluding error messages) each represent a unique mathematical value. However, as we have seen, for some multiples of 100,000 two strings occur, for example <code>4100000</code> and <code>4.1E+6</code>. As we have seen in this case they even evaluate to different floats. However, for both strings <code>#expr</code> gives <code>4.1E+6</code>, so for any two floats ''f<sub>1</sub>'' and ''f<sub>2</sub>'' for which <code><nowiki>{{#expr:</nowiki></code> ''f<sub>1</sub>'' <code>}}</code>  and <code><nowiki>{{#expr:</nowiki></code> ''f<sub>2</sub>'' <code>}}</code> mathematically both represent 4100000, the following gives "true":
*<code><nowiki>{{#ifexpr:{{#expr:{{#expr:</nowiki></code> ''f<sub>1</sub>'' <code><nowiki>}}}}={{#expr:{{#expr:</nowiki></code> ''f<sub>2</sub>'' <code><nowiki>}}}}|true|false}}</nowiki></code>
Also we can use:
*<code><nowiki>{{#ifeq:{{#expr:</nowiki></code> ''f<sub>1</sub>'' <code><nowiki>}}|{{#expr:</nowiki></code> ''f<sub>2</sub>'' <code><nowiki>}}|true|false}}</nowiki></code>

Examples:
*<code><nowiki>{{#ifexpr:4100000=4.1E+6|true|false}}</nowiki></code> → {{#ifexpr:4100000=4.1E+6|true|false}}
*<code><nowiki>{{#ifexpr:{{#expr:4100000}}={{#expr:4.1E+6}}|true|false}}</nowiki></code> → {{#ifexpr:{{#expr:4100000}}={{#expr:4.1E+6}}|true|false}}
*<code><nowiki>{{#ifeq:4100000|4.1E+6|true|false}}</nowiki></code> → {{#ifeq:4100000|4.1E+6|true|false}}
*<code><nowiki>{{#ifexpr:{{#expr:4100000}}={{#expr:4100000.0000001}}|true|false}}</nowiki></code> → {{#ifexpr:{{#expr:4100000}}={{#expr:4100000.0000001}}|true|false}}
*<code><nowiki>{{#ifeq:4100000|4100000.0000001|true|false}}</nowiki></code> → {{#ifeq:4100000|4100000.0000001|true|false}}
The experiments suggest that this applies in general.

Another method is:
*<code><nowiki>{{#ifexpr:abs({{#expr:</nowiki></code> ''f<sub>1</sub>'' <code><nowiki>}}-{{#expr:</nowiki></code> ''f<sub>2</sub>'' <code><nowiki>}})e15<=abs(</nowiki></code> ''f<sub>1</sub>'' <code><nowiki>)|true|false}}</nowiki></code>

or, if ''f<sub>2</sub>'' is known to be nonzero:
*<code><nowiki>{{#ifexpr:abs({{#expr:</nowiki></code> ''f<sub>1</sub>'' <code><nowiki>}}/{{#expr:</nowiki></code> ''f<sub>2</sub>'' <code><nowiki>}}-1)e15<1|true|false}}</nowiki></code>

Examples:
*<code><nowiki>{{#ifexpr:abs(4100000-4.1E+6)e15<=abs4100000|true|false}}</nowiki></code> → {{#ifexpr:abs(4100000-4.1E+6)e15<=abs4100000|true|false}}
*<code><nowiki>{{#ifexpr:abs(4100000-4100000.0000001)e15<=abs4100000|true|false}}</nowiki></code> → {{#ifexpr:abs(4100000-4100000.0000001)e15<=abs4100000|true|false}}
*<code><nowiki>{{#ifexpr:abs(4100000/4.1E+6-1)e15<=1|true|false}}</nowiki></code> → {{#ifexpr:abs(4100000/4.1E+6-1)e15<=1|true|false}}
*<code><nowiki>{{#ifexpr:abs(4100000/4100000.0000001-1)e15<=1|true|false}}</nowiki></code> → {{#ifexpr:abs(4100000/4100000.0000001-1)e15<=1|true|false}}

====Application====
One method of producing a consistent number format involves deciding whether the mathematical value of a string produced by expr is a multiple of 100,000: if so, the number divided by 100,000, followed by 00000 is produced; if not, #expr is used.

With exact computations this could be done with the condition <code>({{{1}}}/1e5round0)e5={{{1}}}</code>, where <code>{{{1}}}</code> is the given string. Rounding errors are small enough that by itself the comparison does not give false positives, but without special provisions we get false negatives. Thus we have to prevent false negatives without introducing false positives.

The left-hand side evaluates to an exact multiple of 100,000, provided that the number is in a range where that multiple is an exact float. However, the right-hand side may for example be 4.1E+6, which, as we have seen, does not evaluate to 4,100,000. If <code>{{{1}}}</code> is not 0 or -0, we can use for example the condition 
*<code>abs(({{{1}}}/1e5round0)e5/{{{1}}}-1)e15<1</code>
This bound of 1e-15 on the relative difference is larger than the combined effect of some relative rounding errors of up to 1.1e-16 each, while smaller than the relative spacing of 14-digit numbers, which is at least 1e-14.

See also [[Template:Expr]] with [[Template:Expr/1]], and [[w:Template:Rndfrac]].

====Very small numbers====
For numbers which in absolute value are less than 1e-310 every float has a different output string (each representing a different mathematical value). and multiple 14-digit numbers are rounded to the same float:
*{{xpsoc|#expr:9.999999999999e-311}}
*{{xpsoc|#expr:9.9999999999991e-311}}
*{{xpsoc|#expr:9.9999999999992e-311}}
*{{xpsoc|#expr:9.9999999999993e-311}}
*{{xpsoc|#expr:9.9999999999994e-311}}
*{{xpsoc|#expr:9.9999999999995e-311}}
*{{xpsoc|#expr:9.9999999999996e-311}}
*{{xpsoc|#expr:9.9999999999997e-311}}
*{{xpsoc|#expr:9.9999999999998e-311}}
*{{xpsoc|#expr:9.9999999999999e-311}}
*{{xpsoc|#expr:1e-310}}
*{{xpsoc|#expr:1.0000000000001e-310}}
*{{xpsoc|#expr:1.0000000000002e-310}}
*{{xpsoc|#expr:1.0000000000003e-310}}
*{{xpsoc|#expr:1.0000000000004e-310}}

==See also==
*[[Help:Extension:ParserFunctions##expr]]
*[[Manual:Expr parser function syntax]]
*[[Template:Expr]]
*[[Manual:Representation of numbers in expr parser function/multiples of 100,000]]

[[Category:Parser manuals]]