View source for Help:Calculation

{{h:h|editor toc}}

:''The accuracy and format of numeric results varies with the server. Currently the results produced by Wikimedia servers seem to be uniform.''

The functions #expr: and #ifexpr: of MediaWiki extension [[mw:Extension:ParserFunctions|ParserFunctions]] evaluate numerical [[w:Expression (programming)|expressions]], and also boolean expressions involving numbers and booleans (not strings). The syntax is

:<nowiki>{{</nowiki> #expr: ''expression'' }}

Spaces are not needed, except between words (for operators and constants). Inside numbers no spaces are allowed.

==General==
An expression is a string representing a [[w:tree structure|tree structure]] with [[w:Data type|type]]/[[w:Value (computer science)|value]] pairs as nodes, with [[w:Binary operation|binary operators]] in [[w:Infix notation|infix notation]], [[w:Unary operation|unary operators]] in [[w:Polish notation|prefix notation]], and end nodes represented by numbers and constants. Letters in operators and names of constants are case-insensitive.

The ParserFunctions software determines which operators and constants, and what numbers, are supported. The e in scientific notation and the sign of a number are treated as operators, the supported literal numbers are unsigned numbers in ordinary decimal format. The ParserFunctions software also determines the precedence of the operators and the error messages, and it converts all literal numbers to type float. 

For the rest the ParserFunctions software just defines the operators in terms of [[w:PHP|PHP]] functions and operators, and any type conversions and pecularities of the operators are properties of these PHP functions and operators themselves. Also, the format of the result is entirely determined by PHP.

The data types are the PHP data types [http://www.php.net/manual/en/language.types.float.php float] ([[w:Double precision floating-point format|double precision floating-point format]]) and [http://www.php.net/manual/en/language.types.integer.php integer] (64-bit [[w:Integer_(computer_science)|integer]]). The range for type integer is from -(2^63) = {{formatnum:{{#expr:trunc(1-2^63)}}}} through 2^63 - 1 = {{formatnum:{{#expr:(trunc2)^(trunc62)+((trunc2)^(trunc62)-(trunc1))}}}}. Type float allows fractions and very large  numbers, but only in the range -(2^52) = {{formatnum:{{#expr:trunc-(2^52)}}}} through (2^52) = {{formatnum:{{#expr:trunc(2^52)}}}} all integer values can be exactly represented in type float (see [[Help:Calculation accuracy]]).

[[w:Type_system#Dynamic_typing|Dynamic typing]] is applied. The end nodes are all of type float (as mentioned, numbers are converted to float; this applies even for numbers with an integer value and format). The data type of the result of an operation depends on the operator, and for some operators on the type(s) of the argument(s), and in some cases on their value(s). If according to these rules the result is of type float,  any argument of type integer is converted to float before the operation, and the result is also rounded to float:
*{{xpsoc|numfh|(trunc2^trunc62+trunc512)-2^62}}
*{{xpsoc|numfh|(trunc2^trunc62+trunc512)+(trunc2^trunc62+trunc1535)}}
*{{xpsoc|numfh|2^63+2047}}

Apart from that, a numerical value outside the range of type integer is converted to float, except in the case of trunc (and mod, which involves applying trunc to the arguments first).

There are 31 operators (excluding two synonyms), two constants, and the unsigned numbers in ordinary decimal notation.

== Operators, numbers, and constants ==

Since literal numbers are of type float, trunc is sometimes used in the examples to construct an integer-type argument, to demonstrate the result of an operator for this case. 

{| class="wikitable sortable"
! ''Operator''
! ''<abbr title="number of arguments">Args</abbr>''
! ''Operation''
! ''PHP''
! ''Data type''
! ''<abbr title="Precedence">Prio</abbr>''
! ''Examples''
|-
| <code>'''-'''</code> || 1
| [[w:Unary operation#Unary negative and positive|unary '''<tt>-</tt><code>''' sign]]  (negation)
| [http://php.net/manual/en/language.operators.arithmetic.php -] || same as argument|| {{nts|10}} ||
{| class="wikitable"
{{xpettu|-|12}}
{{xpettu|-|trunc12}}
{{xpettu|-|trunc(-2^63)}}
|}
|-
| '''<code>e<code>''' between subexpressions|| 2 || *10^ || [http://php.net/manual/en/language.operators.arithmetic.php *] [http://php.net/manual/en/function.pow.php pow] (10,..) || float unless the factor on the left is of type integer and the exponent is non-negative and of type integer || {{nts|10}}

|
{| class="wikitable"
{{xpettb|2|e|3}}
{{xpettb|-2.3|e|-4}}
{{xpettb|(trunc2)|e|(trunc-3)}}
{{xpettb|(trunc2)|e|(trunc0)}}
{{xpettb|(trunc2)|e|(trunc18)}}
{{xpettb|(trunc2)|e|(trunc19)}}
{{xpett|6e(5-2)e-2}}
{{xpett|1e.5}}
|}

Wrong:
{| class="wikitable"
|{{xpett|e4}}
|}
|-
| '''<code>exp<code>''' || 1
| [[w:Exponential function|exponential function e<sup>x</sup>]]
| [http://php.net/manual/en/function.exp.php exp] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|exp|43}}
{{xpettu|exp| trunc0}}
{{xpettu|exp|709}}
{{xpettu|exp|-744}}
|}

Compare:
{| class="wikitable"
|{{xpett|e^43}}
|-
|{{xpett|trunc exp43}}
|}
|-
| '''<code>ln<code>''' || 1
| [[w:Natural logarithm|natural logarithm]]
| [http://php.net/manual/en/function.log.php <sup>log</sup>] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|ln|2}}
{{xpettu|ln| trunc1}}
{{xpettu|ln|8.9e307}}
{{xpettu|ln|.5e-323}}
|}
Hence, the common logarithm of e.g. 2:
{| class="wikitable"
|{{xpett|ln2/ln10}}
|}
|-
| '''<code>abs<code>''' || 1
| [[w:Absolute value|absolute value]]
| [http://php.net/manual/en/function.abs.php abs] || same as argument || {{nts|9}} ||
{| class="wikitable"
{{xpettu|abs|-2}}
{{xpettu|abs| trunc-2}}
{{xpettu|abs| trunc-2^63}}
|}
|-
| '''<code>trunc<code>''' || 1
| [[w:Truncation|truncation]]
| [http://php.net/manual/en/language.types.integer.php#language.types.integer.casting (int)], i.e. [[w:Type conversion|type-casting]] to integer || integer || {{nts|9}} ||
{| class="wikitable"
{{xpettu|trunc|1.2}}
{{xpettu|trunc|1.8}}
{{xpettu|trunc|-1.2}}
{{xpettu|trunc|(-2^64+1e5)}}
{{xpettu|trunc|(-2^63+1e5)}}
{{xpettu|trunc|(2^63)}}
{{xpettu|trunc|(2^63+1e5)}}
{{xpettu|trunc|(2^64+1e5)}}
|}
|-
| '''<code>floor<code>''' || 1
| [[w:Floor function|floor function]]
| [http://php.net/manual/en/function.floor.php floor] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|floor|1.2}}
{{xpettu|floor|-1.2}}
{{xpettu|floor| trunc3}}
|}
|-
| '''<code>ceil<code>''' || 1
| [[w:Ceiling function|ceiling function]]
| [http://php.net/manual/en/function.ceil.php ceil] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|ceil|1.2}}
{{xpettu|ceil|-1.2}}
{{xpettu|ceil| trunc3}}
|}
|-
| '''<code>sin<code>''' || 1
| [[w:Sine function|sine]]
| [http://php.net/manual/en/function.sin.php sin] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|sin|.1}}
{{xpettu|sin| trunc1}}
|}
With an angle in degrees, e.g. 30°:
{| class="wikitable"
|{{xpett|sin(30*pi/180)}}
|}
|-
| '''<code>cos<code>''' || 1
| [[w:Cosine function|cosine]]
| [http://php.net/manual/en/function.cos.php cos] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|cos|.1}}
{{xpettu|cos| trunc1}}
|}
|-
| '''<code>tan<code>''' || 1
| [[w:Tangent function|tangent]]
| [http://php.net/manual/en/function.tan.php tan] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|tan|.1}}
{{xpettu|tan| trunc1}}
|}
|-
| '''<code>asin<code>''' || 1
| [[w:Arcsine|arcsine]]
| [http://php.net/manual/en/function.asin.php asin] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|asin|.1}}
{{xpettu|asin| trunc1}}
|}
|-
| '''<code>acos<code>''' || 1
| [[w:Arccosine|arccosine]]
| [http://php.net/manual/en/function.acos.php acos] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|acos|.1}}
{{xpettu|acos| trunc1}}
{{xpettu|2*|acos 0}}
|}
|-
| '''<code>atan<code>''' || 1
| [[w:Arctangent|arctangent]]
| [http://php.net/manual/en/function.atan.php atan] || float || {{nts|9}} ||
{| class="wikitable"
{{xpettu|atan|.1}}
{{xpettu|atan| trunc1}}
{{xpettu|4*|atan 1}} 
|}
|-
| '''<code>not<code>''' || 1
| [[w:Negation|negation]], logical NOT
| [http://www.php.net/manual/en/language.operators.logical.php !] || integer (1 or 0) || {{nts|9}} ||
{| class="wikitable"
{{xpettu|not|0}}
{{xpettu|not|1}}
{{xpettu|not|2}}
{{xpettu|not| trunc1}}
|}
|-
| '''<code>^<code>''' || 2
| [[w:Exponentiation|exponentiation]] (power)
| [http://php.net/manual/en/function.pow.php pow] || float unless the base is of type integer and the exponent is non-negative and of type integer || {{nts|8}} ||
{| class="wikitable"
{{xpettb|2|^|3}}
{{xpettb|-2|^|3}}
{{xpettb|-2|^|4}}
{{xpettb|(trunc2)|^|(trunc-3)}}
{{xpettb|(trunc2)|^|(trunc0)}}
{{xpettb|(trunc2)|^|(trunc62)}}
{{xpettb|(trunc2)|^|(trunc63)}}
{{xpettb|(-2)|^|1.2}}
{{xpettb|(-2)|^|.5}}
|}
|-
| '''<code>*<code>''' || 2
| [[w:Multiplication|multiplication]]
| [http://php.net/manual/en/language.operators.arithmetic.php *] || integer if both arguments are integer, otherwise float || {{nts|7}} ||
{| class="wikitable"
{{xpettb|2|*|3}}
{{xpettb|(trunc2)|*|3}}
{{xpettb|2|*|trunc3}}
{{xpettb|(trunc2)|*|trunc3}}
{{xpettb|(trunc1e10)|*|trunc1e9}}
|}
|-
| '''<code>/<code>''' (also written '''div''') || 2
|| [[w:Division (mathematics)|division]] (div is not integer division<ref name="divmod">'''<code>div</code>''' and '''<code>mod</code>''' are different from all programming languages, see [[bugzilla:6068]]</ref>)
| [http://php.net/manual/en/language.operators.arithmetic.php /] || float, unless both arguments are integer and the mathematical result is an integer || {{nts|7}} ||
{| class="wikitable"
{{xpettb|6|/|3}}
{{xpettb|(trunc6)|/|3}}
{{xpettb|2|/|trunc6}}
{{xpettb|(trunc6)|/|trunc3}}
{{xpettb|(trunc6)|/|trunc4}}
|}
|-
| '''<code>mod<code>''' || 2
| [[w:Modulo operation|modulo]] operation,&#160;remainder&#160;of&#160;division after truncating both operands to an integer.<ref name="divmod"/>
| [http://php.net/manual/en/language.operators.arithmetic.php %] || integer || {{nts|7}} ||
{| class="wikitable"
{{xpettb|30|mod|7}}
{{xpettb|-30|mod|7}}
{{xpettb|30|mod|-7}}
{{xpettb|-30|mod|-7}}
{{xpettb|30.5|mod|7.9}}
|}
|-
| '''<code>+</code>''' || 2
|| [[w:Addition|addition]]
| [http://php.net/manual/en/language.operators.arithmetic.php +] || integer if both arguments are integer, otherwise float || {{nts|6}} ||
{| class="wikitable"
{{xpettb|2|+|3}}
{{xpettb|(trunc2)|+|3}}
{{xpettb|2|+|trunc3}}
{{xpettb|(trunc2)|+|trunc3}}
{{xpettb|(trunc7e18)|+|trunc4e18}}
|}
|-
| '''<code>-</code>''' || 2
|| [[w:Subtraction|subtraction]]
| [http://php.net/manual/en/language.operators.arithmetic.php -] || integer if both arguments are integer, otherwise float || {{nts|6}} ||
{| class="wikitable"
{{xpettb|3|-|2}}
{{xpettb|(trunc3)|-|2}}
{{xpettb|2|-|trunc2}}
{{xpettb|(trunc3)|-|trunc2}}
{{xpettb|(trunc-7e18)|-|trunc4e18}}
|}
|-
| '''<code>round<code>''' || 2
|| [[w:rounding|rounds off]] the number on the left to a multiple of 1/10 raised to a power, with the exponent equal to the truncated value of the number given on the right 
| [http://php.net/manual/en/function.round.php round] || float || {{nts|5}} ||
{| class="wikitable"
{{xpettb|9.876|round|2}}
{{xpettb|(trunc1234)|round| trunc-2}}
{{xpettb|4.5|round|0}}
{{xpettb|-4.5|round|0}}
{{xpettb|46.857|round|1.8}}
{{xpettb|46.857|round|-1.8}}
|}
|-
| '''<code>=<code>''' || 2
|| [[w:Equality (mathematics)|equality]] (numerical incl. logical, not for strings)
| [http://php.net/manual/en/language.operators.comparison.php ==] || integer (1 or 0) || {{nts|4}} ||
{| class="wikitable"
{{xpettb|3.0|{{=}}|3}}
{{xpettb|3.1|{{=}}|3}}
{{xpettb|3.0|{{=}}|trunc3}}
{{xpettb|3.1|{{=}}|trunc3}}
{{xpettb|1e16|{{=}}|trunc(1e16)}}
{{xpettb|1e16|{{=}}|trunc(1e16)+trunc1}}
{{xpettb|trunc(1e16)|{{=}}|trunc(1e16)+trunc1}}
|}

wrong:
{| class="wikitable"
|{{xpett|a{{=}}a}}
|}
|-
| '''<code>&lt;&gt;<code>''' (also written '''!=''') || 2
| [[w:Inequality|inequality]], logical ''xor'';  not for strings  (negation of =)
| [http://php.net/manual/en/language.operators.comparison.php !=] || integer (1 or 0) || {{nts|4}} ||
{| class="wikitable"
{{xpettb|3|<>|3}}
{{xpettb|3|<>|4}}
|}

|-
| '''<code>&lt;<code>''' || 2
|| [[w:Inequality (mathematics)|less than]] (not for ordering of strings)
| [http://php.net/manual/en/language.operators.comparison.php <] || integer (1 or 0) || {{nts|4}} ||
{| class="wikitable"
{{xpettb|3|<|3}}
{{xpettb|3|<|4}}
{{xpettb|2.9|<|3}}
{{xpettb|3.0|<|3}}
{{xpettb|2.9|<|trunc3}}
{{xpettb|3.0|<|trunc3}}
{{xpettb|1e16|<|trunc(1e16)+trunc1}}
|}

wrong:
{| class="wikitable"
{{xpettb|a|<|b}}
|}
|-
| '''<code>&gt;<code>''' || 2
|| [[w:Inequality (mathematics)|greater than]] (same as <, with arguments reversed)
| [http://php.net/manual/en/language.operators.comparison.php >] || integer (1 or 0) || {{nts|4}} ||
{| class="wikitable"
{{xpettb|4|>|3}}
{{xpettb|3|>|3}}
|}
|-
| '''<code>&lt;=<code>''' || 2
| [[w:Inequality (mathematics)|less than or equal to]] (same as >=, with arguments reversed)
| [http://php.net/manual/en/language.operators.comparison.php <=] || integer (1 or 0) || {{nts|4}} ||
{| class="wikitable"
{{xpettb|3|<{{=}}|4}}
{{xpettb|3|<{{=}}|3}}
|}
|-
| '''<code>&gt;=<code>''' || 2
| [[w:Inequality (mathematics)|greater than or equal to]] (negation of <)
| [http://php.net/manual/en/language.operators.logical.php >=] || integer (1 or 0) || {{nts|4}} ||
{| class="wikitable"
{{xpettb|4|>{{=}}|3}}
{{xpettb|3|>{{=}}|3}}
|}
|-
| '''<code>and<code>''' || 2
| [[w:Logical conjunction|logical AND]]
| [http://php.net/manual/en/language.operators.logical.php &&] || integer (1 or 0) || {{nts|3}} ||
{| class="wikitable"
{{xpettb|3|and|4}}
{{xpettb|-3|and|0}}
{{xpettb|0|and|4}}
{{xpettb|0|and|0}}
|}
|-
| '''<code>or<code>''' || 2
| [[w:Logical disjunction|logical OR]]
| [http://php.net/manual/en/language.operators.logical.php <nowiki>||</nowiki>] || integer (1 or 0) || {{nts|2}} ||
{| class="wikitable"
{{xpettb|3|or|4}}
{{xpettb|-3|or|0}}
{{xpettb|0|or|4}}
{{xpettb|0|or|0}}
|}
|-
| '''<code>+<code>''' || 1
| [[w:Unary operation#Unary negative and positive|unary '''<tt>+</tt><code>''' sign]]
| (nothing) || same as argument || n.a. ||
{| class="wikitable"
{{xpettu|+|1}}
{{xpettu|+|-1}}
{{xpettu|+|trunc1}}
|}
|-
| (number) || 0
| unsigned number in ordinary decimal notation (unary plus and minus and e are treated as operators, see elsewhere in this table) || [http://nl.php.net/manual/en/function.floatval.php floatval] || float || n.a.
|
{| class="wikitable"
| {{xpett|1234567890123456789}}
|-
| {{xpett|123456789.0123456789}}
|}
|-
| '''<code>e<code>''' as subexpression || 0
| constant [[w:e (mathematical constant)|e]] || [http://php.net/manual/en/function.exp.php exp](1) || float || n.a.
|
{| class="wikitable"
| {{xpett|e}}
|}
|-
| '''<code>pi<code>''' || 0
| constant [[w:pi|π]] || [http://php.net/manual/en/function.pi.php pi]() || float || n.a.
|
{| class="wikitable"
| {{xpett|pi}}
|}
|}

Logical operators return 1 for true and 0 for false, and interpret 0 as false and any other number as true. Thus {{xpd0|d=|#expr: (2 < 3) + 1}}. Note that "and" and "or" work with #expr and #ifexpr only; for use with #if, #ifeq, and #ifexist, use 1 as then-text and 0 as else-text, and combine results with "and" and "or" in an outer #expr or #ifexpr. Instead of <nowiki>{{ #expr: {{#if:{{{a}}}|1|0}} or {{#if:{{{b}}}|1|0}} }} we can also use {{#if:{{{a}}}{{{b}}}|1|0}}}}</nowiki>. For negation, simply subtract from 1 or interchange then- and else-part.

Precedence is indicated in the table, a higher number means that the operator is applied first. Examples (">" refers to going before, "~" means application from left to right):
*e > floor, not, etc.: {{xpsoc|#expr:floor1.5e1}}, {{xpsoc|#expr:not0e1}} 
*floor > ^: {{xpsoc|#expr:floor1.5^2}} 
*^ > *: {{xpsoc|#expr:2*3^2}} 
*<nowiki>*</nowiki> ~ / ~ mod: {{xpsoc|#expr:12/3*2}}, {{xpsoc|#expr:111/3mod10}}, {{xpsoc|#expr:358mod10*2}}, 
*<nowiki>*</nowiki> > +, -: {{xpsoc|#expr:2+3*4}}, {{xpsoc|#expr:2-3*4}}
*+ ~ -: {{xpsoc|#expr:6-2+3}}, {{xpsoc|#expr:-2+3}}
*+, - > round: {{xpsoc|#expr:1.234round2-1}}
*round > = etc.: {{xpsoc|1=#expr:1.23=1.234round2}}
*= etc. > and: {{xpsoc|1=#expr:1 and 2=1}}
*and > or: {{xpsoc|1=#expr:1 or 1 and 0}}

In the case of equal precedence number, evaluation is from left to right:
*{{xpsoc|#expr:12/2*3}}
*{{xpsoc|#expr:3^3^3}}

Parentheses can force a different precedence: {{xpsoc|#expr:(2+3)*4}}

Blank spaces are good for readability but not needed for working properly, except between words (including "e"), and not allowed within numbers:
*{{xpd0|d=|#expr:7mod3}}
*{{xpd0|d=|#expr:7.5round0}}
*{{xpd0|d=|#expr:0and1}}
*{{xpd0|d=|#expr:0or not0}}
*{{xpd0|d=|#expr:0ornot0}}
*{{xpd0|d=|#expr:123 456}}
*{{xpd0|d=|#expr:not not3}}
*{{xpd0|d=|#expr:notnot3}}

*{{xpd0|d=|#expr:---2}}
*{{xpd0|d=|#expr:-+-2}}
*{{xpd0|d=|#expr:2*-3}}
*{{xpd0|d=|#expr:-not-not-not0}}
*{{xpd0|d=|#expr:2*/3}}
*{{xpd0|d=|#expr:sinln1.1}}
*{{xpd0|d=|#expr:sin ln1.1}}

For scientific notation e is treated as an operator. An e between subexpressions works just like *10^, except that together with the unary minus, it has the highest precedence, e.g. before a separate ^, and that the implicit 10 is of type integer, not float. An e as subexpression (i.e., with an each side either nothing or an operator) is Euler's constant. An e with on one side nothing or an operator and on the other side a subexpression gives an error message.

==Transitivity==
For comparing a number of type float with one of type integer, the integer is converted to float. Therefore the operators =, <= and >= are not [[w:Transitive relation|transitive]] with mixed types:
*{{xpsoc|1=#expr:trunc1e16=1e16}}
*{{xpsoc|1=#expr:1e16=trunc1e16+trunc1}}
*{{xpsoc|1=#expr:trunc1e16=trunc1e16+trunc1}}

*{{xpsoc|1=#expr:trunc1e16>=1e16}}
*{{xpsoc|1=#expr:1e16>=trunc1e16+trunc1}}
*{{xpsoc|1=#expr:trunc1e16>=trunc1e16+trunc1}}

Similarly, a >= b and b = c does not imply a >=c:
*{{xpsoc|1=#expr:trunc1e16>=1e16}}
*{{xpsoc|1=#expr:1e16=trunc1e16+trunc1}}
*{{xpsoc|1=#expr:trunc1e16>=trunc1e16+trunc1}}

However, < and > ''are'' transitive.

==Monotonicity==
In division of numbers of type integer, a small change in the dividend can change the type of the result. Therefore, if the absolute value of the result is greater than 2^53, it is not always a [[w:Monotonic function|monotonic function]] of the dividend:

*{{xpsoc|numf|(trunc1e18-trunc2)/trunc3}}
*{{xpsoc|numf|(trunc1e18-trunc1)/trunc3}}
*{{xpsoc|numf|trunc1e18/trunc3}}

[[Template:Divint]] rectifies this.

==Numbers as input==
Leading zeros are allowed, as well as a trailing decimal point (for an integer) and trailing zeros in a number with a decimal point.

*{{xpd0|#expr: +01.20}}
*{{xpd0|#expr: 12.}}

These equivalences apply also for #ifeq and #switch, see below.

The part of the expression representing a number is a sequence of digits and points; due to [http://www.php.net/manual/en/function.floatval.php floatval] a second point and any digits and points immediately after it are ignored, and do not give an error message. '''Group separators are not allowed''': a comma is considered an unrecognised punctuation character:

Thus a number can only consist of:
* one or more digits, or
* zero or more digits, a point, and zero or more digits.

*{{xpd0|#expr:123}}
*{{xpd0|#expr:123.456}}
*{{xpd0|#expr:.456}}
*{{xpd0|#expr:0}}

Also accepted:
*{{xpd0|#expr: 123.}}
*{{xpd0|#expr:000123.4560 }}
*{{xpd0|#expr:.}}

With ignored part:
*{{xpd0|#expr:123.456.789}}

Wrong:
*{{xpd0|#expr: 123,456}}
*{{xpd0|#expr: 123 456}}

Combinations with the operator e:

Float:
*{{xpd0|#expr:2.3e-5}}
*{{xpsoc|#expr:2e18}}
Integer type:
*{{xpsoc|#expr:(trunc123456789012345)e trunc4}}
Compare:
*{{xpsoc|#expr:123456789012345e4}}
*{{xpsoc|#expr:trunc123456789012345e4}}
*{{xpsoc|#expr:(trunc123456789012345)e4}}

*{{xpd0|#expr: e5}}

Commas can be removed as follows: 
*{{xpsoc|formatnum:1,2,,34.567,8|R}}

Input of a number of type integer is not possible. A float can be converted to type integer with the function trunc. An integer with a value that is not a float value can be constructed, e.g. with [[Template:Trunc]], where the number is given in two pieces: 
*{{xpsopocc|numf|trunc|12345678|90123456789}}

The smallest positive float can be written:
*{{xpsoc|#expr:.5e-323}}
but we cannot use that output as input:
*{{xpsoc|#expr:{{#expr:.5e-323}}}} 

All digits are used to determine the float to which a number is rounded, as demonstrated in a borderline case:

<small>{{xpsoc|hex|0.00000000000000011102230246251566636831481088739149080825}}</small><br>
<small>{{xpsoc|hex|0.00000000000000011102230246251566636831481088739149080826}}</small>

*{{xpsoc|numf|2^-53}}
*{{xpsoc|numf|2^-53+2^-105}}

Similarly:
*{{xpsoc|numfh|4398046511104.00048828125}}
*{{xpsoc|numfh|4398046511104.00048828125000000000000000000000000000000000000000000000001}}
*2^42+2^-10 = 4,398,046,511,104.000,976,562,5

Thus we see that the value halfway the two consecutive floats is rounded down in this case, while the other decimal fractions between the two floats are rounded to the nearest of the two.

===Function plural===
As opposed to ParserFunctions, "{{ml|Help:Magic_words|Language-dependent_word_conversions|plural}}" accepts points ''and'' commas in numbers and interprets them in a site-language-specific way (depending on $separatorTransformTable in Messagesxx.php); on this site:
*{{xpd5op3p3p3c||||||plural:1.000||a|||b|||c}}
*{{xpd5op3p3p3c||||||plural:1,000||a|||b|||c}}

(on e.g. the German and the Dutch sites reversed w.r.t. the result on English sites).

However, this can be used instead of #ifeq, #ifexpr or #switch only for distinguishing a few site-language-specific categories of numbers (for English: 1 and "not equal to 1", for French <=1 and >1, etc.). Also, since it is designed for linguistic distinction of singular and plural, in some languages the categories of numbers are numerically less useful.

== Numbers as output ==
The MediaWiki software simply passes on the literal result of the php computation, except that logical 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)}}
*{{xpsoc|#expr:trunc1100000}}
*{{xpsoc|#expr:trunc1200000}}
*{{xpsoc|#expr:trunc1300000}}
*{{xpsoc|#expr:trunc4100000}}
while a number of type float is rounded to 14 digits, while inconsistently displaying some numbers in scientific format. This is reportedly a bug in the [[w:Zend Engine|Zend Engine]] which has been fixed [http://bugs.php.net/43053], but on Wikimedia apparently not yet:
*{{xpsoc|#expr:2^52}}
*{{xpsoc|#expr:-(2^52)}}
*{{xpsoc|#expr:1100000}}
*{{xpsoc|#expr:1200000}}
*{{xpsoc|#expr:1300000}}
*{{xpsoc|#expr:4100000}}
*{{xpsoc|#expr:1/7}}

For some representable round numbers, notably some multiples of 100,000,  scientific notation is produced, which, if reused in an expression, is not even exactly equal to the original number:
*{{xpsoc|numfh|4.1e6}}
Thus we may want to either compare two results of #expr (for equality up to 14 digits) or compare two expressions, such as 4100000 and 4000000+100000 (for exact equality); depending on context and intention, the negative result of the comparison of the result of expr with the exact number may be confusing.  

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}}.

[[Template:Num]] displays a number with high accuracy (such that in the case of float the specific internal value is reconstructed when using the output as input), with the variant [[Template:Numf]] showing thousands separators:
*{{xpsoc|numf|trunc3^trunc39}}
*{{xpsoc|numf|trunc3^trunc40}}
*{{xpsoc|numf|1/7}}

==Negative zero==
Although the literal "-0" (the unary minus applied to 0) gives 0, some operations give the float "[[w:Signed zero|-0]]" (preserving commutativity of + and *):

Generating -0 with <code>*</code>, <code>/</code>, <code>ceil</code>, <code>round</code>:
*{{xpsoc|#expr: -1*0}}
*{{xpsoc|#expr: (-1e-200)*1e-200}}
*{{xpsoc|#expr: -1/1e333}}
*{{xpsoc|#expr: 0/-1}}
*{{xpsoc|#expr: (-1e-200)/1e200}}
*{{xpsoc|#expr: (1e-200)/-1e200}}
*{{xpsoc|#expr: ceil(-.1)}}
*{{xpsoc|#expr: -.2round0}}

Passing <code>-0</code> on with unary <code>+</code>, binary <code>+</code>  and <code>-</code>, <code>*</code> (and hence operator <code>e</code>), <code>/</code>, <code>floor</code>, <code>ceil</code>:
*{{xpsoc|#expr: +(-1*0)}}
*{{xpsoc|#expr: (-1*0)+(-1*0)}}
*{{xpsoc|#expr: (-1*0)-0}}
*{{xpsoc|#expr: 1*(-1*0)}}
**{{xpsoc|#expr: (-1*0)e0}}
*{{xpsoc|#expr: (-1*0)/1}}
*{{xpsoc|#expr: floor(-1*0)}}
*{{xpsoc|#expr: ceil(-1*0)}}

However:
*{{xpsoc|#expr: -0}}
*{{xpsoc|#expr: -10^-401}}

Since 2011 the function #ifexpr takes both 0 and the float -0 as false:

*{{xpsoc|#ifexpr:0|1|0}}
*{{xpsoc|#ifexpr:-1*0|1|0}}

Also, as argument of a logical operator -0 is taken as false: 
*{{xpsoc|#expr:not(-1*0)}}
*{{xpsoc|#expr:(-1*0)and1}}
*{{xpsoc|#expr:(-1*0)or0}}

If an expression of type float can have the value -0, then an operation that removes the minus sign from a possible -0, but does not affect any other result, is the addition of 0. If an expression may be of type integer then one can add trunc0.
*{{xpsoc|#expr:0+(-1*0)}}

==Type conversion==
A float can be converted to type integer by operator trunc (note however that for 2^63 <= x <= 2^64 we get x - 2^64, for larger x we get 0; for x < -2^63 we get -2^63).

An expression of type integer can be converted to float by adding 0. Note that for integers greater than 2^53 this involves rounding.

==Limitations and workarounds==
The operator trunc gives the correct mathematical result of rounding toward 0 to an integer for integer-type numbers and for floats x inside the integer range: -2^63 <= x < 2^63. To also get the correct mathematical result for floats outside this range is simple, because these floats all have an integer value, so they can be left unchanged. [[Template:Trunc]] does this.

The operator mod gives strange errors for some fairly large values of the second argument:
*{{xpsoc|#expr:123mod(2^32-1)}}
[[Template:Modint]] works correctly for a larger range.

The operator ''round'' with second argument 0 gives wrong results for odd numbers between 2^52 and 2^53, even though the exact results are representable as float. Also, the operator rounds integer-type numbers with an absolute value between 2^53 and 2^63 to float. [[Template:Round0]] always gives the expression for the exact result, for subsequent use in an expression, or for display (with the accuracy of this depending on the accuracy of the display function or template only).

The operator ''floor'' rounds integer-type numbers with an absolute value between 2^53 and 2^63 to float, and not necessarily downward. Similarly the operator ''ceil'' rounds these numbers not necessarily upward. [[Template:Floor]] and [[Template:Ceil]] always give the expressions for the exact results, for subsequent use in an expression, or for display (with the accuracy of this, and the direction of rounding, depending on the display function or template only).

==Branching depending on an expression==
The function [[mw:Help:Extension:ParserFunctions##ifexpr|#ifexpr:]] produces one of two specified results, depending on the value of a boolean expression involving numbers and booleans (not strings). Examples:
* <nowiki>{{#ifexpr: {{CURRENTDOW}} = 0 or {{CURRENTDOW}} = 6 | weekEND | weekDAY}}</nowiki> yields '''{{#ifexpr: {{CURRENTDOW}} = 0 or {{CURRENTDOW}} = 6|weekEND|weekDAY}}''' because today is {{CURRENTDAYNAME}} and so {{xpd0|CURRENTDOW|gives=is}}.
* {{xpsoc|1=#expr:2^10=1024}}

Note that rounding errors can affect a comparison, even if they are not visible in the displayed values: the  internal values are compared. This applies even to large integers:
*{{xpsoc|#expr:1024e20-1e23}}
*{{xpsoc|1=#expr:1024e20-1e23=2.4e21}}
Instead one may want to allow a relatively small difference that could be present due to rounding errors:
*{{xpsoc|1=#expr:abs(1024e20-1e23-2.4e21)<1e8}}

Again, for comparing a number of type float with one of type integer, the integer is converted to float. In this case the type is determined by the format of the number, e.g. 2 is an integer, but 2.0 and 2e0 are floats; also 12345678901234567890 is a float, because it is too large for an integer. 

Again, equality is not transitive with mixed types:

*{{xpsoc|#ifeq:12345678901234567|12345678901234568.0|1|0}}
*{{xpsoc|#ifeq:12345678901234568.0|12345678901234568|1|0}}
*{{xpsoc|#ifeq:12345678901234567|12345678901234568|1|0}}

*{{xpsoc|#ifeq:12345678901234567|12345678901234567e0|1|0}}
*{{xpsoc|#ifeq:12345678901234567e0|12345678901234568|1|0}}
*{{xpsoc|#ifeq:12345678901234567|12345678901234568|1|0}}

*{{xpsoc|num|trunc(2^62)-trunc1+trunc(2^62)}}
*{{xpsoc|#ifeq:9223372036854775700|9223372036854775900|1|0}}
*{{xpsoc|#ifeq:9223372036854775900|9223372036854775800|1|0}}
*{{xpsoc|#ifeq:9223372036854775700|9223372036854775800|1|0}}

==Comparisons==
The functions <code>[[Template:If##ifeq|#ifeq]]</code> and <code>[[mw:Help:Extension:ParserFunctions##switch|#switch]]</code> compare numbers and strings for equality using PHP operator [http://www.php.net/manual/en/language.operators.comparison.php ==], the same as the equality operator mentioned above, but now applied directly to the expanded wikitext of the arguments. For comparison as numbers no expressions (not even constants) are allowed, but in this case the unary plus and minus and the e of scientific notation are taken as part of the number, instead of as operators. Without e and decimal point the type is integer, otherwise it is float. As mentioned above, when an integer is compared with a float, the integer is converted to float first.

* {{xpsoc|#ifeq:3|3.0|1|0}}
* {{xpsoc|#ifeq:3|03|1|0}}
* {{xpsoc|#ifeq:0.00003456|3.456E-05|1|0}}
* {{xpsoc|#ifeq:1e23|.1e24|1|0}} although rounding both numbers to float gives different internal numbers:
** {{xpsoc|#expr:1e23-.1e24}} 
** {{xpsoc|1=#expr:1e23=.1e24}} 
** {{xpsoc|1=#ifexpr:1e23=.1e24|2=1|3=0}} 
* {{xpsoc|#ifeq:9034567890123456789|9034567890123456788|1|0}} (two numbers of type integer, therefore only true if exactly equal); compare:
* {{xpsoc|#ifeq:9034567890123456700.0|9034567890123456800|1|0}} (due to the decimal point in one number, both are rounded to float before the comparison, so the comparison is cruder)

==Length of expressions==
Long expressions are allowed, see [[Template:Long expression demo]]. However, see also [[Help:Expansion#Efficiency|efficiency]].

==Error messages==
Examples for all known [[mw:Help:Extension:ParserFunctions##expr|#expr:]] and [[mw:Help:Extension:ParserFunctions##ifexpr|#ifexpr:]] error messages. The error texts are within the tags &lt;strong class="error">..&lt;/strong>.

*{{xpdoc|#expr:1/0}}
*{{xpdoc|#expr:2*}}
*{{xpdoc|#expr:1 2}}
*{{xpdoc|#ifexpr:1*/2}}
*{{xpdoc|#expr: 1 (2)}}
*{{xpdoc|#expr: (1}}
*{{xpdoc|#expr: 1)}}
*{{xpdoc|#expr:2*123,456}}
*{{xpdoc|#expr:{{{a}}}}}
*{{xpdoc|#ifexpr:3%2}}
*{{xpdoc|#ifexpr:abc}}
*{{xpdoc|#expr:abc.def}}

{&#123;<small>&#160;</small><tt>#expr:</tt>{&#123;<small>&#160;</small><tt>x|102|1000*</tt>&#125;}<tt><small>&#160;</small>18</tt><small>&#160;</small>&#125;} gives {{#ifeq:{{ns:4}}|Meta|{{#expr:{{x|102|1000*}}18}}|{{#expr:1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*18}}}} 

{&#123;<small>&#160;</small><tt>#expr:</tt>{&#123;<small>&#160;</small><tt>x|102|1000*</tt>&#125;}<tt><small>&#160;</small>179</tt><small>&#160;</small>&#125;} gives {{#ifeq:{{ns:4}}|Meta|{{#expr:{{x|102|1000*}}179}}|{{#expr:1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*179}}}}

{&#123;<small>&#160;</small><tt>#expr:</tt>{&#123;<small>&#160;</small><tt>x|102|1000*</tt>&#125;}<tt><small>&#160;</small>180</tt><small>&#160;</small>&#125;} gives {{#ifeq:{{ns:4}}|Meta|{{#expr:{{x|102|1000*}}180}}|{{#expr:1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*1000*180}}}} (on Wikimedia "INF", but depending on the operating system of the server it may also be e.g. "1.#INF")

INF also appears when an intermediate result is of range:
*{{xpsoc|#expr:1e309/1e308}} 
*{{xpsoc|#expr:1e200*1e200*1e-300}}.
but
*{{xpsoc|#expr:1e200*(1e200*1e-300)}}.

{&#123;<small>&#160;</small><tt>#expr:</tt>{&#123;<small>&#160;</small><tt>x|33|(1+(</tt>&#125;}<small>&#160;</small><tt>1</tt><small>&#160;</small>{&#123;<small>&#160;</small><tt>x|33|))</tt>&#125;} &#125;} gives {{#ifeq:{{ns:4}}|Meta|{{#expr:{{x|33|(1+(}}1{{x|33|))}}}}|{{#expr:(1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+(1)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))}}}} 

{&#123;<small>&#160;</small><tt>#expr:</tt>{&#123;<small>&#160;</small><tt>x|34|(1+(</tt>&#125;}<small>&#160;</small><tt>1</tt><small>&#160;</small>{&#123;<small>&#160;</small><tt>x|34|))</tt>&#125;} &#125;} gives {{#ifeq:{{ns:4}}|Meta|{{#expr:{{x|34|(1+(}}1{{x|34|))}}}}|{{#expr:(1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+((1+(1))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))}}}}

{{xpd0|#expr:3.4.5.6}} &#160; <small>(no feature, only an oddity)</small>


Note: {{links-small|template|x}} copies a given string, here parts of an expression, for the specified times (max. 120).
 
Wikitext without error message from the parser functions, but typically unintended:

{| cellspacing="0" cellpadding="0"
|-
|valign="top"|<nowiki>{{{#expr:2*3}}}</nowiki> &#160; 
|valign="top"| {{{#expr:2*3}}} &#160;
||(triple braces, the whole is interpreted as parameter tag with parameter name "#expr:2*3")
|-
|valign="top"|<nowiki>{{#expr:2*3}}}</nowiki> 
|valign="top"| {{#expr:2*3}}}
|(one closing brace too many; the last of the three is interpreted as plain text, so that the rest works fine)
|-
|valign="top"|<nowiki>{{{#expr:2*3}}</nowiki> 
|valign="top"| {{{#expr:2*3}}
|(one opening brace too many; the first of the three is interpreted as plain text, so that the rest works fine)
|-
|valign="top"|<nowiki>{{#expr:2*3}</nowiki> 
|valign="top"| <nowiki>{{#expr:2*3}</nowiki>
|(too few braces, the whole is interpreted as plain text)
|}

==Checking for a number==
Check whether a string is a valid numeric expression:
*<code><nowiki>{{#if:{{#ifexpr:3}}|0|1}}</nowiki></code> gives {{#if:{{#ifexpr:3}}|0|1}}
*<code><nowiki>{{#if:{{#ifexpr:3-2}}|0|1}}</nowiki></code> gives {{#if:{{#ifexpr:3-2}}|0|1}}
*<code><nowiki>{{#if:{{#ifexpr:3 2}}|0|1}}</nowiki></code> gives {{#if:{{#ifexpr:3 2}}|0|1}}

Find the value represented by a string if it is a valid numeric expression, otherwise just return the string:
*<code><nowiki>{{#iferror:{{#expr:3}}|3}}</nowiki></code> gives {{#iferror:{{#expr:3}}|3}}
*<code><nowiki>{{#iferror:{{#expr:3-2}}|3-2}}</nowiki></code> gives {{#iferror:{{#expr:3-2}}|3-2}}
*<code><nowiki>{{#iferror:{{#expr:3 2}}|3 2}}</nowiki></code> gives {{#iferror:{{#expr:3 2}}|3 2}}

Check whether a string is a number:
*<code><nowiki>{{#ifeq:3|{{#expr:3}}|1|0}}</nowiki></code> gives {{#ifeq:3|{{#expr:3}}|1|0}}
*<code><nowiki>{{#ifeq:03|{{#expr:03}}|1|0}}</nowiki></code> gives {{#ifeq:03|{{#expr:03}}|1|0}}
*<code><nowiki>{{#ifeq:3-2|{{#expr:3-2}}|1|0}}</nowiki></code> gives {{#ifeq:3-2|{{#expr:3-2}}|1|0}}
*<code><nowiki>{{#ifeq:3 2|{{#expr:3 2}}|1|0}}</nowiki></code> gives {{#ifeq:3 2|{{#expr:3 2}}|1|0}}

==Minus sign==
Only the {{mlw|hyphen-minus||hyphen-minus}} character or {{mlw|Minus sign|Character codes|minus sign}} character, typed directly, work as a minus sign operator in expressions.
* The HTML character references (by name or by numeric code point value) are not recognized when evaluating expressions: numerical character references are converted only when generating the final HTML document (after expansion of templates and parser functions)
* Only a handful of character references by name are substituted early by MediaWiki, all others are interpreted only by the browser.
* The other dash characters (such as the hyphen, the figure dash, {{mlw|Dash|En dash|en dash}}, {{mlw|Dash|Em dash|em dash}} and others), though often similar visually, are '''not''' valid minus signs, but punctuation signs or typographical variants.

{|class="wikitable"
|-
| {{mlw|hyphen-minus||hyphen-minus}}, typed directly as the character '-' (U+002D)
| {{xpd0|#expr:-12|gives={{!!}}}}
|-
| hyphen-minus, typed as the numerical character reference <tt>&amp;#x2D;</tt>
| <code>"&#x7B;&#x7B;#expr:&amp;#x2D;12&#x7D;&#x7D;"</code>
| "{{#expr:&#x2D;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%23x2D;12%7D%7D}}]
|-
| hyphen-minus, typed as the numerical character reference <tt>&amp;#45;</tt>
| <code>"&#x7B;&#x7B;#expr:&amp;#45;12&#x7D;&#x7D;"</code>
| "{{#expr:&#45;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%2345;12%7D%7D}}]

|-
| {{mlw|Minus sign|Character codes|minus sign}}, typed directly as the character '−' (U+2212)
| {{xpd0|#expr:−12|gives={{!!}}}}
|-
| minus sign, typed as the numerical character reference <tt>&amp;#x2212;</tt>
| <code>"&#x7B;&#x7B;#expr:&amp;#x2212;12&#x7D;&#x7D;"</code>
| "{{#expr:&#x2212;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%23x2212;12%7D%7D}}]
|-
| minus sign, typed as the numerical character reference <tt>&amp;#8722;</tt>
| <code>"&#x7B;&#x7B;#expr:&amp;#8722;12&#x7D;&#x7D;"</code>
| "{{#expr:&#8722;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%238722;12%7D%7D}}]
|-
| minus sign, typed as the symbolic character reference <tt>&amp;minus;</tt>
| <code>"&#x7B;&#x7B;#expr:&amp;minus;12&#x7D;&#x7D;"</code>
| "{{#expr:&minus;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26minus;12%7D%7D}}]

|-
| figure dash, typed directly as the character '‒' (U+2012)
| {{xpd0|#expr:‒12|gives={{!!}}}}
|-
| figure dash, typed as the numerical character reference <tt>&amp;#x2012;</tt>
| <code>"&#x7B;&#x7B;#expr:&amp;#x2012;12&#x7D;&#x7D;"</code>
| "{{#expr:&#x2012;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%23x2012;12%7D%7D}}]
|-
| figure dash, typed as the numerical character reference <tt>&amp;#8210;</tt>
| <code>"&#x7B;&#x7B;#expr:&amp;#8210;12&#x7D;&#x7D;"</code>
| "{{#expr:&#8210;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%238210;12%7D%7D}}]

|-
| {{mlw|Dash|En dash|en dash}}, typed directly as the character '–' (U+2013)
| {{xpd0|#expr:–12|gives={{!!}}}}
|-
| en dash, typed as the numerical character reference <tt>&amp;#x2013;</tt>
| <code>"&#x7B;&#x7B;#expr:&#x26;#x2013;12&#x7D;&#x7D;"</code>
| "{{#expr:&#x2013;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%23x2013;12%7D%7D}}]
|-
| en dash, typed as the numerical character reference <tt>&amp;#8211;</tt>
| <code>"&#x7B;&#x7B;#expr:&#x26;#8211;12&#x7D;&#x7D;"</code>
| "{{#expr:&#8211;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26%238211;12%7D%7D}}]
|-
| en dash, typed as the symbolic character reference <tt>&amp;ndash;</tt>
| <code>"&#x7B;&#x7B;#expr:&#x26;ndash;12&#x7D;&#x7D;"</code>
| "{{#expr:&ndash;12}}"
| [{{fullurl:Special:ExpandTemplates|input=%7B%7B%23expr:%26ndash;12%7D%7D}}]
|}

Also many other calculation programs require a hyphen. Therefore, in order to be able to copy rendered numbers and expressions to the edit box or input them through a copy operation into other calculation programs, displayed minus signs also need to be hyphens.

==Displaying numbers and numeric expressions==
Guidelines such as {{mlww|Manual of Style (dates and numbers)|Numbers}} focus on number display as end product. However, a point of consideration can also be the possibility to apply the rendered output to #expr or #ifexpr, or to input it without conversion into other calculation programs. This would require the following:
*use digits, not words
*as mentioned above, use the hyphen as minus sign
*use *, <=, and >=, not ×, ≤, or ≥
*do not use thousands separators (however, some programs allow them)
*use output like 6E23 or 6e23 rather than 6{{e|23}}

Examples:
*{{xpd0|#expr:three}}
*{{xpd0|#expr:2<3}}
*{{xpd0|#expr:2≤3}}
*{{xpd0|#expr:2<{{=}}3}}
*{{xpd0|#expr:2>3}}
*{{xpd0|#expr:2≥3}}
*{{xpd0|#expr:2>{{=}}3}}
*{{xpd0|#expr:2*3}}
*{{xpd0|#expr:2×3}}
*{{xpd0|#expr:2,300}}
*{{xpd0|#expr:6E23}}

If the number is the result of a computation by MediaWiki and unsuitable for use in a new computation due to application of a formatting function such as #formatnum or a formatting template, one can copy the wikitext and apply the additional computation before the formatting. However, when templates are used, and copying is done to another wiki, these templates have to be copied too, or substituted.

If you want to calculate with [[mw:Help:Magic words|Magic words]] and return group seperated results you can use formatnum:<br>
<code><nowiki>{{formatnum: {{#expr: {{NUMBEROFPAGES:R}} - {{NUMBEROFFILES:R}} }} }}</nowiki></code> = {{formatnum: {{#expr: {{NUMBEROFPAGES:R}} - {{NUMBEROFFILES:R}} }} }} (instead of {{#expr: {{NUMBEROFPAGES:R}} - {{NUMBEROFFILES:R}} }}).

== See also ==
*[[Help:Mod, round, floor, ceil, trunc]]
*[[Help:Calculation accuracy]]
*[[Help:Comparison between ParserFunctions syntax and TeX syntax]]
*[[:Category:Mathematical templates]]
*[[mw:Extension:MathStatFunctions]]
*[[mw:Extension:Foxway]]
*http://svn.wikimedia.org/svnroot/mediawiki/trunk/extensions/ParserFunctions/Expr.php

{{refs}}

{{h:f|enname=Calculation}}

[[Category:Editor handbook]]