Help:Calculation
From The Scuba Wiki
MediaWiki Handbook: Contents, Readers, Editors, Moderators, System admins +/ 
 The accuracy and format of numeric results varies with the server, even on a single Wikimedia page.
The MediaWiki extension ParserFunctions enables users to perform mathematical computations.
The expr function evaluates numerical expressions, and also boolean expressions involving numbers and booleans (not strings). The syntax is
 {{ #expr: expression }}
The spaces are not needed. Inside numbers no spaces are allowed.
The supported operators (roughly in order of precedence) are not, *, /, div, mod, +, , round, =, <>, !=, <=, >=, and, and or.
Contents 
Operators
Returns 0 or 1 for Booleans or true/false.
Operator  Operation  Examples  

none  none 
Wrong:
 
exp  Exponential function e^{x} 
Compare:
 
ln  Natural logarithm 
Hence, the common logarithm of e.g. 2:
 
abs  Absolute value 
 
trunc  Truncation 
 
floor  Floor function 
 
ceil  Ceiling function 
 
sin  Sine function 
With an angle in degrees, e.g. 30°:
 
cos  Cosine function 
 
tan  Tangent function 
 
asin  Arc sine function 
 
acos  Arc cosine function 
 
atan  Arc tangent function 
 
+  Unary + sign 
 
  Unary  sign (negation) 
 
not  Unary NOT, logical NOT 
 
^  Power 
 
*  Multiplication 
 
/  Division, same as div 
 
div  Division, same as /, not integer division 
 
mod  "Modulo", remainder of division after truncating both operands to an integer (PHP operator %). Caveat, div and mod are different from all programming languages. This has been fixed (but needs to be committed), see bugzilla:6068. 
 
+  Addition 
 
  Subtraction 
 
round  Rounds off the number on the left to the power of 1/10 given on the right (PHP function round) 
 
=  Equality (numerical incl. logical) 
 
<>  Inequality, same as != 
 
!=  Inequality, same as <>, logical xor 
 
<  Less than 
 
>  Greater than 
 
<=  Less than or equal to 
 
>=  Greater than or equal to 
 
and  Logical AND 
 
or  Logical OR 

The boolean operators consider 0 to be false and any other number to be true. An intermediate or final result "true" is identified with 1. Thus "{{#expr: (2 < 3) + 1}}"
gives "2" [91]. Note that "and" and "or" work with #expr and #ifexpr only; for use with #if, #ifeq, and #ifexist, use 1 as thentext and 0 as elsetext, and combine results with "and" and "or" in an outer #expr or #ifexpr. Instead of {{ #expr: {{#if:{{{a}}}10}} or {{#if:{{{b}}}10}} }} we can also use {{#if:{{{a}}}{{{b}}}10}}}}. For negation, simply subtract from 1 or interchange then and elsepart.
Precedence:
"{{#expr: 2  3 + 4 / 5 * 6}}"
gives "3.8" [92]
(+ and  have equal precedence, * and / also, both higher than the former two).
"{{#expr: 2 = 5 < 3 + 4}}"
gives "1" [93]
(first +, then =, then <).
"{{#expr:1.234 + 1.234 round 1 + 1}}"
gives "2.47" [94]
(first additions, then round)
"{{#expr:3 * 4 mod 10 * 10}}"
gives "20" [95]
(mod and multiplication have equal precedence, evaluation from left to right)
Parentheses can force a different precedence: "{{#expr: (2 + 3) * 4}}"
gives "20" [96]
Blank spaces are good for readability but not needed for working properly, except between not and an adjacent and/div/mod/not/or/round operator, and within numbers not allowed:
"{{#expr:7mod3}}"
gives "1" [97]"{{#expr:7.5round0}}"
gives "8" [98]"{{#expr:0and1}}"
gives "0" [99]"{{#expr:0or not0}}"
gives "1" [100]"{{#expr:0ornot0}}"
gives "Expression error: Unrecognised word "ornot"" [101]"{{#expr:123 456}}"
gives "Expression error: Unexpected number" [102]"{{#expr:not not3}}"
gives "1" [103]"{{#expr:notnot3}}"
gives "Expression error: Unrecognised word "notnot"" [104]
"{{#expr:2}}"
gives "2" [105]"{{#expr:+2}}"
gives "2" [106]"{{#expr:2*3}}"
gives "6" [107]"{{#expr:notnotnot0}}"
gives "1" [108]"{{#expr:2*/3}}"
gives "Expression error: Unexpected / operator" [109]"{{#expr:sinln1.1}}"
gives "Expression error: Unrecognised word "sinln"" [110]"{{#expr:sin ln1.1}}"
gives "0.095165945236752" [111]
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.
These equivalences are also relevant for #ifeq and #switch, see below.
In [114] we have
define( 'EXPR_NUMBER_CLASS', '0123456789.' ); ... elseif ( false !== strpos( EXPR_NUMBER_CLASS, $char ) ) { // Number if ( $expecting != 'expression' ) {throw new ExprError('unexpected_number');} // Find the rest of it $length = strspn( $expr, EXPR_NUMBER_CLASS, $p ); // Convert it to float, silently removing double decimal points $operands[] = floatval( substr( $expr, $p, $length ) ); $p += $length;$expecting = 'operator';continue;}
Thus the part of the expression representing a number is a sequence of digits and points; due to 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.
optionally followed by an power of 10 multiplier : the letter E (or e), an optional sign and digits (for the base10 exponent).
For the purpose of evaluating an expression a leading plus or minus sign is considered a unary operator instead of part of the number. The letter e or E was initially parsed only as if it was a binary operator, but now when it true only when it follows a number (otherwise this is Euler's constant, i.e. the base of natural logarithms).
Canonical form:
"{{#expr: 123}}"
gives "123" [115]"{{#expr: 123.456}}"
gives "123.456" [116]"{{#expr: 0.456}}"
gives "0.456" [117]"{{#expr: 0}}"
gives "0" [118]"{{#expr: 2.0E5}}"
gives "2E05" [119]
Accepted, although in some cases more or less odd:
"{{#expr: .456}}"
gives "0.456" [120]"{{#expr: 123.}}"
gives "123" [121]"{{#expr: 000123}}"
gives "123" [122]"{{#expr: 123.456.789}}"
gives "123.456" [123]"{{#expr: .}}"
gives "0" [124]"{{#expr: 2e5}}"
gives "2E05" [125]"{{#expr: 2E5}}"
gives "2E05" [126]"{{#expr: 1e5}}"
gives "1E05" [127]"{{#expr: 1 e 5}}"
gives "1E05" [128]
Using Euler's constant e:
"{{#expr: E}}"
gives "2.718281828459" [129]"{{#expr: e}}"
gives "2.718281828459" [130]"{{#expr: E5}}"
gives "2.281718171541" [131]"{{#expr: e5}}"
gives "2.281718171541" [132]
Wrong:
"{{#expr: 123,456}}"
gives "Expression error: Unrecognised punctuation character ","" [133]"{{#expr: 123 456}}"
gives "Expression error: Unexpected number" [134]
Due to the specifier R ("raw"), Template:Xpdoc etc., i.e. numbers without group separators, which can be used in computations.
As opposed to ParserFunctions, "plural " accepts points and commas in numbers and interprets them in a sitelanguagespecific way (depending on $separatorTransformTable in Messagesxx.php); on this site:
Template:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1x{{Template:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1x}}Template:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1x
gives "a" [135]Template:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1x{{Template:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1x}}Template:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1xTemplate:1x
gives "b" [136]
(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 sitelanguagespecific 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
A noninteger result has a decimal point in it. Scientific notation is produced for numbers with small absolute value (for Wikimedia: less than 1E4) and for numbers with large absolute value (for Wikimedia: greater than or equal to 1E+12; however, even within Wikimedia there is no uniformity, larger numbers in nonscientific notation and smaller numbers in scientific notation have been observed as output; the format of the same number can vary from preview to view, and by refreshing the page!). Thus numbers produced include (depending on the operating system of the server):
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoc
For negative numbers simply a minus sign is prefixed:
 Long YYYYMMDDhhmmss timestamps can run into the same problem:
 Template:Xpdoc,
 Template:Xpdoocc.
 Timestamps without seconds are 12 digits, just short enough:
 Template:Xpdoc
To avoid these problems and also increase accuracy, unless the result is represented by #expr exactly and in nonscientific notation, such as a not too large integer, do not use #expr in an expression to be evaluated by #expr or #ifexpr. Typically the result of a computational template could be needed in a further computation, so at least one version of such a template needs to give the result in a form suitable for that, e.g. template:roote ( talk edit history links ) and template:rooteval ( talk edit history links ); for convenience, for the final result another version can be made simply calling the other one and applying #expr to the result, e.g. template:rootfineval ( talk edit history links ).
Two methods for representing intermediate results are:
1. The expression resulting from processing the expressions themselves, using #expr for branching only.
For example, template:powe ( talk edit history links ) produces the power of a number in the form of an expression:
"{{powe31.1812}}"
gives "(31.18*31.18*31.18*31.18*31.18*31.18*31.18*31.18*31.18*31.18*31.18*31.18)" [137]
However, the expression can get quite long, for template:roote ( talk edit history links ) see Help:Calculation/example 1. Although long expressions are allowed, they give rise to a large postexpand include size and template argument size, for which limits exist.
Applying #expr directly on the linked expression gives 0.0052083333397318, but it can also be used in a further computation, unlike the value just mentioned.
2. Writing numbers splitting off factors which are powers of 10 but written plainly.
Example:
"{{rootevalTemplate:1x}}"
giving "(Expression error: Unexpected < operator / 10000000000 / 10000000000 / 10000000000)" [138]
Intermediate results are also in such a form, preventing the growth of the expression like above. Again, #expr can be applied directly, as done in template:rootfineval ( talk edit history links ), giving 1E13, but the result can also be used in a further computation.
Compare:
"{{rootTemplate:1x}}"
gives "0.0052083333397315" [139]
This uses the same method, but with intermediate application of #expr, giving an error because of internediate results in scientific notation.
If the result of rounding a negative number is zero, the result is "0". To avoid that, an expression x can be replaced by 0 + ( x ):
"{{#expr: ( 0.2 round 0 )}}"
gives "0" [140]"{{#expr: 1*(0.2 round 0)}}"
gives "0" [141]"{{#expr: 0+(0.2 round 0)}}"
gives "0" [142]
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
×10^{23}.Accuracy
 The accuracy and format of numeric results varies with the operating system of the server. Some remarks in this section are specific for Wikimedia.
Accuracy of the result of #expr is less than internally used within the computation of an expression:
 Template:Xpdoc
 Template:Xpdoc
 Template:Xpdoocc
 Template:Xpdoc (conclusion: 16 or 17 digits of 1234567890.1234567890 used)
 Template:Xpdoc (result is rounded to a total of 12 digits)
 Template:Xpdoocc
 The macheps or smallest x such that 1+x != 1 appears to be near 0.5^53 + 0.5^106 or 1.1102230246251566636831481088739149080825883E16 (see below):
 Template:Xpdoc
 Template:Xpdoc
 That's the normal behaviour for 64=1+52+11 bits (52 mantissa, 11 exponent). As explained above it is unrelated to the smallest expression result greater than 1:
 Template:Xpdoc
 Template:Xpdoc below about 1 + 5E12.
Branching depending on an expression
The function #ifexpr produces one of two specified results, depending on the value of a boolean expression involving numbers and booleans (not strings). Examples:
 {{#ifexpr: {{CURRENTDOW}} = 0 or {{CURRENTDOW}} = 6  weekEND  weekDAY}} yields weekDAY because today is Friday and so
"{{CURRENTDOW}}"
is "5" [143]. 
"{{#ifexpr:2^10=102410}}"
gives "1" [144]
Note that rounding errors can affect a result:

"{{#expr:sin pi}}"
gives "1.2246063538224E16" [145] 
"{{#ifexpr:sin pi=010}}"
gives "0" [146] 
"{{#ifexpr:abs sin pi<1e1510}}"
gives "1" [147]
Similarly:
Comparisons
 The function #ifeq: compares numbers and strings for equality (equal if both represent the same number or both are equal strings).
 The function #switch: compares one string with multiple others, and correspondingly produces one of multiple specified results.
 Template:Xpdopepepec

"{{#ifeq:33.010}}"
gives "1" [150] 
"{{#ifeq:30310}}"
gives "1" [151] 
"{{#ifeq:0.000034563.456E0510}}"
gives "1" [152] Note that #ifeq: (like now #expr:) accepts exponential notation on input.

"{{#ifeq:1234567890123123456789012010}}"
gives "0" [153] 
"{{#ifeq:12345678901231.23456789012E+1210}}"
gives "0" [154] 
"{{#ifeq:12345678901201.23456789012E+1210}}"
gives "1" [155] 
"{{#ifeq:1.234567890120E121.23456789012E+1210}}"
gives "1" [156]
Numerical comparisons don't depend on the output format, compare:

"{{#expr:1234567890123}}"
gives "1234567890123" [157] 
"{{#expr:1234567890120}}"
gives "1234567890120" [158]
#ifeq: allows to compare strings containing equal signs:
#switch:  #ifeq: 

"{{#switch:1.01=okayfail}}" gives "fail" [159]
 "{{#ifeq:1.01okayfail}}" gives "okay" [160]

"{{#switch:a=ba=b=okayfail}}" gives "fail" [161]
 "{{#ifeq:a=ba=bokayfail}}" gives "okay" [162]

"{{#switch:a=ca=b=failokay}}" gives "okay" [163]
 "{{#ifeq:a=ca=bfailokay}}" gives "okay" [164]

Length of expressions
To find the absolute value of a numeric expression x without using a separate template at least doubles the length of the expression:
 x*(12*(x<0))
 x*{{#ifexpr:x>011}}
(The first is not only shorter but has also the advantage that for substitution one less "subst:" or {{{subst}}} is needed.)
Do not use
 {{#ifexpr:x>0xx}}
for long expressions as it triples the length.
Similarly do not use mod to round or conversely, because it doubles the length of the expression.
Also providing a leading zero for the result of an expression if it is less than 10 doubles its length:
 {{#ifexpr:x<100}}x
This "exponential" growth of expressions, with much repetition, is due to the lack of variables (in the computer programming sense); however, see also VariablesExtension.
Templates (subroutines) provide some of the functionality that variables offer: a template name is comparable with a variable name, while its content is comparable with the value of the variable. Alternatively, a template parameter can be assigned a value which can be used for multiple occurrences of the same parameter in the template. Thus e.g. x*(12*(x<0)) with a long expression x can be evaluated avoiding duplication of that expression, in two ways:
 put the expression x in a template (multiple calls of the same template)
 put x*(12*(x<0)) in a template with parameter x (use of a template with multiple occurrences of the same parameter)
If the number of possible results of a long expression is small, a switch allows arbitrary conversion, including the absolute value and providing a leading zero, etc., without repeating the expression.
Error messages
Examples for all known #expr: and #ifexpr: error messages. The error texts are within the tags <strong class="error">..</strong>.
"{{#expr:1/0Template:1x}}" gives "Division by zero" [165]
 
"{{#expr:2*Template:1x}}" gives "Expression error: Missing operand for *" [166]
 
"{{#expr:1 2Template:1x}}" gives "Expression error: Unexpected number" [167]
 
"{{#ifexpr:1*/2Template:1x}}" gives "Expression error: Unexpected / operator" [168]
 
"{{#expr: 1 (2)Template:1x}}" gives "Expression error: Unexpected ( operator" [169]
 
"{{#expr: (1Template:1x}}" gives "Expression error: Unclosed bracket" [170]
 
"{{#expr: 1)Template:1x}}" gives "Expression error: Unexpected closing bracket" [171]
 
"{{#expr:2*123,456Template:1x}}" gives "Expression error: Unrecognised punctuation character ","" [172]
 
"{{#expr:{{{a}}}Template:1x}}" gives "Expression error: Unrecognised punctuation character "{"" [173]
 
"{{#ifexpr:3%2Template:1x}}" gives "Expression error: Unrecognised punctuation character "%"" [174]
 
"{{#ifexpr:abcTemplate:1x}}" gives "Expression error: Unrecognised word "abc"" [175]
 
"{{#expr:abc.defTemplate:1x}}" gives "Expression error: Unrecognised word "abc"" [176]
 
{{ #expr:{{ x1021000*}} 18 }} gives 1.8E+307  
{{ #expr:{{ x1021000*}} 179 }} gives 1.79E+308  
{{ #expr:{{ x1021000*}} 180 }} gives INF (on Wikimedia "INF", but depending on the operating system of the server it may also be e.g. "1.#INF")  
{{ #expr:{{ x33(1+(}} 1 {{ x33))}} }} gives Expression error: Unclosed bracket  
{{ #expr:{{ x34(1+(}} 1 {{ x34))}} }} gives Expression error: Stack exhausted  
"{{#expr:3.4.5.6}}" gives "3.4" [177] (no feature, only an oddity)

Note: template:x ( talk edit history links ) copies a given string, here parts of an expression, for the specified times (max. 120), this help page shown on other projects actually evaluate its substituted output like 102 factors "1000" times "180" to get INF (infinity).
Wikitext without error message from the parser functions, but typically an error while using or attempting to use them:
{{{#expr:2*3}}}  {{{#expr:2*3}}}  (triple braces, the whole is interpreted as parameter tag with parameter name "#expr:2*3") 
{{#expr:2*3}}}  6}  (one closing brace too many; the last of the three is interpreted as plain text, so that the rest works fine) 
{{{#expr:2*3}}  {6  (one opening brace too many; the first of the three is interpreted as plain text, so that the rest works fine) 
{{#expr:2*3}  {{#expr:2*3}  (too few braces, the whole is interpreted as plain text) 
 A crude but informative "unrecognised word" error message can be generated intentionally. Only the first identified error is shown:
 {{ #expr: 2*{{ #ifexpr: 3*4>10toolarge3*4 }} }} gives
 Expression error: Unrecognised word "toolarge",
 {{ #expr: 2*{{ #ifexpr: 3*4>10too large3*4 }} }} gives
 Expression error: Unrecognised word "too".
See also #iferror.
Minus sign
Only the hyphenminus character or 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, en dash , em dash and others), though often similar visually, are not valid minus signs, but punctuation signs or typographical variants.
hyphenminus , typed directly as the character '' (U+002D)  "{{#expr:12}}" Template:!! "12" Template:!! [178]
 
hyphenminus, typed as the numerical character reference   "{{#expr:12}}"
 "Expression error: Unrecognised punctuation character "&""  [179] 
hyphenminus, typed as the numerical character reference   "{{#expr:12}}"
 "Expression error: Unrecognised punctuation character "&""  [180] 
minus sign , typed directly as the character '−' (U+2212)  "{{#expr:−12}}" Template:!! "12" Template:!! [181]
 
minus sign, typed as the numerical character reference −  "{{#expr:−12}}"
 "Expression error: Unrecognised punctuation character "&""  [182] 
minus sign, typed as the numerical character reference −  "{{#expr:−12}}"
 "Expression error: Unrecognised punctuation character "&""  [183] 
minus sign, typed as the symbolic character reference −  "{{#expr:−12}}"
 "12"  [184] 
figure dash, typed directly as the character '‒' (U+2012)  "{{#expr:‒12}}" Template:!! "Expression error: Unrecognised punctuation character "�"" Template:!! [185]
 
figure dash, typed as the numerical character reference ‒  "{{#expr:‒12}}"
 "Expression error: Unrecognised punctuation character "&""  [186] 
figure dash, typed as the numerical character reference ‒  "{{#expr:‒12}}"
 "Expression error: Unrecognised punctuation character "&""  [187] 
en dash , typed directly as the character '–' (U+2013)  "{{#expr:–12}}" Template:!! "Expression error: Unrecognised punctuation character "�"" Template:!! [188]
 
en dash, typed as the numerical character reference –  "{{#expr:–12}}"
 "Expression error: Unrecognised punctuation character "&""  [189] 
en dash, typed as the numerical character reference –  "{{#expr:–12}}"
 "Expression error: Unrecognised punctuation character "&""  [190] 
en dash, typed as the symbolic character reference –  "{{#expr:–12}}"
 "Expression error: Unrecognised punctuation character "&""  [191] 
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 w:Wikipedia: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 ×10^{23}
Examples:
"{{#expr:three}}"
gives "Expression error: Unrecognised word "three"" [192]"{{#expr:2<3}}"
gives "1" [193]"{{#expr:2≤3}}"
gives "Expression error: Unrecognised punctuation character "�"" [194]"{{#expr:2<Template:=3}}"
gives "Expression error: Unrecognised punctuation character "["" [195]"{{#expr:2>3}}"
gives "0" [196]"{{#expr:2≥3}}"
gives "Expression error: Unrecognised punctuation character "�"" [197]"{{#expr:2>Template:=3}}"
gives "Expression error: Unrecognised punctuation character "["" [198]"{{#expr:2*3}}"
gives "6" [199]"{{#expr:2×3}}"
gives "Expression error: Unrecognised punctuation character "�"" [200]"{{#expr:2,300}}"
gives "Expression error: Unrecognised punctuation character ","" [201]"{{#expr:6E23}}"
gives "6E+23" [202]
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.
See also
Links to other help pages
 Help contents
 Meta  Wikinews  Wikipedia  Wikiquote  Wiktionary  commons:  mw:  b:  s:  mw:Manual  google
 Versions of this help page (for other languages see below)
 Meta  Wikinews  Wikipedia  Wikiquote  Wiktionary
 What links here on Meta or from Meta  Wikipedia  MediaWiki
 Reading
 Go  Search  Stop words  URL  Namespace  Page name  Section
 Backlinks  Link  Piped link  Interwiki link  Redirect  Category  Image page
 Logging in and preferences
 Logging in  Preferences  User style
 Editing
 Advanced editing  Editing FAQ  Edit toolbar  Export  Import  Shortcuts
 Tracking changes
 Recent changes (enhanced)  Related changes  Watching pages  Diff
 Page history  Edit summary  User contributions  Minor edit  Patrolled edit
 Style & formatting
 Wikitext examples  Reference card  HTML in wikitext  List  Table  Sorting  Colors
 Special input and output
 Inputbox  Special characters  Displaying a formula  Images (uploads)  EasyTimeline
 Advanced functioning
 Template  Advanced templates  Parser function  ParserFunctions  Parameter default
 Variable  Magic word  System message  Substitution  Array  Calculation
 Page management
 Starting a new page  Renaming (moving) a page  Protecting pages  Deleting a page
 Special pages
 Talk page  Testing  Sandbox  CentralNotice