en.wikipedia.org, 2022-07-28 | Main page
Saved from web.archive.org, with Lynx.
   #alternate Edit this page Wikipedia (en)

Conditional (computer programming)

   From Wikipedia, the free encyclopedia
     (Redirected from Conditional branching)
   Jump to navigation Jump to search
   Programming language construct that performs actions according to
   boolean conditions
   For Wikipedia's conditional parser functions, see Help:Conditional
   If-Then-Else flow diagram
   A nested "If-Then-Else" flow diagram

   In computer science, conditionals (that is, conditional statements,
   conditional expressions and conditional constructs,) are programming
   language commands for handling decisions. Specifically, conditionals
   perform different computations or actions depending on whether a
   programmer-defined boolean condition evaluates to true or false. In
   terms of control flow, the decision is always achieved by selectively
   altering the control flow based on some condition (apart from the case
   of branch predication).

   Although dynamic dispatch is not usually classified as a conditional
   construct, it is another way to select between alternatives at runtime.
   [ ]


     * 1 Terminology
     * 2 If-then(-else)
          + 2.1 History and development
               o 2.1.1 The "dangling else" problem
          + 2.2 Else if
          + 2.3 If-then-else expressions
               o 2.3.1 Algol family
               o 2.3.2 Lisp dialects
               o 2.3.3 Haskell
               o 2.3.4 C-like languages
               o 2.3.5 Small Basic
               o 2.3.6 Visual Basic
               o 2.3.7 Tcl
               o 2.3.8 Rust
          + 2.4 Arithmetic if
          + 2.5 Object-oriented implementation in Smalltalk
          + 2.6 JavaScript
          + 2.7 Lambda calculus
     * 3 Case and switch statements
     * 4 Pattern matching
     * 5 Hash-based conditionals
     * 6 Predication
     * 7 Choice system cross reference
     * 8 See also
     * 9 References
     * 10 External links


   In imperative programming languages, the term "conditional statement"
   is usually used, whereas in functional programming, the terms
   "conditional expression" or "conditional construct" are preferred,
   because these terms all have distinct meanings.


   "if-then-else" redirects here. For the album, see If Then Else.

   The if-then construct (sometimes called if-then-else) is common across
   many programming languages. Although the syntax varies from language to
   language, the basic structure (in pseudocode form) looks like this:
If (boolean condition) Then
End If

   For example:
If stock=0 Then
   message= order new stock
   message= there is stock
End If

   In the example code above, the part represented by (boolean condition)
   constitutes a conditional expression, having intrinsic value (e.g., it
   may be substituted by either of the values True or False) but having no
   intrinsic meaning. In contrast, the combination of this expression, the
   If and Then surrounding it, and the consequent that follows afterward
   constitute a conditional statement, having intrinsic meaning (e.g.,
   expressing a coherent logical rule) but no intrinsic value.

   When an interpreter finds an If, it expects a boolean condition - for
   example, x > 0, which means "the variable x contains a number that is
   greater than zero" - and evaluates that condition. If the condition is
   true, the statements following the then are executed. Otherwise, the
   execution continues in the following branch - either in the else block
   (which is usually optional), or if there is no else branch, then after
   the end If.

   After either branch has been executed, control returns to the point
   after the end If.

History and development[edit]

   In early programming languages, especially some dialects of BASIC in
   the 1980s home computers, an if-then statement could only contain GOTO
   statements (equivalent to a branch instruction). This led to a
   hard-to-read style of programming known as spaghetti programming, with
   programs in this style called spaghetti code. As a result, structured
   programming, which allows (virtually) arbitrary statements to be put in
   statement blocks inside an if statement, gained in popularity, until it
   became the norm even in most BASIC programming circles. Such mechanisms
   and principles were based on the older but more advanced ALGOL family
   of languages, and ALGOL-like languages such as Pascal and Modula-2
   influenced modern BASIC variants for many years. While it is possible
   while using only GOTO statements in if-then statements to write
   programs that are not spaghetti code and are just as well structured
   and readable as programs written in a structured programming language,
   structured programming makes this easier and enforces it. Structured
   if-then-else statements like the example above are one of the key
   elements of structured programming, and they are present in most
   popular high-level programming languages such as C, Java, JavaScript
   and Visual Basic .

The "dangling else" problem[edit]

   Main article: Dangling else

   The else keyword is made to target a specific if-then statement
   preceding it, but for nested if-then statements, classic programming
   languages such as ALGOL 60 struggled to define which specific statement
   to target. Without clear boundaries for which statement is which, an
   else keyword could target any preceding if-then statement in the nest,
   as parsed.
if a then if b then s else s2

   can be parsed as
if a then (if b then s) else s2

if a then (if b then s else s2)

   depending on whether the else is associated with the first if or second
   if. This is known as the dangling else problem, and is resolved in
   various ways, depending on the language (commonly via the end if
   statement or {...} brackets).

Else if[edit]

   By using else if, it is possible to combine several conditions. Only
   the statements following the first condition that is found to be true
   will be executed. All other statements will be skipped.
if condition then
   -- statements
elseif condition then
   -- more statements
elseif condition then
   -- more statements;
   -- other statements;
end if;

   For example, for a shop offering as much as a 30% discount for an item:
if discount < 11% then
   print (you have to pay $30)
elseif discount<21% then
   print (you have to pay $20)
elseif discount<31% then
   print (you have to pay $10)
end if;

   In the example above, if the discount is 10%, then the first if
   statement will be evaluated as true and "you have to pay $30" will be
   printed out. All other statements below that first if statement will be

   The elseif statement, in the Ada language for example, is simply
   syntactic sugar for else followed by if. In Ada, the difference is that
   only one end if is needed, if one uses elseif instead of else followed
   by if. PHP uses the elseif keyword^[1] both for its curly brackets or
   colon syntaxes. Perl provides the keyword elsif to avoid the large
   number of braces that would be required by multiple if and else
   statements. Python uses the special keyword elif because structure is
   denoted by indentation rather than braces, so a repeated use of else
   and if would require increased indentation after every condition. Some
   implementations of BASIC, such as Visual Basic,^[2] use ElseIf too.
   Similarly, the earlier UNIX shells (later gathered up to the POSIX
   shell syntax^[3]) use elif too, but giving the choice of delimiting
   with spaces, line breaks, or both.

   However, in many languages more directly descended from Algol, such as
   Simula, Pascal, BCPL and C, this special syntax for the else if
   construct is not present, nor is it present in the many syntactical
   derivatives of C, such as Java, ECMAScript, and so on. This works
   because in these languages, any single statement (in this case if
   cond...) can follow a conditional without being enclosed in a block.

   This design choice has a slight "cost". Each else if branch effectively
   adds an extra nesting level. This complicates the job for the compiler
   (or the people who write the compiler), because the compiler must
   analyse and implement arbitrarily long else if chains recursively.

   If all terms in the sequence of conditionals are testing the value of a
   single expression (e.g., if x=0 ... else if x=1 ... else if x=2...), an
   alternative is the switch statement, also called case-statement or
   select-statement. Conversely, in languages that do not have a switch
   statement, these can be produced by a sequence of else if statements.

If-then-else expressions[edit]

   See also: Statement (computer science)

   Many languages support if expressions, which are similar to if
   statements, but return a value as a result. Thus, they are true
   expressions (which evaluate to a value), not statements (which may not
   be permitted in the context of a value).

Algol family[edit]

   ALGOL 60 and some other members of the ALGOL family allow if-then-else
   as an expression:
  myvariable := if x > 20 then 1 else 2

Lisp dialects[edit]

   In dialects of Lisp - Scheme, Racket and Common Lisp - the first of
   which was inspired to a great extent by ALGOL:
;; Scheme
(define myvariable (if (> x 12) 1 2))   ; Assigns 'myvariable' to 1 or 2, depend
ing on the value of 'x'

;; Common Lisp
(let ((x 10))
  (setq myvariable (if (> x 12) 2 4)))  ; Assigns 'myvariable' to 2


   In Haskell 98, there is only an if expression, no if statement, and the
   else part is compulsory, as every expression must have some value.^[4]
   Logic that would be expressed with conditionals in other languages is
   usually expressed with pattern matching in recursive functions.

   Because Haskell is lazy, it is possible to write control structures,
   such as if, as ordinary expressions; the lazy evaluation means that an
   if function can evaluate only the condition and proper branch (where a
   strict language would evaluate all three). It can be written like
if' :: Bool -> a -> a -> a
if' True x _ = x
if' False _ y = y

C-like languages[edit]

   C and C-like languages have a special ternary operator (?:) for
   conditional expressions with a function that may be described by a
   template like this:
condition ? evaluated-when-true : evaluated-when-false

   This means that it can be inlined into expressions, unlike
   if-statements, in C-like languages:
my_variable = x > 10 ? "foo" : "bar";  // In C-like languages

   which can be compared to the Algol-family if-then-else expressions (in
   contrast to a statement) (and similar in Ruby and Scala, among others).

   To accomplish the same using an if-statement, this would take more than
   one line of code (under typical layout conventions), and require
   mentioning "my_variable" twice:
if (x > 10)
    my_variable = "foo";
    my_variable = "bar";

   Some argue that the explicit if/then statement is easier to read and
   that it may compile to more efficient code than the ternary
   operator,^[6] while others argue that concise expressions are easier to
   read than statements spread over several lines containing repetition.

Small Basic[edit]

x = TextWindow.ReadNumber()
If (x > 10) Then
    TextWindow.WriteLine("My variable is named 'foo'.")
    TextWindow.WriteLine("My variable is named 'bar'.")

   First, when the user runs the program, a cursor appears waiting for the
   reader to type a number. If that number is greater than 10, the text
   "My variable is named 'foo'." is displayed on the screen. If the number
   is smaller than 10, then the message "My variable is named 'bar'." is
   printed on the screen.

Visual Basic[edit]

   In Visual Basic and some other languages, a function called IIf is
   provided, which can be used as a conditional expression. However, it
   does not behave like a true conditional expression, because both the
   true and false branches are always evaluated; it is just that the
   result of one of them is thrown away, while the result of the other is
   returned by the IIf function.


   In Tcl if is not a keyword but a function (in Tcl known as command or
   proc). For example
if {$x > 10} {
   puts "Foo!"

   invokes a function named if passing 2 arguments: The first one being
   the condition and the second one being the true branch. Both arguments
   are passed as strings (in Tcl everything within curly brackets is a

   In the above example the condition is not evaluated before calling the
   function. Instead, the implementation of the if function receives the
   condition as a string value and is responsible to evaluate this string
   as an expression in the callers scope.^[7]

   Such a behavior is possible by using uplevel and expr commands:

          Uplevel makes it possible to implement new control constructs as
          Tcl procedures (for example, uplevel could be used to implement
          the while construct as a Tcl procedure).^[8]

   Because if is actually a function it also returns a value:

          The return value from the command is the result of the body
          script that was executed, or an empty string if none of the
          expressions was non-zero and there was no bodyN.^[9]


   In Rust, if is always an expression. It evaluates to the value of
   whichever branch is executed, or to the unit type () if no branch is
   executed. If a branch does not provide a return value, it evaluates to
   () by default. To ensure the if expression's type is known at compile
   time, each branch must evaluate to a value of the same type. For this
   reason, an else branch is effectively compulsory unless the other
   branches evaluate to (), because an if without an else can always
   evaluate to () by default.^[10]
// Assign my_variable some value, depending on the value of x
let my_variable = if x > 20 {
} else {

// This variant will not compile because 1 and () have different types
let my_variable = if x > 20 {

// Values can be omitted when not needed
if x > 20 {
    println!("x is greater than 20");

Arithmetic if[edit]

   Up to Fortran 77, the language Fortran has an "arithmetic if" statement
   which is halfway between a computed IF and a case statement, based on
   the trichotomy x < 0, x = 0, x > 0. This was the earliest conditional
   statement in Fortran:^[11]
IF (e) label1, label2, label3

   Where e is any numeric expression (not necessarily an integer); this is
   equivalent to
IF (e .LT. 0) GOTO label1
IF (e .EQ. 0) GOTO label2
GOTO label3

   Because this arithmetic IF is equivalent to multiple GOTO statements
   that could jump to anywhere, it is considered to be an unstructured
   control statement, and should not be used if more structured statements
   can be used. In practice it has been observed that most arithmetic IF
   statements referenced the following statement with one or two of the

   This was the only conditional control statement in the original
   implementation of Fortran on the IBM 704 computer. On that computer the
   test-and-branch op-code had three addresses for those three states.
   Other computers would have "flag" registers such as positive, zero,
   negative, even, overflow, carry, associated with the last arithmetic
   operations and would use instructions such as 'Branch if accumulator
   negative' then 'Branch if accumulator zero' or similar. Note that the
   expression is evaluated once only, and in cases such as integer
   arithmetic where overflow may occur, the overflow or carry flags would
   be considered also.

Object-oriented implementation in Smalltalk[edit]

   In contrast to other languages, in Smalltalk the conditional statement
   is not a language construct but defined in the class Boolean as an
   abstract method that takes two parameters, both closures. Boolean has
   two subclasses, True and False, which both define the method, True
   executing the first closure only, False executing the second closure
var = condition
    ifTrue: [ 'foo' ]
    ifFalse: [ 'bar' ]


   JavaScript uses if-else statements similar to those in C languages or
   similar. A boolean value is accepted within parentheses between the
   reserved if keyword and a left curly bracket.
if (Math.random() < 0.5) {
  console.log("You got Heads!");
} else {
  console.log("You got Tails!");

   The above example takes the conditional of Math.random() < 0.5 which
   outputs true if a random float value between 0 and 1 is greater than
   0.5. The statement uses it to randomly choose between outputting You
   got Heads! or You got Tails! to the console. Else and else-if
   statements can also be chained after the curly bracket of the statement
   preceding it as many times as necessary, as shown below:
var x = Math.random();
if (x < 1/3) {
  console.log("One person won!");
} else if (x < 2/3) {
  console.log("Two people won!");
} else {
  console.log("It's a three-way tie!");

Lambda calculus[edit]

   In Lambda calculus, the concept of an if-then-else conditional can be
   expressed using the expressions:
true = lx. ly. x
false = lx. ly. y
ifThenElse = (lc. lx. ly. (c x y))

    1. true takes up to two arguments and once both are provided (see
       currying), it returns the first argument given.
    2. false takes up to two arguments and once both are provided(see
       currying), it returns the second argument given.
    3. ifThenElse takes up to three arguments and once all are provided,
       it passes both second and third argument to the first
       argument(which is a function that given two arguments, and produces
       a result). We expect ifThenElse to only take true or false as an
       argument, both of which project the given two arguments to their
       preferred single argument, which is then returned.

   note: if ifThenElse is passed two functions as the left and right
   conditionals; it is necessary to also pass an empty tuple () to the
   result of ifThenElse in order to actually call the chosen function,
   otherwise ifThenElse will just return the function object without
   getting called.

   In a system where numbers can be used without definition (like Lisp,
   Traditional paper math, so on), the above can be expressed as a single
   closure below:
 ((ltrue. lfalse. lifThenElse.
     (ifThenElse true 2 3)
 )(lx. ly. x)(lx. ly. y)(lc. ll. lr. c l r))

   Here, true, false, and ifThenElse are bound to their respective
   definitions which are passed to their scope at the end of their block.

   A working JavaScript analogy(using only functions of single variable
   for rigor) to this is:
 var computationResult = ((_true => _false => _ifThenElse =>
 )(x => y => x)(x => y => y)(c => x => y => c(x)(y)));

   The code above with multivariable functions looks like this:
 var computationResult = ((_true, _false, _ifThenElse) =>
     _ifThenElse(_true, 2, 3)
 )((x, y) => x, (x, y) => y, (c, x, y) => c(x, y));

   another version of the earlier example without a system where numbers
   are assumed is below.

   First example shows the first branch being taken, while second example
   shows the second branch being taken.
 ((ltrue. lfalse. lifThenElse.
     (ifThenElse true (lFirstBranch. FirstBranch) (lSecondBranch. SecondBranch))
 )(lx. ly. x)(lx. ly. y)(lc. ll. lr. c l r))

 ((ltrue. lfalse. lifThenElse.
     (ifThenElse false (lFirstBranch. FirstBranch) (lSecondBranch. SecondBranch)
 )(lx. ly. x)(lx. ly. y)(lc. ll. lr. c l r))

   Smalltalk uses a similar idea for its true and false representations,
   with True and False being singleton objects that respond to messages
   ifTrue/ifFalse differently.

   Haskell used to use this exact model for its Boolean type, but at the
   time of writing, most Haskell programs use syntactic sugar "if a then b
   else c" construct which unlike ifThenElse does not compose unless
   either wrapped in another function or re-implemented as shown in The
   Haskell section of this page.

Case and switch statements[edit]

   Main article: Switch statement

   Switch statements (in some languages, case statements or multiway
   branches) compare a given value with specified constants and take
   action according to the first constant to match. There is usually a
   provision for a default action ('else','otherwise') to be taken if no
   match succeeds. Switch statements can allow compiler optimizations,
   such as lookup tables. In dynamic languages, the cases may not be
   limited to constant expressions, and might extend to pattern matching,
   as in the shell script example on the right, where the '*)' implements
   the default case as a regular expression matching any string.

        Pascal:       C: Shell script:
case someChar of
  'a': actionOnA;
  'x': actionOnX;
  else actionOnNoMatch;

switch (someChar) {
  case 'a': actionOnA; break;
  case 'x': actionOnX; break;
  case 'y':
  case 'z': actionOnYandZ; break;
  default: actionOnNoMatch;

case $someChar in
   a)    actionOnA; ;;
   x)    actionOnX; ;;
   [yz]) actionOnYandZ; ;;
  *)     actionOnNoMatch  ;;

Pattern matching[edit]

   Main article: Pattern matching

   Pattern matching may be seen as an alternative to both if-then-else,
   and case statements. It is available in many programming languages with
   functional programming features, such as Wolfram Language, ML and many
   others. Here is a simple example written in the OCaml language:

match fruit with
| "apple" -> cook pie
| "coconut" -> cook dango_mochi
| "banana" -> mix;;

   The power of pattern matching is the ability to concisely match not
   only actions but also values to patterns of data. Here is an example
   written in Haskell which illustrates both of these features:

map _ []      = []
map f (h : t) = f h : map f t

   This code defines a function map, which applies the first argument (a
   function) to each of the elements of the second argument (a list), and
   returns the resulting list. The two lines are the two definitions of
   the function for the two kinds of arguments possible in this case - one
   where the list is empty (just return an empty list) and the other case
   where the list is not empty.

   Pattern matching is not strictly speaking always a choice construct,
   because it is possible in Haskell to write only one alternative, which
   is guaranteed to always be matched - in this situation, it is not being
   used as a choice construct, but simply as a way to bind names to
   values. However, it is frequently used as a choice construct in the
   languages in which it is available.

Hash-based conditionals[edit]

   In programming languages that have associative arrays or comparable
   data structures, such as Python, Perl, PHP or Objective-C, it is
   idiomatic to use them to implement conditional assignment.^[13]

pet = input("Enter the type of pet you want to name: ")
known_pets = {
    "Dog": "Fido",
    "Cat": "Meowsles",
    "Bird": "Tweety",
my_name = known_pets[pet]

   In languages that have anonymous functions or that allow a programmer
   to assign a named function to a variable reference, conditional flow
   can be implemented by using a hash as a dispatch table.


   Main article: Branch predication

   An alternative to conditional branch instructions is predication.
   Predication is an architectural feature that enables instructions to be
   conditionally executed instead of modifying the control flow.

Choice system cross reference[edit]

   This table refers to the most recent language specification of each
   language. For languages that do not have a specification, the latest
   officially released implementation is referred to.

   Programming language Structured if switch-select-case Arithmetic if
   Pattern matching^[A]
   then else else-if
   Ada Yes Yes Yes Yes No No
   APL No Yes Yes Yes No No
   Bash shell Yes Yes Yes Yes No Yes
   C, C++ No Yes unneeded^[B]^[C] Fall-through No No
   C# No Yes Unneeded^[B]^[C] Yes No No
   COBOL Yes Yes Unneeded^[C] Yes No No
   Eiffel Yes Yes Yes Yes No No
   F# Yes Yes Yes Unneeded^[D] No Yes
   Fortran 90 Yes Yes Yes Yes Yes^[G] No
   Go No Yes Unneeded^[C] Yes No No
   Haskell Yes Needed Unneeded^[C] Yes, but unneeded^[D] No Yes
   Java No Yes Unneeded^[C] Fall-through^[14] No No
   ECMAScript (JavaScript) No Yes Unneeded^[C] Fall-through^[15] No No
   Mathematica No Yes Yes Yes No Yes
   Oberon Yes Yes Yes Yes No No
   Perl No Yes Yes Yes No No
   PHP No Yes Yes Fall-through No No
   Pascal, Object Pascal (Delphi) Yes Yes Unneeded Yes No No
   Python No Yes Yes No No Yes
   QuickBASIC Yes Yes Yes Yes No No
   Ruby Yes Yes Yes Yes No Yes^[H]
   Rust No Yes Yes Unneeded No Yes
   Scala No Yes Unneeded^[C] Fall-through^[citation needed] No Yes
   SQL Yes^[F] Yes Yes Yes^[F] No No
   Swift No Yes Yes Yes No Yes
   Tcl No Yes Yes Yes No Yes
   Visual Basic, classic Yes Yes Yes Yes No No
   Visual Basic .NET Yes Yes Yes Yes No No
   Windows PowerShell No Yes Yes Fall-through No No

    1. ^^ This refers to pattern matching as a distinct conditional
       construct in the programming language - as opposed to mere string
       pattern matching support, such as regular expression support.


   ^2 An #ELIF directive is used in the preprocessor sub-language that is
   used to modify the code before compilation; and to include other files.

     ^1 ^2 ^3 ^4 ^5 ^6 The often-encountered else if in the C family of
   languages, and in COBOL and Haskell, is not a language feature but a
   set of nested and independent if then else statements combined with a
   particular source code layout. However, this also means that a distinct
   else-if construct is not really needed in these languages.

     ^1 ^2 In Haskell and F#, a separate constant choice construct is
   unneeded, because the same task can be done with pattern matching.

     ^^ In a Ruby case construct, regular expression matching is among the
   conditional flow-control alternatives available. For an example, see
   this Stack Overflow question.

     ^1 ^2 SQL has two similar constructs that fulfill both roles, both
   introduced in SQL-92. A "searched CASE" expression CASE WHEN cond1 THEN
   expr1 WHEN cond2 THEN expr2 [...] ELSE exprDflt END works like if ...
   else if ... else, whereas a "simple CASE" expression: CASE expr WHEN
   val1 THEN expr1 [...] ELSE exprDflt END works like a switch statement.
   For details and examples see Case (SQL).

     ^^ Arithmetic if is obsolescent in Fortran 90.

     ^^ Pattern matching was added in Ruby 3.0.^[16] Some pattern matching
   constructs are still experimental.

See also[edit]

     * Branch (computer science)
     * Conditional compilation
     * Dynamic dispatch for another way to make execution choices
     * McCarthy Formalism for history and historical references
     * Named condition
     * Relational operator
     * Test (Unix)
     * Yoda conditions
     * Conditional move


    1. ^ PHP elseif syntax
    2. ^ Visual Basic ElseIf syntax
    3. ^ POSIX standard shell syntax
    4. ^ Haskell 98 Language and Libraries: The Revised Report
    5. ^ "If-then-else Proposal on HaskellWiki"
    6. ^ "Efficient C Tips #6 - Don't use the ternary operator << Stack
       Overflow". Embeddedgurus.com. 2009-02-18. Retrieved 2012-09-07.
    7. ^ "New Control Structures". Tcler's wiki. Retrieved August 21,
    8. ^ "uplevel manual page". www.tcl.tk. Retrieved August 21, 2020.
    9. ^ "if manual page". www.tcl.tk. Retrieved August 21, 2020.
   10. ^ "If and if let expressions". Retrieved November 1, 2020.
   11. ^ "American National Standard Programming Language FORTRAN".
       1978-04-03. Archived from the original on 2007-10-11. Retrieved
   12. ^ "VisualWorks: Conditional Processing". 2006-12-16. Archived from
       the original on 2007-10-22. Retrieved 2007-09-09.
   13. ^ "Pythonic way to implement switch/case statements". Archived from
       the original on 2015-01-20. Retrieved 2015-01-19.
   14. ^ Java.sun.com, Java Language Specification, 3rd Edition.
   15. ^ Ecma-international.org Archived 2015-04-12 at the Wayback Machine
       ECMAScript Language Specification, 5th Edition.
   16. ^ "Pattern Matching". Documentation for Ruby 3.0.

External links[edit]

   Look up then or else in Wiktionary, the free dictionary.

     * Media related to Conditional (computer programming) at Wikimedia
     * IF NOT (ActionScript 3.0) video

   Retrieved from

     * Conditional constructs

   Hidden categories:
     * Webarchive template wayback links
     * Articles with short description
     * Short description matches Wikidata
     * All articles with unsourced statements
     * Articles with unsourced statements from November 2015
     * Commons category link from Wikidata
     * Articles with example pseudocode
     * Articles with example C code
     * Articles with example Pascal code
     * Articles with example Haskell code
     * Articles with example Python (programming language) code

Navigation menu

Personal tools

     * Not logged in
     * Talk
     * Contributions
     * Create account
     * Log in


     * Article
     * Talk

   [ ] English


     * Read
     * Edit
     * View history

   [ ] More


   ____________________ Search Go


     * Main page
     * Contents
     * Current events
     * Random article
     * About Wikipedia
     * Contact us
     * Donate


     * Help
     * Learn to edit
     * Community portal
     * Recent changes
     * Upload file


     * What links here
     * Related changes
     * Upload file
     * Special pages
     * Permanent link
     * Page information
     * Cite this page
     * Wikidata item


     * Download as PDF
     * Printable version

In other projects

     * Wikimedia Commons


     * a+l+e+r+b+y+tm
     * Az@rbaycanca
     * B"lgarski
     * Catal`a
     * Cestina
     * Deutsch
     * Eesti
     * Espanol
     * Esperanto
     * f+a+r+s+
     * Franc,ais
     * Hrvatski
     * Bahasa Indonesia
     * Italiano
     * E+B+R+J+T+
     * Magyar
     * Bahasa Melayu
     * Norsk bokmaal
     * Olyk marij
     * Polski
     * Portugues
     * Russkij
     * Srpski / srpski
     * Suomi
     * Svenska
     * Ukrayins'ka
     * Tie>'ng Vie>-.t

   Edit links

     * This page was last edited on 25 July 2022, at 10:42 (UTC).
     * Text is available under the Creative Commons Attribution-ShareAlike
       License 3.0; additional terms may apply. By using this site, you
       agree to the Terms of Use and Privacy Policy. Wikipedia(R) is a
       registered trademark of the Wikimedia Foundation, Inc., a
       non-profit organization.

     * Privacy policy
     * About Wikipedia
     * Disclaimers
     * Contact Wikipedia
     * Mobile view
     * Developers
     * Statistics
     * Cookie statement

     * Wikimedia Foundation
     * Powered by MediaWiki
Saved from web.archive.org, with Lynx.
Main page
© 2022 Matei. No cookies®