Absfunction

Syntax

Abs(z)

gives the absolute value of the (complex) number z.

Details

If z is an exact numerical expression, the numerical estimation of z is used to decide about the sign.
For special cases of z, some simplifications are performed.

Examples

Abs(-123)123

Abs(1.2 + 3.4*I)3.60555

Abs(3+4*I)5

Abs uses the numerical estimation of an expression to decide about the sign of the result.

Abs(Sin(4))-Sin(4)

-Sin(4) // Calculate0.756802

Simplifications are performed if possible.

Abs(-2*x)2*Abs(x)

Abs(x^3)Abs(x)^3

Allconstant

Syntax

All

can be used to specifies all elements.

Details

All can usually be used in Part[…] to pick all element from a particular level.

Examples

Part( {{a1,a2}, {b1,b2}, {c1,c2}} , All, 1 ){a1, b1, c1}

{"Hello", "World!"}[All, 1]{"H", "W"}

Alternatives|function

Syntax

Alternatives(pat₁, pat₂, … )pat₁ | pat₂ | …

is a pattern object that represents any pattern pat_i during a pattern matching.

Details

Alternatives can be understand as an OR operation for pattern objects, similar to Or|| for logical and binary expressions.

Examples

Matching( b, a|b )True

Alternatives can be used for replacements:

Replace( {a, b, c, a, b, c} , a|b -> 0 ){0, 0, c, 0, 0, c}

A definition of a function which excapts only integer and rational numbers.

f( x?Rational | x?Integer ) := x^2; { f(2), f(1.0), f(1/2) }{4, f(1.0), 1/4}

And&&function

Syntax

And(bool₁, bool₂, … )bool₁ && bool₂ && …

gives the logical AND of bool_i.

And(int₁, int₂, … )int₁ && int₂ && …

gives the binary AND of the integers int_i.

And(str₁, str₂, … )str₁ && str₂ && …

gives the binary AND of the strings str_i.

Details

The arguments of And are evaluated step by step.
And gives False immediately if any argument is False, and True if all arguments are True.
And() is defined as True.
And(exp) is simplified to exp.
Integers are handled in their two's complement form.
Strings are converted into binary form and And is performed bitwise.

Examples

True && FalseFalse

12 && 74

'BINARY' && 'abc''@@B'

And stops to evaluate its arguments if False occurs. In the following case the second Print is not evaluated.

(Print(1);True) && False && (Print(2);True)1False

Expressions which are evaluated into True will be erased.

2==2 && a==5 && b==10 && Truea == 5 && b == 10

Any?function

Syntax

Any?

is a pattern object that matches to any object.

Any(head)?head

matches to any object having the head head.

Details

Any is typical used in assignments and rules.

Examples

Matching( f(123), Any )True

Matching( f(123), Any(f) )True

Any can used in rules for replacements.

Replace( { 1, 1.0, 1/2, 4 } , ?Integer -> x ){x, 1.0, 1/2, x}

Any can used in an assignment as a pattern for an argument.

f(?Real) = "real"; { f(1), f(1.0), f(2^0.5) }{f(1), "real", "real"}

Possible Issues

In functions like Plus+ and Times*, Any does not differ from other symbols and is transformed.

? + ? Matching( a + b, ? + ? ) Matching( a + b, x? + y? )2*? False True

AnyNullSequence???function

Syntax

AnyNullSequence???

is a pattern object that matches to a sequence of any objects, even an empty sequence of no object.

AnyNullSequence(head)???head

matches to a sequence of objects all having the head head, or an empty sequence.

Details

AnyNullSequence is typical used in assignments and rules.

Examples

Matching( f(), f(AnyNullSequence) )True

Matching( f(x, y), f(AnyNullSequence(Symbol)) )True

Matching( f(), f(AnyNullSequence(Symbol)) )True

AnyNullSequence can used in an assignment as a pattern for a sequence of arguments.

f(???Real) = "reals or nothing"; { f(), f(1.0), f(1.0, 2.0), f(1) }{"reals or nothing", "reals or nothing", "reals or nothing", f(1)}

AnySequence??function

Syntax

AnySequence??

is a pattern object that matches to a sequence of any objects.

AnySequence(head)??head

matches to a sequence of objects all having the head head.

Details

AnySequence is typical used in assignments and rules.

Examples

Matching( f(1, 2, 3), f(AnySequence) )True

Matching( f(x, y), f(AnySequence(Symbol)) )True

AnySequence can used in an assignment as a pattern for a sequence of arguments.

f(??Real) = "reals"; { f(1), f(1.0), f(1.0, 2.0), f(1, 0.5) }{f(1), "reals", "reals", f(1, 0.5)}

Applyfunction

Syntax

Apply(h, exp)

replaces the head of expression exp with h.

Details

After the new head is set, the whole expression is evaluated.

Examples

Apply(g, f(1, a, x))g(1, a, x)

Apply(Plus, {2, 3, 4})9

Apply(Times, a+b+c)a*b*c

Apply(f, a+b)f(a, b)

Apply will process anonymous function as well:

Apply( {#1^#2, #2^#1} & , {3, 2} ){9, 8}

ArcCosfunction

Syntax

ArcCos(z)

gives the arcus cosine of z.

Details

ArcCos gives an exact result when possible.
If z is an exact numerical value, ArcCos remains unevaluated if no exact solution was found.
ArcCos gives complex results when z is not real or |z| > 1.

Examples

ArcCos(0.5)1.0472

Calculate(ArcCos(1/2), 70)1.047197551196597746154214461093167628065723133125035273658314864102605

ArcCos(1.2)0.622363*I

ArcCos(2.0+3.0*I)1.00014-1.98339*I

Particular arguments and their result:

ArcCos(-1)Pi

ArcCos(0)1/2*Pi

ArcCos(1/2)1/3*Pi

ArcCos(1)0

ArCoshfunction

Syntax

ArCosh(z)

gives the area hyperbolic cosine of z.

Details

ArCosh gives an exact result when possible.
If z is an exact numerical value, ArCosh remains unevaluated if no exact solution was found.
ArCosh gives complex results when z is not real or |z| < 1.

Examples

ArCosh(1.5)0.962424

Calculate(ArCosh(3/2), 70)0.9624236501192068949955178268487368462703686687713210393220363376803277

ArCosh(0.2)1.36944*I

ArCosh(2.0+3.0*I)1.98339+1.00014*I

Particular arguments and their result:

ArCosh(1)0

ArCosh(-1)I*Pi

ArCosh(0)1/2*I*Pi

ArCosh(1/2)1/3*I*Pi

ArcSinfunction

Syntax

ArcSin(z)

gives the arcus sine of z.

Details

ArcSin gives an exact result when possible.
If z is an exact numerical value, ArcSin remains unevaluated if no exact solution was found.
ArcSin gives complex results when z is not real or |z| > 1.

Examples

ArcSin(0.5)0.523599

Calculate(ArcSin(1/2), 70)0.5235987755982988730771072305465838140328615665625176368291574320513027

ArcSin(1.2)1.5708-0.622363*I

ArcSin(2.0+3.0*I)0.570653+1.98339*I

Particular arguments and their result:

ArcSin(-1)-1/2*Pi

ArcSin(0)0

ArcSin(1/2)1/6*Pi

ArcSin(1)1/2*Pi

ArcTanfunction

Syntax

ArcTan(z)

gives the arcus tangent of z.

ArcTan(x,y)

gives the arcus tangent of y/x, taking into account the quadrant of the point (x, y).

Details

ArcTan gives an exact result when possible.
If z is an exact numerical value, ArcTan remains unevaluated if no exact solution was found.

Examples

ArcTan(2.0)1.10715

Calculate(ArcTan(2), 70)1.107148717794090503017065460178537040070047645401432646676539207433710

ArcTan(2.0+3.0*I)1.40992+0.229073*I

Particular arguments and their result:

ArcTan(0)0

ArcTan(1)1/4*Pi

ArcTan(3^(1/2))1/3*Pi

ArcTan(Infinity)1/2*Pi

ArcTan with two arguments:

ArcTan(1, 1)1/4*Pi

ArcTan(-1, 0)Pi

ArcTan(-1.0, -3.0)-1.89255

Argfunction

Syntax

Arg(z)

gives the argument of the (complex) number z.

Details

Arg gives the phase angle in radians between -Pi and Pi.
Arg is 0 for positive non-complex numbers, and Pi for negative non-complex numbers.
Arg(0) is 0.
For special cases of z, some simplifications are performed.

Examples

Arg(1.2 + 3.4*I)1.2315

Arg(-123)Pi

Arg(1+I)1/4*Pi

Arg(2.5)0

Simplifications are performed if possible.

Arg(-2*x)Arg(-x)

Arg(x^(1/3))1/3*Arg(x)

Arg(Abs(z))0

ArSinhfunction

Syntax

ArSinh(z)

gives the area hyperbolic sine of z.

Details

ArSinh gives an exact result when possible.
If z is an exact numerical value, ArSinh remains unevaluated if no exact solution was found.
ArSinh gives complex results when z is not real.

Examples

ArSinh(1.5)1.19476

Calculate(ArSinh(3/2), 70)1.194763217287109304111930828519090523536162075153005429270680299461324

ArSinh(2.0+3.0*I)1.96864+0.964659*I

Particular arguments and their result:

ArSinh(0)0

ArSinh(1*I)1/2*I*Pi

ArSinh(1/2*I)1/6*I*Pi

ArTanhfunction

Syntax

ArTanh(z)

gives the area hyperbolic tangent of z.

Details

ArTanh gives an exact result when possible.
If z is an exact numerical value, ArTanh remains unevaluated if no exact solution was found.
ArTanh gives complex results when z is not real or |z| > 1.

Examples

ArTanh(0.5)0.549306

Calculate(ArTanh(1/2), 70)0.5493061443340548456976226184612628523237452789113747258673471668187471

ArTanh(1.5)0.804719-1.5708*I

ArTanh(2.0+3.0*I)0.146947+1.33897*I

Particular arguments and their result:

ArTanh(0)0

ArTanh(1)-Infinity

ArTanh(I)1/4*I*Pi

ArTanh(-Infinity)1/2*I*Pi

Attributesfunction

Syntax

Attributes(s)

gives a list of all set attributes for symbol s.

Attributes(s) = attr

sets the attribute attr for symbol s.

Attributes(s) = {attr₁, attr₂, …}

sets the attributes attr_i for symbol s.

Details

During the set of attributes all old attributes are removed.

The following set of attributes can be used for a symbol f:

Flat	`f` is associative.
Orderless	`f` is commutative.
Listable	`f` is automatically threaded over List{…}.
Protected	Definitions of `f` cannot be changed.
Locked	Attributes of `f` cannot be changed.

Examples

Attributes(Plus){Flat, Listable, Locked, NumericFunction, OneIdentity, Orderless, Protected}

Define an orderless and flat expression:

f(1, z, f(a, 2))f(1, z, f(a, 2))

Attributes(f) = {Orderless, Flat}{Orderless, Flat}

f(1, z, f(a, 2))f(1, 2, a, z)

Define a function that threads over lists:

Attributes(g) = Listable; g(x?) := "<" ~ ToString(x) ~ ">"Null

g(7)"<7>"

g({-1,2,a}){"<-1>", "<2>", "<a>"}

BinaryFormatoption

Syntax

BinaryFormat -> type

is an option to define the binary format for numeric and string representations.

Details

BinaryFormat can be used in ToString, ToInteger, and ToReal.

type is a string and can be one of the following formats:

Integer formats:
`"Integer8"`, `"int8"`	8-bit signed integer
`"Integer16"`, `"int16"`	16-bit signed integer ¹⁾
`"Integer32"`, `"int32"`	32-bit signed integer ¹⁾
`"Integer64"`, `"int64"`	64-bit signed integer ¹⁾
`"IntegerN"`, `"intn"`	n-bit signed integer ^{1) 2)}
`"UnsignedInteger8"`, `"uint8"`	8-bit unsigned integer
`"UnsignedInteger16"`, `"uint16"`	16-bit unsigned integer ¹⁾
`"UnsignedInteger32"`, `"uint32"`	32-bit unsigned integer ¹⁾
`"UnsignedInteger64"`, `"uint64"`	64-bit unsigned integer ¹⁾
`"UnsignedIntegerN"`, `"uintn"`	n-bit unsigned integer ^{1) 2)}
Floating-point formats:
`"Real16"`, `"float16"`, `"half"`	16-bit IEEE 754 floating point number
`"Real32"`, `"float32"`, `"single"`	32-bit IEEE 754 floating point number
`"Real64"`, `"float64"`, `"double"`	64-bit IEEE 754 floating point number
`"Complex32"`	Two 16-bit IEEE 754 floating point numbers
`"Complex64"`	Two 32-bit IEEE 754 floating point numbers
`"Complex128"`	Two 64-bit IEEE 754 floating point numbers
String formats:
`"ANSI"`	Windows codepage 1252 - latin 1 encoded string
`"UTF8"`	UTF-8 encoded string
`"UTF16"`	UTF-16 encoded string ¹⁾
`"UTF32"`	UTF-32 encoded string ¹⁾
¹⁾ By default the order of bytes are handled as little-endian. Use Endianness to change it.
²⁾ The size depends on the most significant bit and is rounded to a full byte.

Examples

Handling different number formats:

ToString(12345, BinaryFormat->"Integer16") ToString(3.1415, BinaryFormat->"double")'90' 'o\x12\x83ÀÊ!\t@'

ToInteger('ÿ', BinaryFormat->"Integer8") ToInteger('ÿ', BinaryFormat->"UnsignedInteger8")-1 255

Handling different string formats:

ToString("yä€𝄞", BinaryFormat->"ANSI") ToString("yä€𝄞", BinaryFormat->"UTF8") ToString("yä€𝄞", BinaryFormat->"UTF16", Endianness->-1) ToString("yä€𝄞", BinaryFormat->"UTF16", Endianness->1) ToString("yä€𝄞", BinaryFormat->"UTF32")'yä\x80?' 'yÃ¤â\x82¬ð\x9D\x84\x9E' 'y\0ä\0¬ 4Ø\x1EÝ' '\0y\0ä ¬Ø4Ý\x1E' 'y\0\0\0ä\0\0\0¬ \0\0\x1EÑ\x01\0'

ToString('yÃ¤â\x82¬ð\x9D\x84\x9E', BinaryFormat->"UTF8") ToString('\0y\0ä ¬Ø4Ý\x1E', BinaryFormat->"UTF16", Endianness->1)"yä€𝄞" "yä€𝄞"

Possible Issues

An error is given, if the format is insufficient for the whole number or its precision.

ToString(12345, BinaryFormat->"Integer8") ToString(12345, BinaryFormat->"float16")ToString.InsufficientBinaryFormat: Specified format Integer8 is insufficient to represent the whole number 12345 or its precision.ToString.InsufficientBinaryFormat: Specified format float16 is insufficient to represent the whole number 12345 or its precision.'9' '\ar'

ToReal('\ar', BinaryFormat->"float16")12344.0

Binomialfunction

Syntax

Binomial(n, k)

gives the binomial coefficient n choose k.

Details

Binomial(n, k) is defined via Factorial! as
n!
k! (n−k)!
.
Binomial is processing non-integer values too.

Examples

Binomial(49, 6)13983816

Binomial(365, 31)884481797664650696626118102000059032909354320

Binomial(7/2, 3/2)35/8

Binomial(3.5, 2.1)4.26099

Binomial keeps partial products as small as possible to avoid overflows.

(10^20)!Integer.Overflow: Integer overflow during computation with integers detected.Overflow

Binomial(10^20, 3)166666666666666666661666666666666666666700000000000000000000

Boolefunction

Syntax

Boole(bool)

gives 0 if bool is True and 1 if bool is False.

Details

Boole is effectively equivalent to If(bool, 1, 0).
Boole remains unevaluated if bool is neither True nor False.

Examples

Boole(False)0

Boole(32 > 30)1

Boole(a<b)Boole(a < b)

Calculatefunction

Syntax

Calculate(exp)

evaluates the expression exp to a real or complex number with machine precision.

Calculate(exp, n)

evaluates the expression exp to a real or complex number with precision n.

Details

Usually, expressions with exclusively exact values, will keep exact results.
Use Calculate to receive an approximate numerical value of them.
Calculate, with a specified precision n, uses internally a higher precision to ensure the required precision of the result.

Examples

Log(-5)I*Pi + Log(5)

Log(-5) // Calculate1.60944+3.14159*I

Calculate a set of expressions:

x = { 4/6 , Cos(3) , Cos(Pi/6) }{2/3, Cos(3), 1/2*3^(1/2)}

Calculate(x){0.666667, -0.989992, 0.866025}

Calculate any exact expressions with a specified precision:

Calculate(Log(-5), 25)1.609437912434100374600759+3.141592653589793238462643*I

Calculate(Cos(2^10), 50)0.98735361821984829524651338092244419111051208085007

Possible Issues

It is not possible to increase the precision of an inexact number:

x = Calculate(Pi, 15)3.14159265358979

Calculate(x, 30)3.14159265358979

In some cases the internally higher precision is not enough to ensure the required precision of the result:

y = Calculate(Sin(10^40), 30)Calculate.ExtraPrecisionLimit: Internal extra precision limit (32) reached during calculation.-0.569633400953636327308

y // Precision21.6803

A subtraction of almost equal numbers can can lead to strong loss of precision.

Calculate(Exp(1/10^100)-1, 30)Calculate.ExtraPrecisionLimit: Internal extra precision limit (32) reached during calculation.0.e-61

Ceilfunction

Syntax

Ceil(x)

gives the smallest integer greater than or equal to x.

Details

If x is an exact numerical expression, the numerical approximation of x is used to establish the result.
For a complex number x, Ceil is applied separately to the real and imaginary part.

Examples

Ceil(2.1)3

Ceil(-2.9)-2

Ceil(3/8)1

Ceil(1.2 + 3.8*I)2+4*I

Ceil(Log(10))3

Processing of Overflow and Underflow:

Ceil(Overflow)Overflow

Ceil(Underflow)1

Ceil(-Underflow)0

Clearfunction

Syntax

Clear(s)

removes all assignment rule defined to symbol s.

Details

Clear can be used to remove assignments defined by Define=, DefineDelayed:=, SubDefine@=, and SubDefineDelayed@:=.
If s is a List{…}, Clear is applied on all its elements.

Examples

Remove an assignment from a single symbols:

x = 123123

x^215129

Clear(x)Null

x^2x^2

Remove all assignments:

f(10) = 0 f(z?Integer) := 2*z f(z?) * w? @:= -w*z0

Definitions(f)f(10) = 0f(Pattern(z, ?Integer)) := 2*zf(Pattern(z, ?))*Pattern(w, ?) := Minus(w*z)Null

Clear(f)Null

Definitions(f)/* no definitions */Null

Complementfunction

Syntax

Complement(list, list₁, list₂, … )

gives a sorted list of all distinct elements that appear in list but not in any of list_i.

Details

If the lists list and list_i are considered as sets, Complement gives their complement list \ list₁.
Complement works with any kind of expressions as long as they have the same head.

Examples

Complement( {4,2,3,2,1} , {1,4} ){2, 3}

Complement( {x, y, z} , {y} ){x, z}

Complement( {1,2,3,4} , {1,2} , {2,3} ){4}

Complement works with any expressions, not only lists, as long as they have the same head.

Complement( a + b + c + d , a + c )b + d

Complement( f(1, 4, 2), f(2, 3) )f(1, 4)

Possible Issues

Heads have to be the same when Complement is applied on expressions.

Complement( f(1, 4, 2), g(2, 3) )Complement.Heads: Heads f and g are not the same.Complement(f(1, 4, 2), g(2, 3))

Complex`x`+`y`*Iobject

Syntax

x + y*I

is a complex number with a real part x and imaginary part y multiplied with the imaginary unit I.

Complex

is the head of a complex number.

Details

Both parts x and y can be of the type Integern, Rationala/b or Realx.
Complex numbers are exact numbers as long as both parts are exact numbers.
If either the real part or the imaginary part is an inexact number, the other part is not effected by this inaccuracy.
ComplexOverflow and ComplexUnderflow are two special complex numbers representing a float pointing overflow or underflow, respectively.

Examples

Head(1+2*I)Complex

(1-I)^3-2-2*I

1/2 + 0.4*I1/2+0.4*I

Sqrt(-4)2*I

Log(-0.5)-0.693147+3.14159*I

Possible Issues

Combinations of ComplexOverflow and ComplexUnderflow can result in Indeterminate.

ComplexOverflow * ComplexUnderflowIndeterminate

ComplexInfinityconstant

Syntax

ComplexInfinity

represents the mathematical infinite quantity with an undetermined complex phase.

Details

ComplexInfinity is the short form of DirectedInfinity().
ComplexInfinity is handled in calculations as an exact number.
ComplexInfinity keeps exact computation possible, unlike ComplexOverflow.
The magnitude of ComplexInfinity is even larger than ComplexOverflow.

Examples

Abs(ComplexInfinity) > Abs(ComplexOverflow)True

Arithmetical and mathematical functions are able to process ComplexInfinity:

1 / ComplexInfinity0

1 / 0ComplexInfinity

Log(ComplexInfinity)Infinity

ComplexOverflowconstant

Syntax

ComplexOverflow

represents an overflow in float-pointing arithmetic with complex numbers.

Details

The head of ComplexOverflow is Complex.
The magnitude of ComplexOverflow is always larger than the highest possible magnitude of a complex value, but always smaller than ComplexInfinity.

Examples

(7.0+4.0*I) ^ Exp(100.0)ComplexOverflow

Arithmetical and mathematical functions are able to process ComplexOverflow:

3.14 + ComplexOverflowComplexOverflow

ComplexOverflow * (-2)ComplexOverflow

Abs( ComplexOverflow )Overflow

Arg( ComplexOverflow )Indeterminate

ComplexUnderflowconstant

Syntax

ComplexUnderflow

represents an underflow in float-pointing arithmetic with complex numbers.

Details

The head of ComplexUnderflow is Complex.
The magnitude of ComplexUnderflow is always smaller than the lowest possible magnitude of a complex value, but always larger than 0.

Examples

(7.0+4.0*I) ^ (-Exp(100.0))ComplexUnderflow

Arithmetical and mathematical functions are able to process ComplexUnderflow:

3.14 + ComplexUnderflow3.14+0.0*I

ComplexUnderflow * (-2)ComplexUnderflow

1 / ComplexUnderflowIndeterminate

Abs( ComplexUnderflow )Underflow

Arg( ComplexUnderflow )Indeterminate

Compound;function

Syntax

Compound(exp₁, exp₂, … )exp₁ ; exp₂ ; …

evaluates all expressions exp_i in turn and gives the last one as result.

exp;

evaluates exp but gives Null as result.

Details

Compound is usually used in expressions to perform multiple calculations.

Examples

x = 1 ; y = 2 ; x + y3

z = 10^10000;Null

Log(10, z)10000

Condition/?function

Syntax

Condition(pat, cond)pat /? cond

is a pattern object that matches only if the evaluation of cond yields True.

Details

The condition is only evaluated if the pattern pat matches at all.
Condition can be applied to a single pattern object or to a whole expression.
In a collection of definitions, the next definition is tried if cond yields not True.
That distinguishes the use of Condition/? instead of If.

Examples

Matching( 1, x? /? x>0 ) Matching( -1, x? /? x>0 )True False

Using Condition in a single argument:

f(x? /? x!=0) := 1/xNull

f(2) f(1/2) f(0)1/2 2 f(0)

Using Condition for the whole definition:

g(x?, y?) /? x>y := x^yNull

g(10, 2) g(2, 4) g(x, 3)100 g(2, 4) g(x, 3)

Using Condition for a replacement rule:

Replace( {-1,2,-3,4,-5,6} , x?Integer /? x<0 -> 0 ){0, 2, 0, 4, 0, 6}

The difference between a definition with Condition/? instead of a definition with If:

g( x? /? x!=1 ) := (x^2-1)/(x-1) /* general definition with exception */ h(x?) := If( x!=1 , (x^2-1)/(x-1) , "problem" ) /* definition with If */Null

{ g(0.0) , g(1.0) , g(2.0) } { h(0.0) , h(1.0) , h(2.0) }{1.0, g(1.0), 3.0} {1.0, "problem", 3.0}

Conjugatefunction

Syntax

Conjugate(z)

gives the complex conjugate of the complex number z.

Details

Conjugate flips the sign of the imaginary part.
For special cases of z, some simplifications are performed.

Examples

Conjugate(1+I)1-I

Conjugate(1.2 - 3.4*I)1.2+3.4*I

Conjugate(-123)-123

Conjugate(I*Infinity)DirectedInfinity(-I)

Simplifications are performed if possible.

Conjugate(-2*x)-2*Conjugate(x)

Conjugate(Log(3+I))Log(3-I)

Conjugate((-2)^(1/2))-I*2^(1/2)

Cosfunction

Syntax

Cos(z)

gives the cosine of z.

Details

Cos gives an exact result when possible.
If z is an exact numerical value, Cos remains unevaluated if no exact solution was found.
z is assumed to be in radians.

Examples

Cos(2.0)-0.416147

Calculate(Cos(2), 70)-0.4161468365471423869975682295007621897660007710755448907551499737819649

Cos(2.0+3.0*I)-4.18963-9.10923*I

Particular arguments and their result:

Cos(0)1

Cos(Pi/2)0

Cos(Pi/3)1/2

Cos(Pi/4)1/2^(1/2)

Pure imaginary arguments are converted into Cosh:

Cos(2*I)Cosh(2)

The cosine of the arcus cosine is identity:

Cos(ArcCos(z))z

Coshfunction

Syntax

Cosh(z)

gives the hyperbolic cosine of z.

Details

Cosh gives an exact result when possible.
If z is an exact numerical value, Cosh remains unevaluated if no exact solution was found.

Examples

Cosh(2.0)3.7622

Calculate(Cosh(2), 70)3.762195691083631459562213477773746108293973558230711602777643347588324

Cosh(2.0+3.0*I)-3.72455+0.511823*I

Particular arguments and their result:

Cosh(0)1

Cosh(I*Pi)Cosh(I*Pi)

Pure imaginary arguments are converted into Cos:

Cosh(2*I)Cos(2)

The hyperbolic cosine of the area hyperbolic cosine is identity:

Cosh(ArCosh(z))z

Define=function

Syntax

Define(lhs, rhs)lhs = rhs

evaluates the expression rhs and assign the result as a replacement for the expression lhs whenever it appears.

Details

lhs is typically a symbol or an expression with pattern objects.
For Define the assignment f(g) = rhs is associate with f, while f(g) @= rhs (SubDefine@=) is associate with g.
The expression rhs will evaluated before assignment.
Multiple assignments to the same expression head are ordered by their specialization.
If lhs and rhs are lists with same length, the assignment is done with corresponding elements.
lhs can contain Condition/? to specialize the definition.
Clear can be used to remove all assignment rules from a symbol.

Examples

Assign expressions to single symbols:

x = 123123

x*2246

y = a^2 + b^2a^2 + b^2

2*y2*(a^2 + b^2)

Multiple assignments via list:

{a, b, c} = {123, 3.14, "Test"};Null

a b c123 3.14 "Test"

Assign expressions to an expression with a pattern:

f(z?) = z^2 + zz + z^2

f(9) f(a+b)90 16037.4

Polytypism allows multiple definitions to the same expression head:

f(z?, n?) = z^n + zz + z^n

f(w) f(w, 5)w + w^2 w + w^5

Possible Issues

Define evaluates the expression rhs on the right hand side before assignment, DefineDelayed:= not.

x = 3.143.14

h(x?) = 2*x6.28

k(x?) := 2*xNull

x is already known and will be replaced in Define= but not in DefineDelayed:=.

h(123) k(123)6.28 246

DefineDelayed:=function

Syntax

DefineDelayed(lhs, rhs)lhs := rhs

assigns the unevaluated expression rhs as a replacement for the expression lhs whenever it appears.

Details

lhs is typically a symbol or an expression with pattern objects.
For DefineDelayed the assignment f(g) := rhs is associate with f, while f(g) @:= rhs (SubDefineDelayed@:=) is associate with g.
The expression rhs will assigned unevaluated and is always evaluated when lhs is called.
Multiple assignments to the same expression head are ordered by their specialization.
If lhs and rhs are lists with same length, the assignment is done with corresponding elements.
lhs can contain Condition/? to specialize the definition.
Clear can be used to remove all assignment rules from a symbol.

Examples

Assign expressions to single symbols:

x := 123Null

x*2246

y := a^2 + b^2Null

2*y2*(a^2 + b^2)

Multiple assignments via list:

{a, b, c} := {123, 3.14, "Test"}Null

a b c123 3.14 "Test"

Assign expressions to an expression with a pattern:

f(z?) := z^2 + zNull

f(9) f(a+b)90 16037.4

Polytypism allows multiple definitions to the same expression head:

f(z?, n?) := z^n + zNull

f(w) f(w, 5)w + w^2 w + w^5

Possible Issues

DefineDelayed does not evaluates the expression rhs on the right hand side before assignment, Define= does.

m = 22

k(q?) := m*qNull

h(q?) = m*q2*q

m is already known and will be replaced within Define= during the assignment but for DefineDelayed:= after replacement.

h(a) k(a)246 246

The result of h(a) changes when m is changed, but not the result of k(a)

m = 55

h(123) k(123)246 615

Definitionsfunction

Syntax

Definitions(s)

prints all assignments defined to symbol s.

Details

For built-in functions just the assignment pattern is printed.
The definitions are printed in order of their specialization, started with the most specialized one.

Examples

Definitions(Plus)Plus(???) /* built-in function */Null

Define some assignments to f and print all definitions:

f(1) = 1; f(x?) := f(x-1)+f(x-2); f(2) = 1; f(x? /? x <= 0) = 0;Null

Definitions(f)f(1) = 1f(2) = 1f(Condition(Pattern(x, ?), x <= 0)) = 0f(Pattern(x, ?)) := f(x - 1) + f(x - 2)Null

Depthfunction

Syntax

Depth(exp)

gives the maximum nesting depth of exp.

Details

For a non-expression objects, Depth is 0.

Examples

Depth( { {1,2}, 3, {4,{5,6}} } )3

Depth( 123 )0

Depth works with any expressions, not only lists.

Depth( f(x^2) )2

Depth( a + 2*b^2 + 3*c )3

Rational and complex numbers have a depth of 0.

Depth( 1/3 )0

Depth( 1+2*I )0

Possible Issues

Depth operates on the internal evaluated form, not on the displayed form.

a/ba/b

Depth( a/b )2

InternalForm( a/b )Times(a, Power(b, -1))

DigitBaseoption

Syntax

DigitBase -> int

is an option to define the digit base for number representations.

Details

DigitBase can be used in ToString, ToInteger, and ToReal.
int has to be an integer between 2 and 36.
If DigitBase is not explicitly specified, the base 10 is used.
For bases larger than ten, the capital letters from A until Z are used.
During parsing also the small letters from a until z are valid.

Examples

ToString(12345, DigitBase->2)"11000000111001"

ToString(10^100, DigitBase->36)"2HQBCZU2OW52BALA8LGC3S5Y9MM5TIY0VO9TKE25466GFI6AX8GS22X7KUU8L1TDS"

ToInteger("FF", DigitBase->16)255

ToInteger("5yc1s", DigitBase->36)10000000

ToReal("0.C4", DigitBase->16)0.765625

DirectedInfinityfunction

Syntax

DirectedInfinity()

represents the mathematical infinite quantity with an unknown direction in the complex plane.

DirectedInfinity(z)

represents the mathematical infinite quantity with its direction in the complex plane along z.

Details

During evaluation z will be normalized.
DirectedInfinity(1) is displayed as Infinity.
DirectedInfinity(-1) is displayed as -Infinity.
DirectedInfinity(0) is converted to DirectedInfinity().
DirectedInfinity() is displayed as ComplexInfinity.

Examples

Arithmetical and mathematical functions are able to process DirectedInfinity:

DirectedInfinity(1.0+I) * DirectedInfinity(I)DirectedInfinity(-0.707107+0.707107*I)

DirectedInfinity(I) ^ 4Infinity

Tan(DirectedInfinity(1+I))I

ArcCos(Infinity)DirectedInfinity(I)

ArTanh(DirectedInfinity(I))1/2*I*Pi

Divide/function

Syntax

Divide(exp₁, exp₂)exp₁ / exp₂

divides expression exp₁ by exp₂.

Details

Divide(exp₁, exp₂) is converted to Times(exp₁, Power(exp₂, -1)).
Divide gives a rational number in case of two non-divisible integer numbers.
Divide is suitable for both symbolic and numerical manipulation.

Examples

4 / 22

x^5 / x^2x^3

Possible Issues

A division of two exact numbers keeps exact. Use at least one real number to force a real result.

4 / 6 4.0 / 62/3 0.666667

Econstant

Syntax

E

represents Euler's number e ≅ 2.71828.

Details

E is exact and is not evaluated unless it is combined with an inexact computation.
E can be calculated with arbitrary precision.
For calculations with an arbitrary precision the factorial series is used.

Examples

Calculate E:

Calculate(E)2.71828

Calculate(E, 70)2.718281828459045235360287471352662497757247093699959574966967627724077

Arithmetic with E:

2*E2*E

2.0*E5.43656

Some functions give exact results for terms with E.

Log(E)1

Endiannessoption

Syntax

Endianness -> -1Endianness -> 1

is an option to define the endianness (order of bytes) as little-endian (-1) or big-endian (1).

Details

Endianness can be used in ToString and ToInteger.
If Endianness is not explicitly specified, little-endian (-1) is used.
Endianness usually used in combination with BinaryFormat.

Examples

ToString(1023, BinaryFormat->"Integer32") ToString(1023, BinaryFormat->"Integer32", Endianness->-1) ToString(1023, BinaryFormat->"Integer32", Endianness->1)'ÿ\x03\0\0' 'ÿ\x03\0\0' '\0\0\x03ÿ'

ToString("yä€𝄞", BinaryFormat->"UTF16", Endianness->-1) ToString("yä€𝄞", BinaryFormat->"UTF16", Endianness->1)'y\0ä\0¬ 4Ø\x1EÝ' '\0y\0ä ¬Ø4Ý\x1E'

ToInteger('ÿ\x01\0\0', BinaryFormat->"Integer32") ToInteger('ÿ\x01\0\0', BinaryFormat->"Integer32", Endianness->-1) ToInteger('ÿ\x01\0\0', BinaryFormat->"Integer32", Endianness->1)511 511 -16711680

Equal==function

Syntax

Equal(exp₁, exp₂, … )exp₁ == exp₂ == …

gives True if all expressions exp_i are mathematically equal, and False if they are unequal.

Details

Equal verify the expressions for mathematical equality, unlike Same===.
Inexact numbers are considered as equal if they differ in at most their last five binary digits.

Examples

1 == 1True

3.0 == 3True

0.2 == 1/5True

The integer 1 and the real number 1.0 are mathematically equal, but not identical.

1 == 1.0 1 === 1.0True False

The equality of Overflows is unknown, but they are identical.

Overflow == Overflow Overflow === OverflowOverflow == Overflow True

Equal stays unevaluated if equality is unknown.

a == ba == b

Possible Issues

Inexact numbers are considered as equal if just the last one or two decimal digits are different. This allows an easier handling with floating point numbers.

1.0000000000000000002 == 1.0000000000000000001True

1.00000000000000000020 == 1.00000000000000000010False

EulerMascheroniconstant

Syntax

EulerMascheroni

represents the Euler–Mascheroni constant γ ≅ 0.577216.

Details

EulerMascheroni is exact and is not evaluated unless it is combined with an inexact computation.
EulerMascheroni can be calculated with arbitrary precision.
For calculations with an arbitrary precision an exponential integral method is used.

Examples

Calculate EulerMascheroni:

Calculate(EulerMascheroni)0.577216

Calculate(EulerMascheroni, 70)0.5772156649015328606065120900824024310421593359399235988057672348848677

Arithmetic with EulerMascheroni:

2*EulerMascheroni2*EulerMascheroni

2.0*EulerMascheroni1.15443

Expfunction

Syntax

Exp(z)

gives the exponential of z.

Details

Exp gives an exact result when possible.
Exp(z) is converted to Power(E, z) if no solution was found.
For calculations with an arbitrary precision the formal power series definition is used.

Examples

Exp(-2.5)0.082085

Exp(1000.0)1.970071114017e434

Exp(3.0+2.0*I)-8.35853+18.2637*I

Calculate(Exp(10), 70)22026.46579480671651695790064528424436635351261855678107423542635522520

Particular arguments and their result:

Exp(0)1

Exp(1)E

Exp(-Infinity)0

Expandfunction

Syntax

Expand(exp)

expands out products and positive integer powers in exp.

Details

Expand uses the distributive law and the binomial theorem to expand out exp.

Examples

Expand( 3*(a+b) )3*a + 3*b

Expand( (a+b)^2 )a^2 + 2*a*b + b^2

Expand( (Pi+1)^3 * (E-2) )-2 + E - 6*Pi + 3*E*Pi - 6*Pi^2 + 3*E*Pi^2 - 2*Pi^3 + E*Pi^3

Expand( (a+b)^2 + (a-b)^2 )2*a^2 + 2*b^2

Possible Issues

Expand is not applied to deeper expression levels:

Expand( f((1+a)^2) )f((1 + a)^2)

Expression`f`(…)object

Syntax

head(arg₁, arg₂, … )

is an expression with a head head and any number of arguments arg_i.

head @ arg

is the prefix notation of an expression head(arg).

arg // head

is the postfix notation of an expression head(arg).

Details

head is usually a Symbols, but can be any other expression.
Any kind of object can be assigned to an expression via Define=, DefineDelayed:=, SubDefine@=, or SubDefineDelayed@:=.
Expressions usually contain patterns as arguments in an assignment.

Examples

Head( func(a, b) )func

Head( h(y)(a, b) )h(y)

func @ 123func(123)

123 // funcfunc(123)

Define assignments for specific arguments:

f(1) = 2 f(foo) = 3 f("bar") = 42 3 4

{ f(), f(0), f(1) } { f(foo), f(bar), f("bar"), f("foo") }{f(), f(0), 2} {3, f(bar), 4, f("foo")}

Define a function:

g(x?) := x^2Null

{ g(7) , g(a) , g(2+b) }{49, a^2, (2 + b)^2}

Factorial!function

Syntax

Factorial(n)n!

gives the factorial of n.

Details

For non-integer numbers, the value of n! is given by the gamma function Γ ( 1 + n ).
The evaluation of Γ ( 1 + n ) uses Lanczos approximation and Spouge's approximation.

Examples

Factorial(10)3628800

50!30414093201713378043612608166064768844377641568960512000000000000

(-5)!ComplexInfinity

6.32!1321.18

1000.0!4.02387260077e2567

Calculate(Factorial(22/7), 70)7.199869288735633700776845665344668943490127819531077381591855761162949

(-1/2)!Pi^(1/2)

(2.1+0.4*I)!1.97507+0.802929*I

Falseconstant

Syntax

False

represents the boolean value false.

Details

False is a possible result of comparisons and logical operations.

Examples

1 == 2False

Not(False)True

Fibonaccifunction

Syntax

Fibonacci(n)

gives the Fibonacci number F_n.

Details

For integer numbers, the value of Fibonacci(n) is given by the recursion rule F_n = F_n−1 + F_n−2, with F₀ = 0 and F₁ = 1.
The evaluation of F_n uses fibonacci doubling method.
For non-integer numbers, the value of Fibonacci(n) is given by the general formula F_n =
φⁿ − cos(π n) φ⁻ⁿ
5
, where φ is the golden ratio.

Examples

Calculate Fibonacci numbers based on the recursion rule:

Fibonacci(10)55

Fibonacci(350)6254449428820551641549772190170184190608177514674331726439961915653414425

Fibonacci(-10)-55

Calculate Fibonacci numbers based on the general formula:

Fibonacci(10.0)55.0

Fibonacci(16.32)1151.31

Fibonacci(10000.0)3.36447648764e2089

Calculate(Fibonacci(22/7), 70)2.118038120159998741207512266041453547560232382534595267287508988177487

Fibonacci(2.1+0.4*I)0.932786+0.370984*I

Flatattribute

Syntax

Flat

is an attribute for symbols to indicate that their arguments can be flatted or sub expressions can be created during pattern matching.

Details

Typical functions like Plus+ and Times* have the attribute Flat.
Attributes can be set and get with Attributes.

Examples

Summands in Plus+ are flattened during evaluation:

a + (b + c)a + b + c

By default expressions with the same head are not flattened or nested.

f(1, f(2, 3))f(1, f(2, 3))

Matching( f(1, 2, 3) , f(x?, y?) )False

After setting the attribute Flat, expressions will flattened and pattern matching tries all sub expressions.

Attributes(f) = FlatFlat

f(1, f(2, 3))f(1, 2, 3)

f(1, 2, 3) /: f(x?, y?) :> {x, y}{1, f(2, 3)}

Floorfunction

Syntax

Floor(x)

gives the greatest integer less than or equal to x.

Details

If x is an exact numerical expression, the numerical approximation of x is used to establish the result.
For a complex number x, Floor is applied separately to the real and imaginary part.

Examples

Floor(-2.1)-3

Floor(2.9)2

Floor(7/8)0

Floor(1.2 + 3.8*I)1+3*I

Floor(Log(10))2

Processing of Overflow and Underflow:

Floor(Overflow)Overflow

Floor(Underflow)0

Floor(-Underflow)-1

Function&function

Syntax

Function(body)body&

is an anonymous function with the body body.

Details

body usually contains an expression with Slot# elements representing the arguments of this function.
body is not evaluated as long as the function receives no arguments.
Anonymous functions usually are used in functions like Map/@, Sort or Select.

Examples

f = Function( 2*#+1 )Function(2*#1 + 1)

f(x) f(5)1 + 2*x 11

g = #1^#2 + #2^#1 &Function(#1^#2 + #2^#1)

g(x, y) g(4,3)x^y + y^x 145

Select( {1,2,3,4} , #<3 & ){1, 2}

Possible Issues

Too many arguments are ignored. Too few arguments will result in an error.

f = {#1, #2} &Function({#1, #2})

f(a,b,c){a, b}

f(a,b){a, b}

f(a)Function.Slot: Slot number 2 cannot be filled.{a, #2}

GoldenAngleconstant

Syntax

GoldenAngle

represents the golden angle

2 π

φ²

≅ 2.39996 ≅ 137.5°, with the golden ratio φ.

Details

GoldenAngle is exact and is not evaluated unless it is combined with an inexact computation.
GoldenAngle is defined as
2 π
φ²
= (3 − 5) π.
GoldenAngle can be calculated with arbitrary precision.

Examples

Calculate GoldenAngle:

Calculate(GoldenAngle)2.39996

Calculate(GoldenAngle, 70)2.399963229728653322231555506633613853124999011058115042935112750731307

Calculate(GoldenAngle*180/Pi)137.508

GoldenRatioconstant

Syntax

GoldenRatio

represents the golden ratio φ ≅ 1.61803.

Details

GoldenRatio is exact and is not evaluated unless it is combined with an inexact computation.
GoldenRatio is defined as φ =
1+5
2
.
GoldenRatio can be calculated with arbitrary precision.

Examples

Calculate GoldenRatio:

Calculate(GoldenRatio)1.61803

Calculate(GoldenRatio, 70)1.618033988749894848204586834365638117720309179805762862135448622705260

Greater>function

Syntax

Greater(x₁, x₂, … )x₁ > x₂ > …

gives True if x_i is greater than x_i + 1 for all arguments, and False if x_i is less than or equal to x_i + 1 for at least one pair.

Details

For exact expressions in x_i, Greater compares the approximated value.

Examples

2 > 1True

1/3 > 0 > -0.5True

x > 2 > 2False

The comparison will be simplified if possible.

2 > 1 > x1 > x

The value of an exact expression is approximated for comparison.

Sin(2) > 0True

GreaterEqual>=function

Syntax

GreaterEqual(x₁, x₂, … )x₁ >= x₂ >= …

gives True if x_i is greater than or equal to x_i + 1 for all arguments, and False if x_i is less than x_i + 1 for at least one pair.

Details

For exact expressions in x_i, GreaterEqual compares the approximated value.

Examples

2 >= 1True

3/2 >= 1.5 >= -0.5True

x >= 1 >= 2False

The comparison will be simplified if possible.

2 >= 1 >= x1 >= x

The value of an exact expression is approximated for comparison.

Sin(2) >= 0True

Headfunction

Syntax

Head(exp)

gives the head of the expression exp or any kind of object.

Details

Head can also used for non-expressional objects.
A part specification like exp[0] is a synonym for Head(exp).

Examples

Head( f(a, b) )f

Head( 123 )Integer

Head( a * b )Times

{1, 2, 3}[0]List

Possible Issues

Head operates on the internal evaluated form, not on the displayed form.

a/b Head(a/b)a/b Times

InternalForm(a/b)Times(a, Power(b, -1))

Iconstant

Syntax

I

represents the imaginary unit i ≡ −1.

Details

The imaginary part of complex numbers are represented with I.
A single I is equivalent to a complex number with a real part of 0 and an imaginary part of 1.

Examples

I // HeadComplex

I * I-1

(-4)^(1/2)2*I

Iffunction

Syntax

If(con, t, f)

gives t if con is True and f if con is False.

If(con, t, f, u)

gives u if con is neither True nor False.

If(con, t)

gives Null if con is False.

Details

Usually, con is a comparison or logical expression.
If evaluates only the argument determined by the value of the condition.

Examples

If(True, 123, -10) If(False, 123, -10)123 -10

x = 3; If(x!=0, 1.0/x, "Div 0") x = 0; If(x!=0, 1.0/x, "Div 0")0.333333 "Div 0"

If remains unevaluated if the condition is neither True nor False.

If(a==b, 1, 2)If(a == b, 1, 2)

Force a result for indefinite expressions with the fourth argument:

If(a==b, 1, 2, 3)3

Imfunction

Syntax

Im(z)

gives the imaginary part of the complex number z.

Details

If z is a real number, Im(z) is 0.
For special cases of z, some simplifications are performed.

Examples

Im(1+I)1

Im(1.2 - 3.4*I)-3.4

Im(-123)0

Im(Log(-6))Pi

Im(I*Infinity)Infinity

Simplifications are performed if possible.

Im(-2*x)-2*Im(x)

Im(3+Pi+z)Im(z)

Im(Abs(z))0

Im(Exp(2+3*I))E^2*Sin(3)

Indeterminateconstant

Syntax

Indeterminate

represents a mathematical quantity whose magnitude is undetermined.

Details

Calculations with at least one Indeterminate leads to an Indeterminate result.

Examples

0 / 0Indeterminate

0 ^ 0Indeterminate

Infinity - InfinityIndeterminate

Infinityconstant

Syntax

Infinity

represents the mathematical positive infinite quantity.

Details

Infinity is the short form of DirectedInfinity(1).
Infinity is handled in calculations as an exact number.
Infinity is even larger than Overflow.
Infinity keeps exact computation possible, unlike Overflow.

Examples

Infinity > OverflowTrue

Arithmetical and mathematical functions are able to process Infinity:

1 / Infinity0

Log(0)-Infinity

E^(-Infinity)0

Tanh(Infinity)1

Exact evaluation is not possible with Overflow:

Tanh(Overflow)1.0

Log(0.0)Indeterminate

Integer`n`object

Syntax

n

with an arbitrary number of digits represents an integer number.

Integer

is the head of an integer number.

Details

Integer numbers can be of any size and are not limited to the word size of the processor.
Integer numbers are always exact values.

Examples

Head(123)Integer

12 + 3446

Working with large numbers:

32845723658234756 * 34659487645645654611384159533448787206618577180912776

11384159533448787206618577180912776 / 34659487645645654632845723658234756

3^200265613988875874769338781322035779626829233452653394495974574961739092490901302182994384699044001

InternalFormfunction

Syntax

InternalForm(exp)

gives the internal representation of exp without operator signs.

Details

InternalForm converts operators to the expression format with head and arguments.
InternalForm shows all structures usually hidden during output.

Examples

InternalForm(4+2*I)Complex(4, 2)

InternalForm(1/5)Rational(1, 5)

InternalForm(1+2*x)Plus(1, Times(2, x))

InternalForm(x?Integer)Pattern(x, Any(Integer))

Possible Issues

InternalForm visualizes the internal used expression structure, not the input structure.

InternalForm(a-b)Plus(a, Times(-1, b))

InternalForm(1/x)Power(x, -1)

InternalForm(Exp(z))Power(E, z)

Intersectionfunction

Syntax

Intersection(list₁, list₂, … )

gives a sorted list of all distinct elements that appear in all of list_i.

Details

If the lists list_i are considered as sets, Intersection gives their intersection list₁ ∩ list₂.
Intersection works with any kind of expressions as long as they have the same head.

Examples

Intersection( {4,3,3,1} , {1,4,4,5} ){1, 4}

Intersection( {x, y} , {u, v} ){}

Intersection( {1,2,3} , {1,10,100} , {1,2,4,8} ){1}

Intersection works with any expressions, not only lists, as long as they have the same head.

Intersection( a + b + d , a + c + d )a + d

Intersection( f(1, 4, 2), f(2, 3, 4) )f(2, 4)

Possible Issues

Heads have to be the same when Intersection is applied on expressions.

Intersection( f(1, 2), g(2, 3) )Intersection.Heads: Heads f and g are not the same.Intersection(f(1, 2), g(2, 3))

Iteratefunction

Syntax

Iterate(exp, n)

gives a list of n evaluated copies of exp.

Iterate(exp, {i, i_max} )

generates a list by iterating i from 1 to i_max.

Iterate(exp, {i, i_min, i_max} )

generates a list by iterating i from i_min to i_max.

Iterate(exp, {x, x_min, x_max, x_step} )

generates a list by iterating x from x_min to x_max using steps x_step.

Iterate(exp, {e, {e₁, e₂, …, e_n } } )

generates a list by iterating e though the values e₁, e₂, …, e_n.

Iterate(exp, spec₁, spec₂, … )

is evaluated as Iterate(Iterate(exp, spec₁), spec₂, … ).

Details and Options

The expression exp is just evaluated during the iteration, not before.
The iterator symbol (i, x or e) is used in a local scope and protected from outer scope.

Examples

Iterations without iterator:

Iterate(0, 8){0, 0, 0, 0, 0, 0, 0, 0}

Iterate("Text", 4){"Text", "Text", "Text", "Text"}

Iteration with an iterator:

Iterate(i, {i, 10} ){1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Iterate(i^2, {i, -3, 3} ){9, 4, 1, 0, 1, 4, 9}

Iterate(x, {x, 0.5, 0.9, 0.1} ){0.5, 0.6, 0.7, 0.8, 0.9}

Iteration with an iterator and specific elements:

Iterate(w*2, {w, {1,0.7,t,1/3} } ){2, 1.4, 2*t, 2/3}

Nested iteration with two iterators m and n:

Iterate(m+n*10, {m, 1, 4}, {n, 1, 4}){{11, 12, 13, 14}, {21, 22, 23, 24}, {31, 32, 33, 34}, {41, 42, 43, 44}}

The outer iterator n can be used in the inner iteration range.

Iterate(m+n*10, {m, 1, n}, {n, 1, 4}){{11}, {21, 22}, {31, 32, 33}, {41, 42, 43, 44}}

Possible Issues

The expression to iterate is just evaluated during the iteration, not before. In the following, this leads to different random numbers instead of ten identically numbers.

Iterate(Random(9), 10){8, 5, 3, 2, 7, 5, 3, 2, 6, 9}

Join~function

Syntax

Join(exp₁, exp₂, … )exp₁ ~ exp₁ ~ …

joins all expressions exp_i that have the same head, e.g. List{…}.

Join(str₁, str₂, … )str₁ ~ str₁ ~ …

joins all strings str_i.

Examples

Join( {1,2} , {3,4,5} ){1, 2, 3, 4, 5}

Join( "Hello ", "World!" )"Hello World!"

Join works with any expressions, not only lists, as long as they have the same head.

Join( a + b , c + d )a + b + c + d

Join( f(1, 2), f(x) )f(1, 2, x)

Lengthfunction

Syntax

Length(exp)

gives the number of elements in expression exp.

Length(str)

gives the number of characters in string str.

Details

For neither expression nor string, Length is 0.

Examples

Length( {1,2,3,4,5} )5

Length( "Hello World!" )12

Length( '\0\x80ÿ\n' )4

Length works with any expressions, not only lists or strings.

Length( a + 2*b + c )3

Length( f(a, b) )2

Rational and complex numbers have a length of 0.

Length( 1/3 )0

Length( 1+2*I )0

Possible Issues

Length operates on the internal evaluated form, not on the displayed form.

Minus(x)-x

Length( -x )2

InternalForm( -x )Times(-1, x)

Less<function

Syntax

Less(x₁, x₂, … )x₁ < x₂ < …

gives True if x_i is less than x_i + 1 for all arguments, and False if x_i is greater than or equal to x_i + 1 for at least one pair.

Details

For exact expressions in x_i, Less compares the approximated value.

Examples

1 < 2True

-0.5 < 0 < 1/3True

x < 2 < 2False

The comparison will be simplified if possible.

1 < 2 < x2 < x

The value of an exact expression is approximated for comparison.

Sin(4) < 0True

LessEqual<=function

Syntax

LessEqual(x₁, x₂, … )x₁ <= x₂ <= …

gives True if x_i is less than or equal to x_i + 1 for all arguments, and False if x_i is greater than x_i + 1 for at least one pair.

Details

For exact expressions in x_i, LessEqual compares the approximated value.

Examples

1 <= 2True

-0.5 <= 1.5 <= 3/2True

x <= 2 <= 1False

The comparison will be simplified if possible.

1 <= 2 <= x2 <= x

The value of an exact expression is approximated for comparison.

Sin(4) <= 0True

List{…}function

Syntax

List(e₁, e₂, … ){ e₁, e₂, … }

represents a list of elements e_i.

Details

Lists are not exceptional constructs, but just an expression with the head List.
Most built-in functions have the attribute Listable and thread into lists.

Examples

List( 1, 2, 3 ){1, 2, 3}

{{a1,a2}, {b1,b2}}{{a1, a2}, {b1, b2}}

Most built-in functions thread into lists:

Sqrt({1, 4, 9}){1, 2, 3}

Exp({0.0, 1.0, 10.0}){1.0, 2.71828, 22026.5}

Listableattribute

Syntax

Listable

is an attribute for symbols to indicate that the symbol will threaded into lists occurring in arguments.

Details

Typical functions like Plus+ and Times* have the attribute Listable.
Attributes can be set and get with Attributes.

Examples

{a, b} + {c, d}{a + c, b + d}

Sin({x, 2, 0.5}){Sin(x), Sin(2), 0.479426}

By default the head of an expression is not threaded into the list.

f({1, 2, 3})f({1, 2, 3})

After setting the attribute Listable, f will threaded into the list.

Attributes(f) = ListableListable

f({1, 2, 3}){f(1), f(2), f(3)}

f({1, 2, 3}, {a, b, c}){f(1, a), f(2, b), f(3, c)}

Lockedattribute

Syntax

Locked

is an attribute for symbols to indicate that they are locked against changes in their attributes.

Details

Some fundamental built-in symbols and functions are locked.
Attributes can be set and get with Attributes.

Examples

Attributes(Plus) = FlatAttributes.Locked: Plus is locked!Flat

After setting the attribute Locked, no more changes in attributes can be made.

Attributes(f) = {Flat, Locked}{Flat, Locked}

Attributes(f) = {Orderless}Attributes.Locked: f is locked!{Orderless}

Attributes(f){Flat, Locked}

Logfunction

Syntax

Log(z)

gives the natural logarithm of z.

Log(b, z)

gives the logarithm of z to base b.

Details

Log gives an exact result when possible.
If z is an exact numerical value, Log remains unevaluated if no exact solution was found.
Log(b, z) is converted to Log(z)/Log(b) when no exact solution was found.
For calculations with an arbitrary precision a series based on the area hyperbolic tangent function is used.

Examples

Log(1000.0)6.90776

Log(-3.14)1.14422+3.14159*I

Log(3.0+2.0*I)1.28247+0.588003*I

Calculate(Log(100), 70)4.605170185988091368035982909368728415202202977257545952066655801935145

Particular arguments and their result:

Log(E)1

Log(0)-Infinity

Log(-1)I*Pi

Logarithm with specified base:

Log(10, 1000)3

Log(4.5, 4.5^100000)1.0e5

Log(2/3, 16/81)4

Log(1/4, 8)-3/2

Possible Issues

If an exact solution does not exist, just a conversion is performed.

Log(2, 100)Log(100)/Log(2)

MachinePrecisionconstant

Syntax

MachinePrecision

indicates the usage of machine precision in float pointing numbers like reals.

Details

MachinePrecision is exact and is not evaluated unless it is combined with an inexact computation.
For 64-bit IEEE float pointing numbers MachinePrecision is 53/Log(2,10).
Precision gives MachinePrecision if the number is stored as a machine number.

Examples

Calculate MachinePrecision on current system:

Calculate(MachinePrecision)15.9546

Small real numbers with low precision stored with machine precision:

Precision(3.1415)MachinePrecision

Precision(789.456e123)MachinePrecision

Large real numbers stored with an arbitrary precision with at least machine precision:

Precision(123.4e5678)15.9546

Map/@function

Syntax

Map(f, exp)f /@ exp

applies f to each element in expression exp.

Details

After f is applied, the whole expression is evaluated.

Examples

Map(f, g(1, a, x))g(f(1), f(a), f(x))

Map(Cos, Pi+b+c)-1 + Cos(b) + Cos(c)

Map will process anonymous function as well:

#^2 & /@ {4, 9, a, 0.4}{16, 81, a^2, 0.16}

Matchingfunction

Syntax

Matching(exp, pat)

performs a pattern matching of pattern pat on expression exp.

Details

Matching gives True if pat matches exp, and False otherwise.
pat usually consists of patterns like Any?, AnySequence??, or Alternatives|, or Condition/?.

Examples

Matching(123, ?Integer) Matching(123.0, ?Integer)True False

Matching({a, b, c}, {??Symbol}) Matching({a, 2, b}, {??Symbol})True False

Matching({10, 11}, {x?, x?}) Matching({10, 10}, {x?, x?})False True

Matching({2, 1}, {x?, y?} /? x>y ) Matching({1, 2}, {x?, y?} /? x>y )True False

Maxfunction

Syntax

Max(x₁, x₂, … )Max( {x₁, x₂, … }, {x_n + 1, x_n + 2, … }, … )

gives the numerically largest value of x_i.

Details

Max gives only in case of exclusively real numerical values x_i the largest value.
For exact expressions in x_i, Max compares the approximated value.
Max() gives -Infinity.
Max(exp) gives exp.

Examples

Max(3, -2, 1.0)3

Max(E, Pi)Pi

Max({4,2,-4}, {9, 0, 4})9

Possible Issues

Max remains unevaluated, but simplified, when non-comparable values are included.

Max(3, "test", -5, 2+I, 4)Max("test", 2+I, 4)

Minfunction

Syntax

Min(x₁, x₂, … )Min( {x₁, x₂, … }, {x_n + 1, x_n + 2, … }, … )

gives the numerically smallest value of x_i.

Details

Min gives only in case of exclusively real numerical values x_i the smallest value.
For exact expressions in x_i, Min compares the approximated value.
Min() gives Infinity.
Min(exp) gives exp.

Examples

Min(3, -2, 1.0)-2

Min(E, Pi)E

Min({4,2,-4}, {9, 0, 4})-4

Possible Issues

Min remains unevaluated, but simplified, when non-comparable values are included.

Min(3, "test", -5, 2+I, 4)Min("test", 2+I, -5)

Minus-function

Syntax

Minus(exp)-exp

gives the arithmetic negation of exp.

Details

Minus(exp) is converted to Times(-1, exp).

Examples

Minus(123)-123

Minus(a+b+c)-a - b - c

Minus(3+2*I)-3-2*I

Double negation of an expression is the expression itself.

Minus(Minus(exp))exp

Modfunction

Syntax

Mod(m, n)

gives the remainder on devision of m by n.

Details

The sign of n is used as the sign of the remainder.
Mod is suitable for both symbolic and numerical manipulation.
Mod works also with rational and real numbers.
In cases of general expressions in m and n simplifications are tried.

Examples

Mod(7, 3)1

Mod(4.0, 1.2)0.4

Mod(5/9, 1/2)1/18

Mod also performs on expressions.

Mod(Pi, 2)-2 + Pi

Mod(8*Pi, 3*Pi)2*Pi

Mod(10, 5^(1/2))10 - 4*5^(1/2)

Mod(14*a^2, 3*a^2)2*a^2

Possible Issues

The result of Mod(m, n) is always in the range 0 to n, and negative when n is negative.
This behavior differs from other languages, where the result becomes negative when m is negative, instead of n.

Mod(7, 3)1

Mod(-7, 3)2

Mod(7, -3)-2

Mod(-7, -3)-1

Not!function

Syntax

Not(bool)!bool

gives the logical NOT of bool.

Not(int)!int

gives the binary NOT of the integer int.

Not(str)!str

gives the binary NOT of the string str.

Details

Not gives True if bool is False, and False if it is True.
Integers are handled in their two's complement form.
Strings are converted into binary form and Not is performed bitwise.
Simplifications are performed if possible to evaluate Not on expressions.

Examples

! FalseTrue

! 15-16

! 'BINARY''½¶±¾¦'

Negation of comparisons are simplified if possible.

Not( x < 3 )x >= 3

Not( x == 3 )x != 3

Double negation of an expression is the expression itself.

Not( Not( exp ) )exp

Nullconstant

Syntax

Null

represents the absence of any kind of object.

Details

Null is usually returned from Compound;, Print or delayed assignments like DefineDelayed:= or RuleDelayed:>.
A single Null will be hidden from the output.

Examples

NullNull

x := 1Null

z = 3;Null

{1, Print(2), z}2{1, 2, 3}

Optional:function

Syntax

Optional(pat, exp )pat : exp

is a pattern object that is replaced by exp if pat is not matched.

Details

Optional can be used to define a default value in function's arguments.
Optional can be used at any position, not only at the end of arguments.

Examples

Matching( {1, 2}, {x?, y?:0} ) Matching( {1}, {x?, y?:0} )True True

f(x?, y?:2) := x^yNull

f(a, b) f(a)a^b a^2

g(n?Integer:0, str?String) := {n, str}Null

g("Text") g(10, "Text"){0, "Text"} {10, "Text"}

Optionsfunction

Syntax

Options(sym₁ -> val₁, sym₂ -> val₂, … )Options(sym₁ :> val₁, sym₂ :> val₂, … )

is a pattern object that matches a collection of rules for symbols sym_n and their default value val_n.

Details

Options is typically used in definition of functions for additional arguments attributed by their names.
Arguments and default values in Options can either by defined with Rule-> or RuleDelayed:>.

Examples

f(Options(x->1, y->2)) := {x, y}Null

f() f(x->100) f(y->100) f(y->100, x->99){1, 2} {100, 2} {1, 100} {99, 100}

Arguments defined with RuleDelayed are evaluated each time again they will be used:

f(Options(x->0)) := {x, x, x, x, x}Null

f() f(x->Random(10)) f(x:>Random(10)){0, 0, 0, 0, 0} {10, 10, 10, 10, 10} {7, 2, 8, 9, 9}

Or||function

Syntax

Or(bool₁, bool₂, … )bool₁ || bool₂ || …

gives the logical OR of bool_i.

Or(int₁, int₂, … )int₁ || int₂ || …

gives the binary OR of the integers int_i.

Or(str₁, str₂, … )str₁ || str₂ || …

gives the binary OR of the strings str_i.

Details

The arguments of Or are evaluated step by step.
Or gives True immediately if any argument is True, and False if all arguments are False.
Or() is defined as False.
Or(exp) is simplified to exp.
Integers are handled in their two's complement form.
Strings are converted into binary form and Or is performed bitwise.

Examples

True || FalseTrue

12 || 715

'BINARY' || 'abc''ckoARY'

Or stops to evaluate its arguments if True occurs. In the following case the second Print is not evaluated.

(Print(1);False) || True || (Print(2);False)1True

Expressions which are evaluated into False will be erased.

1==2 || a==5 || b==10 || Falsea == 5 || b == 10

Orderfunction

Syntax

Order(exp₁, exp₂)

gives 1 if exp₁ and exp₂ are in order, gives -1 if exp₁ and exp₂ are out of order, and gives 0 if both expression are identical.

Details

Order is used as default comparison function in Sort.

Order gives the typical order of exp₁ and exp₂ in orderless expressions:

Integern, Rationala/b and Realx numbers are ordered by their numerical value.

Complexx+y*I numbers are ordered by their real part and then by their imaginary part.

String"…",'…' are ordered using the Unicode collation algorithm.

Numerical values are ordered before String"…",'…', Symbols and Expressionf(…).

Examples

Order(123, var)1

Order(1, 1+I)1

Order("b", "a")-1

Order(x^2, x^2)0

Possible Issues

Constants are ordered by their name and not by their numerical value.

Order(Pi, 4)-1

Orderlessattribute

Syntax

Orderless

is an attribute for symbols to indicate that their arguments can be sorted and rearranged in pattern matching.

Details

Typical functions like Plus+ and Times* have the attribute Orderless.
Attributes can be set and get with Attributes.

Examples

Summands in Plus+ are sorted during evaluation:

a + c + ba + b + c

By default expressions keep their order of arguments.

f(1, b, 2, a)f(1, b, 2, a)

Matching( f(x, 2) , f(?Integer, x) )False

After setting the attribute Orderless, expressions will sorted and pattern matching tries all combinations.

Attributes(f) = OrderlessOrderless

f(1, b, 2, a)f(1, 2, a, b)

Matching( f(x, 2) , f(?Integer, x) )True

Outputfunction

Syntax

Output(exp₁, exp₂, … )


exp₁
exp₂
 …

evaluates all expressions exp_i in turn.

Details

Output generates a newline (carriage return and line feed) only on top level.
In in deeper levels Output remains to avoid syntax errors.

Examples

Output(1+2, 3*4, 5^6)3 12 15625

1+2 3*4 5^63 12 15625

f(Output(1,2,3))f(Output(1, 2, 3))

Overflowconstant

Syntax

Overflow

represents an overflow in float-pointing or integer arithmetic.

Details

The head of Overflow is Real.
Overflow is always larger than the highest possible real value, but always smaller than Infinity.

Examples

Exp(10.0^20.0)Overflow

Arithmetical and mathematical functions are able to process Overflow:

3.14 + OverflowOverflow

Overflow * (-2)-Overflow

3.14 / OverflowUnderflow

ArcTan(Overflow)1.5708

Part[…]function

Syntax

Part(exp, level₁, level₂, … )exp[level₁, level₂, … ]

gives a part of the expression exp specified by level_i for the different nesting levels.

Part(str, part)str[part]

gives a part of the string str specified by part.

Details

The part and level specifications can have the following forms:

`…[n]`	gives the `n`^th element of an expression or the `n`^th character of a string.
`…[-n]`	counts from the end of the expression or the string.
`…[0]`	gives the head of an expression or the string.
`…[{n₁, n₂, … }]`	gives the expression with elements specified by `n_i` or the string with characters specified by `n_i`.
`…[m..n]`	gives the expression with a span of elements or the string with characters from `m` until `n`.
`…[m..n..s]`	gives a span of elements or characters from `m` until `n` in steps of `s`, where `s` can also be negative.
`…[All]`	gives the expression with all elements in this level or the string with all characters.

Examples

Pick an element or a character:

Part( {a,b,c,d,e} , 3 )c

"Hello World!"[-1]"!"

Pick multiple elements or characters:

{a,b,c,d,e}[{-1,3,3}]{e, c, c}

"Hello World!"[{1,8,3,-2}]"Hold"

Pick a span of elements or characters:

{a,b,c,d,e}[2..-2]{b, c, d}

{a,b,c,d,e}[-1..1..-1]{e, d, c, b, a}

Part( "Hello World!" , 1..7..2 )"HloW"

Pick all 2^nd elements from the second level:

{{a1,a2}, {b1,b2}, {c1,c2}}[All, 2]{a2, b2, c2}

Part works on any expression.

Part( a+b*x+x^2 , 2, 1)b

f(1, 2, x, 4, y)[3..5]f(x, 4, y)

Possible Issues

Rationala/b numbers or Complexx+y*I numbers are atomic objects. Part cannot extract the numerator/denominator or real/imaginary part. In such cases you have to use Numerator, Denominator, Re, or Im.

Part( 3/4 , 1 )Part.Depth: Part specification (3/4)[1] is longer than depth of object.(3/4)[1]

Part( 2+3*I , 1 ) Re( 2+3*I )Part.Depth: Part specification (2+3*I)[1] is longer than depth of object.(2+3*I)[1] 2

Expressions like Plus+ and Times* are ordered and flattened before Part is executed.

Part( a+c+b , 2) a+c+b // InternalFormb Plus(a, b, c)

Part( (a*b)*(c*d) , 2) (a*b)*(c*d) // InternalFormb Times(a, b, c, d)

Partitionfunction

Syntax

Partition(str, n)

partitions the string str into a list of sub-strings of length n.

Partition(exp, n)

partitions the expression exp into sub-expressions of length n.

Details

If the length of exp is no multiple of n, some elements will be disregarded.

Examples

Partition( {1, 2, 3, 4, 5, 6} , 3 ){{1, 2, 3}, {4, 5, 6}}

Partition( {1, 2, 3, 4, 5, 6} , 4 ){{1, 2, 3, 4}}

Partition( "Hello World!" , 3 ){"Hel", "lo ", "Wor", "ld!"}

Partition( "Hello World!" , 5 ){"Hello", " Worl"}

Partition( f(1,2,3,4) , 2 )f(f(1, 2), f(3, 4))

Patternfunction

Syntax

Pattern(sym, pat)

represents the pattern pat and assigns a matching object to the symbol sym.

sym?
sym??
sym???

is the short form for Pattern(sym, ?), Pattern(sym, ??) or Pattern(sym, ???).

sym?head
sym??head
sym???head

is the short form for Pattern(sym, ?head), Pattern(sym, ??head) or Pattern(sym, ???head).

Details

Pattern is a common argument for function definitions with DefineDelayed:= or SubDefineDelayed@:=.

Examples

f(x?, y?) := x ^ y f(a, b)a^b

g(x??) := Times(x)Null

g(3) g(4, 5) g(a, 6, x^2)3 20 6*a*x^2

g(Pattern(x, ?Integer|Infinity)) := x^2Null

{ g(1), g(-5), g(Infinity), g(3.14) }{1, 25, Infinity, 3.14}

Piconstant

Syntax

Pi

represents the constant π ≅ 3.14159.

Details

Pi is exact and is not evaluated unless it is combined with an inexact computation.
Pi can be calculated with arbitrary precision.
For calculations with an arbitrary precision the Bailey–Borwein–Plouffe formula is used.

Examples

Calculate Pi:

Calculate(Pi)3.14159

Calculate(Pi, 70)3.141592653589793238462643383279502884197169399375105820974944592307816

Arithmetic with Pi:

2*Pi2*Pi

2.0*Pi6.28319

Some functions give exact results for terms with Pi.

Cos(Pi)-1

Expressions with Pi are returned from some functions.

Log(-1)I*Pi

ArcTan(Infinity)1/2*Pi

Plus+function

Syntax

Plus(exp₁, exp₂, … )exp₁ + exp₂ + …

gives the sum of all expressions exp_i.

Details

Plus is suitable for both symbolic and numerical manipulation.
Plus has the attributes Orderless, Flat and Listable.
Plus() is defined as 0.
Plus(exp) is simplified to exp.

Examples

1 + 2 + 36

2*x + 3*x5*x

2 + 1/4 2 + 0.259/4 2.25

Plus are flattened and the arguments are sorted.

(a + c) + (b + 4)4 + a + b + c

Plus threads over List{…}:

{1, 2, 3} + 10{11, 12, 13}

{1, 2, x} + {5, 10, y}{6, 12, x + y}

Power^function

Syntax

Power(exp₁, exp₂)exp₁ ^ exp₂

gives expression exp₁ to the power of exp₂.

Details

Power is suitable for both symbolic and numerical manipulation.
Power has the attributes Listable.
In case of exact arguments, Power tries to evaluate an exact number.
For complex numbers and calculations with an arbitrary precision the identity x^y = Exp(y*Log(x)) is used.

Examples

2 ^ 1001267650600228229401496703205376

5 ^ (-2)1/25

27 ^ (1/3) 10 ^ (1/3)3 10^(1/3)

10 ^ (1/3) // Calculate 10.0 ^ (1/3)2.15443 2.15443

2.5 ^ 10008.709809816217e397

Power threads over List{…}:

{2, 3, 4} ^ 2{4, 9, 16}

{2, 10} ^ {4, 3}{16, 1000}

Possible Issues

Some evaluations give Indeterminate or ComplexInfinity:

0^0Indeterminate

0^(-1)ComplexInfinity

If the result of Power is to large or near zero, it gives Overflow or Underflow.

10.0 ^ (10.0^20.0)Overflow

0.5 ^ (10.0^20.0)Underflow

Precisionfunction

Syntax

Precision( z )

gives the number of precise decimal digits of the number z.

Details

In case of integers and rational numbers, Precision gives Infinity.
In case of real numbers, Precision gives MachinePrecision if the number is stored as a 64-bit IEEE float pointing number.
In case of complex numbers, Precision gives lowest precision of real part and imaginary part.
In case of an expression, Precision gives lowest precision of all elements.

Examples

Determine the number's precision:

Precision(123)Infinity

Precision(3/7)Infinity

Precision(3.14)MachinePrecision

Precision(Overflow)0.0

Precision(123456.78901234567890)20.0915

Precision(4.0 + 3*I)MachinePrecision

Printfunction

Syntax

Print(exp₁, exp₂, …, exp_last )

evaluates and prints all expressions exp_i in turn, and gives the last one exp_last as result.

Details

If exp_n is a string, only its content is shown and control characters are taken into account.
If exp_i is Null no print is performed. Using Null in exp_last the result is hidden from output.
Print can be used to trace calculations in a more complex evaluation.

Examples

Print(1, 2, 3)1233

Print("String are shown\r\nwith line breaks\tand tabs.")String are shown with line breaks and tabs."String are shown\r\nwith line breaks\tand tabs."

Print(Hello, World, Null)HelloWorldNull

Trace a large calculation:

Print(Log(10, Print(2^10)-24 // Print)) * 2110241000363

Apply(Plus, Iterate(Print(Random(100)), 5))9780896834368

Protectedattribute

Syntax

Protected

is an attribute for symbols to indicate that they are protected against changes by assignments or Clear.

Details

All built-in symbols and functions are protected.
Attributes can be set and get with Attributes.

Examples

Pi = 3Define.Protected: Pi is protected!3

After setting the attribute Protected, no more definitions can be made.

x = 123123

Attributes(x) = ProtectedProtected

x = 0Define.Protected: x is protected!0

x123

Randomfunction

Syntax

Random(z)

gives a pseudorandom number between 0 and z.

Random(list)

gives a pseudorandom element from the list list.

Details and Options

Depending on the head of z (Integer, Rational, Real or Complex), Random gives either only integer numbers, rational numbers, real numbers, or complex numbers, respectively.
For a complex number z, Random is performed for the real part and imaginary part.
For a rational number z = a/b, the resulting numbers are in steps of 1/b.

Examples

Random(7)6

Random(2/3)2/3

Random(2.0)1.5129

Random(1.0+2.0*I)0.752581+1.27174*I

Random( {a, b, c} )b

Generate a list of random numbers:

Iterate( Random(9), 10 ){3, 0, 4, 3, 0, 2, 5, 7, 8, 1}

Rational`a`/`b`object

Syntax

a/b

is a rational number, represented as a fraction of two integer numbers with numerator a and denominator b.

Rational

is the head of a rational number.

Details

The numerator a and denoninator b can be numbers of any size and are not limited to the word size of the processor.
Rational numbers are reduced as much as possible.
Rational numbers are always exact values.
a/b uses the same operator level as Divide/.

Examples

Head(1/2)Rational

4/121/3

5 + 1/316/3

1/123456 + 1/678901802357/83814401856

Working with large numers:

(2/3)^1001267650600228229401496703205376/515377520732011331036461129765621272702107522001

Refunction

Syntax

Re(z)

gives the real part of the complex number z.

Details

If z is a real number, Re(z) is just z.
For special cases of z, some simplifications are performed.

Examples

Re(1+I)1

Re(1.2-3.4*I)1.2

Re(-123)-123

Re(Log(-6*I))Log(6)

Re(ArcCos(2))0

Re(Infinity)Infinity

Simplifications are performed if possible.

Re(-2*x)-2*Re(x)

Re(3+Pi+z)3 + Pi + Re(z)

Re(Abs(z))Abs(z)

Re(Exp(2+3*I))E^2*Cos(3)

Real`x`object

Syntax

x

with an arbitrary number of digits and a decimal point represents a real number.

Real

is the head of a real number.

Details

Real numbers can be of any precision and magnitude.
Real numbers are stored with machine precision (64-bit IEEE float pointing number) if possible.
Real numbers with machine precision displayed only with 6 precision digits, but full IEEE precision is tracked.
Real numbers are inexact values and the precision can be received with Precision.
Calculations with at least one inexact value leads to an inexact result.
Overflow and Underflow are two special real numbers representing a float pointing overflow or underflow.

Examples

Head(1.0)Real

4.0 * 0.72.8

1 + 2.03.0

1/3 + 1.01.33333

1.0000000000000000000000000000000000000000123 + 1011.0000000000000000000000000000000000000000123

The magnitude of real numbers can be larger then typical 64-bit IEEE float pointing numbers can handle.

123.456 ^ 1000.03.25238259113e2091

0.012 ^ 1000.01.517910089172e-1921

Small real numbers with low precision are stored always with machine precision:

Precision(123.456)MachinePrecision

Precision(789.456e123)MachinePrecision

The precision of larger real numbers or numbers with higher precision is tracked:

x = 123.456 ^ 1000.0 y = 123.000000000000000000004567893.25238259113e2091 123.00000000000000000000456789

{ Precision(x) , Precision(y) }{12.4798, 29.0899}

x ^ y1.0018442638e257256

Precision(x^y)10.3898

Overflow and Underflow are real numbers.

123.456 ^ (10^100)Overflow

Head(Overflow)Real

123.456 ^ (-10^100)Underflow

Head(Underflow)Real

Possible Issues

Combinations of Overflow and Underflow can result in Indeterminate or complex numbers.

Overflow * UnderflowIndeterminate

Underflow - UnderflowComplexUnderflow

Replace/:function

Syntax

Replace(exp, rule)exp /: rule

applies the rule rule to the expression exp and its sub-expressions as a substitution.

Replace(exp, {r₁, r₂, … })exp /: {r₁, r₂, … }

applies the rules r_i to the expression exp and its sub-expressions as a substitution.

Replace(str, a->b )str /: a->b

replaces all sub-strings a in the string str with b.

Details

Replace applies the rules starting from the lowest depth to the deepest level.
Rules can be defined as Rule-> as well as RuleDelayed:>.
Once a rule was applied to a sub-expression, no more replacements will be applied to this sub-expression.

Examples

Replace a symbol with a value:

x^2 + x /: x->420

{x+y, x*y, x^y} /: {x->2, y->3}{5, 6, 8}

Swapping elements:

x^2 /: {2->x, x->2}2^x

Replace uses the Flat and Orderless attributes to find a match:

a+b+c+d /: a+d -> xb + c + x

Replace a special type of elements:

{a, b, 1, 2, 3.0, 0.4, "Hello", "World"} /: ?Real -> 0{a, b, 1, 2, 0, 0, "Hello", "World"}

Replace a sub-string:

"Hello World!" /: "World" -> "User""Hello User!"

Possible Issues

Once a rule is matching a sub-expression, no more rules will tried for this sub-expression.

{x, y, z} /: {x->y, y->z, z->0}{y, z, 0}

RuleDelayed:> is evaluated each time of replacement, while Rule-> is evaluated before all replacements:

{x, x, x, x, x} /: x -> Random(10){0, 0, 0, 0, 0}

{x, x, x, x, x} /: x :> Random(10){7, 9, 1, 1, 5}

Patterns that are too general replace the entire expression

f(2, 3, 4) /: x? -> x^2f(2, 3, 4)^2

f(2, 3, 4) /: x?Integer -> x^2f(4, 9, 16)

Rule->function

Syntax

Rule(lhs, rhs)lhs -> rhs

represents a rule that transforms lhs by rhs.

Details

rhs is evaluated before the rule is applied.
lhs is typically a symbol or an expression with pattern objects.
Rules are typically used in Replace/: or Options.

Examples

Replace(x+y, { x->2, y->4 } )6

Replace(a+b+c+d, b+c -> 4 )4 + a + d

Replace({1, 2.0, 3, 4.0, 5}, ?Integer -> Null ){Null, 2.0, Null, 4.0, Null}

Replace({1, 2.0, 3, 4.0, 5}, x?Integer -> x^2 ){1, 2.0, 9, 4.0, 25}

Possible Issues

x = 44

Rule is evaluated immediately:

x?Integer -> x^2Pattern(x, ?Integer) -> 16

Replace({2, 3, 4}, x?Integer -> x^2 ){16, 16, 16}

RuleDelayed holds the right hand side and is evaluated after the appliement:

x?Integer :> x^2Pattern(x, ?Integer) :> x^2

Replace({2, 3, 4}, x?Integer :> x^2 ){4, 9, 16}

RuleDelayed:>function

Syntax

RuleDelayed(lhs, rhs)lhs :> rhs

represents a rule that transforms lhs by rhs and then evaluate it.

Details

rhs remains unevaluated until the rule is applied.
lhs is typically a symbol or an expression with pattern objects.
Rules are typically used in Replace/: or Options.

Examples

rhs of RuleDelayed will evaluated during each replacement.

Replace({1, x, 2, x, 3, x}, x :> Random(1000) ){1, 337, 2, 986, 3, 384}

RuleDelayed is typically used in combination with patterns:

Replace({2, 3, 4}, x?Integer :> x^3 ){8, 27, 64}

Same===function

Syntax

Same(exp₁, exp₂, … )exp₁ === exp₂ === …

gives True if all expressions exp_i are identical, and False otherwise.

Details

Same is evaluated immediately and always gives False or True.
Same verify the expressions for exact correspondence and ignores the mathematical equality, unlike Equal==.

Examples

123 === "text"False

x === yFalse

f(5) === f(5)True

The integer 1 and the real number 1.0 are not identical, but mathematically equal.

1 === 1.0 1 == 1.0False True

Overflows are identical, but the equality is unknown.

Overflow === Overflow Overflow == OverflowTrue Overflow == Overflow

Possible Issues

Same=== is evaluated immediately, while Equal== is keep unevaluated until a decision is possible.

x === 2 Replace( x === 2 , x->2 )False False

x == 2 Replace( x == 2 , x->2 )x == 2 True

Scopefunction

Syntax

Scope(sym, body)

evaluates body with the local symbol sym.

Scope({sym₁, sym₂, … }, body)

evaluates body with the local symbols sym_i.

Details

sym can be either a single symbol or an assignment in form of sym = exp of an expression exp to the symbol sym.
Scope replaces all symbols sym_i in body by unique symbols protected from the outer scope.
Unique symbols are specified by a $-character followed by an unique index.

Examples

Scope keeps x and y unchanges in the outer scope.

x = 123; a=3; b=44

Scope({x, y}, x=a+b; y=a-b; x/y )-7

{x, y, a, b}{123, y, 3, 4}

Defines temporary symbols:

Scope({z=2, w=3}, z*w )6

{z, w}{z, w}

Possible Issues

Temporary symbols used in the scope will become a unique symbol if they are returned.

Scope(x, x+y )x$3 + y

Selectfunction

Syntax

Select(list, crit)

gives all elements e_i of list for which crit(e_i) is True.

Details

list can be any expression, no necessarily a List{…}.
crit should be a function receiving an element e_i from list as argument and returning True or False.
Usually, crit is a Function&.

Examples

Select( {"Hello", x+y, 4, 3+I, "World!", z} , Head(#)===String & ){"Hello", "World!"}

check(x?) := x^2 < 6Null

Select( {1, 2, 3, 4, y, 2.2}, check ){1, 2, 2.2}

Select works with any kind of expression.

Select( 1 + w - Pi + x^2 + E, Head(Calculate(#))===Real & )1 + E - Pi

Sequencefunction

Syntax

Sequence(arg₁, arg₂, … )

is equivalent to a sequence of arguments arg_i in an expression or in pattern matching.

Details

A Sequence is typically returned from AnySequence?? or AnyNullSequence??? after pattern matching.
Sequence is flatten as soon as it is a function's argument.

Examples

func(Sequence(a, b, c), d)func(a, b, c, d)

arg = Sequence(2,4,6) Plus(arg) Times(arg)Sequence(2, 4, 6) 12 48

f(1, 2, 3) /: f(x??) :> xSequence(1, 2, 3)

Signfunction

Syntax

Sign(z)

gives the sign of the (complex) number z.

Details

In case of real numbers, Sign gives -1, 0, or +1, if z is negative, zero, or positive, respectively.
In case of complex numbers, Sign(z) is defined as z/Abs(z).
For special cases of z, some simplifications are performed.

Examples

Sign(-123)-1

Sign(2.5)1

Sign(1.2 + 3.4*I)0.33282+0.94299*I

Sign(1+I)(1+I)/2^(1/2)

Sign uses the numerical estimation of an expression to decide about the sign of the result.

Sign(Pi-E)1

Sign(Sin(4))-1

Sin(4) // Calculate-0.756802

Simplifications are performed if possible.

Sign(-2*x)-Sign(x)

Sinfunction

Syntax

Sin(z)

gives the sine of z.

Details

Sin gives an exact result when possible.
If z is an exact numerical value, Sin remains unevaluated if no exact solution was found.
z is assumed to be in radians.

Examples

Sin(2.0)0.909297

Calculate(Sin(2), 70)0.9092974268256816953960198659117448427022549714478902683789730115309673

Sin(2.0+3.0*I)9.1545-4.16891*I

Particular arguments and their result:

Sin(0)0

Sin(Pi/2)1

Sin(Pi/3)1/2*3^(1/2)

Sin(Pi/4)1/2^(1/2)

The sine of the arcus sine is identity:

Sin(ArcSin(z))z

Sinhfunction

Syntax

Sinh(z)

gives the hyperbolic sine of z.

Details

Sinh gives an exact result when possible.
If z is an exact numerical value, Sinh remains unevaluated if no exact solution was found.

Examples

Sinh(2.0)3.62686

Calculate(Sinh(2), 70)3.626860407847018767668213982801261704886342012321135721309484474934250

Sinh(2.0+3.0*I)-3.59056+0.530921*I

Particular arguments and their result:

Sinh(0)0

Sinh(I*Pi)Sinh(I*Pi)

The hyperbolic sine of the area hyperbolic sine is identity:

Sinh(ArSinh(z))z

Slot#function

Syntax

Slot(n)#n

represents n^th argument of an anonymous function (Function&).

#

represents the first argument of an anonymous function.

Details

Slot is only used in Function&.

Examples

Select( {0,1,2,3,4,5,6,7,8,9} , #<5 & ){0, 1, 2, 3, 4}

f = Function(#1^#2) f(a, b) f(3, 4)Function(#1^#2) a^b 81

Sortfunction

Syntax

Sort(list)

sorts the elements of list into canonical order.

Sort(list, cmp)

uses the comparison function cmp for ordering.

Details

Sort is usually used on List{…}, but handles all type of expressions.
Sort orders Integern, Rationala/b and Realx numbers by their numerical value, and Complexx+y*I numbers by their real part and then by their imaginary part.
Sort orders String"…",'…' using the Unicode collation algorithm.
Sort orders numerical values before String"…",'…', Symbols and Expressionf(…).
The optional comparison function cmp receives two arguments e₁ and e₂ (a pair of elements of list) and has to return one of the following values:
True e₁ and e₂ are in order
False e₁ and e₂ are out of order
1 e₁ comes before e₂
-1 e₁ comes after e₂
0 e₁ and e₂ are identical

Examples

Sort({ "Hello", x+y, 4, 3+I, z}){3+I, 4, "Hello", z, x + y}

Sort( f(3,1,2) )f(1, 2, 3)

Use a comparison function for custom sorting.

Sort( {-3, 2, -1, 0, Pi, 4} ){-3, -1, 0, 2, 4, Pi}

Sort( {-3, 2, -1, 0, Pi, 4}, GreaterEqual ){4, Pi, 2, 0, -1, -3}

Sort( {-3, 2, -1, 0, Pi, 4}, Abs(#1) <= Abs(#2) & ){0, -1, 2, -3, Pi, 4}

During the sort of strings the unicode collation algorithm is used.

Sort({"NINO", "Nina", "Nino", "Ninu", "Niño"}){"Nina", "Nino", "NINO", "Niño", "Ninu"}

Sorting strings by their length:

Sort({"Hello", "Foo", "Baa", "World", "!"}, Length(#1) <= Length(#2) & ){"!", "Foo", "Baa", "Hello", "World"}

Span..function

Syntax

Span(m, n)m .. n

represents a span between the integers m and n.

Span(m, n, s)m .. n .. s

represents a span between the integers m and n in steps of s.

Details

Negative integers for m or n count from the end in the respective scope.
A negative integer for s count backwards.
Span is typically used in Part[…].

Examples

"Hello World!"[7..-1]"World!"

"Hello World!"[-1..-6..-1]"!dlroW"

{a, b, c, d, e}[1..5..2]{a, c, e}

Sqrtfunction

Syntax

Sqrt(z)

gives the square root of z.

Details

Sqrt(z) is converted to Power(z, 1/2).

Examples

Sqrt(16)4

Sqrt(2.0)1.41421

Sqrt(-0.5)0.0+0.707107*I

Particular arguments and their result:

Sqrt(0)0

Sqrt(-1)I

Sqrt(Infinity)Infinity

String"…",'…'object

Syntax

"…"

is a text string, a sequence of unicode characters in double quote marks.

'…'

is a binary string, a sequence of bytes in single quote marks.

String

is the head of a string.

Details and Options

In the sequence the \-character is used to mask the following special and unprintable characters:
\0 NUL \f FF
\a BEL \r CR
\b BS \" "
\t TAB \' '
\n LF \\ \
\v VT \x00 – \xFF Two-digit hexadecimal code
Strings can be contain the null-character.
Strings can be converted with ToString between text form and binary form or any kind of object.

Examples

Text strings with unicode characters:

"abc αβγ \t ♦♥♠♣ \0 ﬂ""abc αβγ \t ♦♥♠♣ \0 ﬂ"

Head("abc αβγ \t ♦♥♠♣ \0 ﬂ")String

Binary strings with bytes are shown as ASCII characters:

'\0\0ÿ7)<''\0\0ÿ7)<'

Head('\0\0ÿ7)<')String

Possible Issues

Strings are not added with Plus+. They must be concatenated with Join~.

"Hello " + "World!""Hello " + "World!"

"Hello " ~ "World!""Hello World!"

Text strings will be converted into binary strings, if they are joined with a binary string.

'Cost: ' ~ "10 €"'Cost: 10 â\x82¬'

SubDefine@=function

Syntax

SubDefine(lhs, rhs)lhs @= rhs

evaluates the expression rhs, assign the result as a replacement for the expression lhs, and associates it with symbols occur in the first level of lhs.

Details

lhs is typically an expression with pattern objects.
For SubDefine the assignment f(g) @= rhs is associate with g, while f(g) = rhs (Define=) is associate with f.
The expression rhs will evaluated before assignment.
If lhs and rhs are lists with same length, the assignment is done with corresponding elements.
lhs can contain Condition/? to specialize the definition.
Clear can be used to remove all assignment rules from a symbol.

Examples

An assignment with SubDefine is associate with the arguments of the expression:

f(beta) @= 22

Definitions(f)/* no definitions */Null

Definitions(beta)f(beta) = 2Null

{ f(alpha), f(beta), f(123) }{f(alpha), 2, f(123)}

Assign a special addition for special symbols:

off + off @= off; off + on @= on; on + on @= off;Null

on + off on + off + onon off

Similar definitions are not always possible with Define= due to protected symbols.

off + on = on;Define.Protected: Plus is protected!Null

Possible Issues

An assignment with SubDefine@= has a higher priority than an assignment with Define=.

f(alpha) = 1 f(alpha) @= 21 2

f(alpha)2

SubDefineDelayed@:=function

Syntax

SubDefineDelayed(lhs, rhs)lhs @:= rhs

assigns the unevaluated expression rhs as a replacement for the expression lhs and associates it with symbols occur in the first level of lhs.

Details

lhs is typically an expression with pattern objects.
For SubDefineDelayed the assignment f(g(x)) @:= rhs is associate with g, while f(g(x)) := rhs (DefineDelayed:=) is associate with f.
The expression rhs will assigned unevaluated and is always evaluated when lhs is called.
If lhs and rhs are lists with same length, the assignment is done with corresponding elements.
lhs can contain Condition/? to specialize the definition.
Clear can be used to remove all assignment rules from a symbol.

Examples

An assignment with SubDefineDelayed is associate with the arguments of the expression:

f(a(x?)) @:= x^2Null

Definitions(f)/* no definitions */Null

Definitions(a)f(a(Pattern(x, ?))) := x^2Null

{ f(7), f(a(7)), f(a) }{f(7), 49, f(a)}

Assign a special addition for angles:

angle(x?) + angle(y?) @:= angle( Mod(x+y, 360) )Null

angle(270) + angle(180)angle(90)

Similar definitions are not always possible with DefineDelayed:= due to protected symbols.

angle(x?) + angle(y?) := angle( Mod(x+y, 360) )DefineDelayed.Protected: Plus is protected!Null

Possible Issues

An assignment with SubDefineDelayed@:= has a higher priority than an assignment with DefineDelayed:=.

f(g(x?)) := x^2 f(g(x?)) @:= x*2Null

f(g(10))20

Subtract-function

Syntax

Subtract(exp₁, exp₂)exp₁ - exp₂

subtracts expression exp₂ from exp₁.

Details

Subtract(exp₁, exp₂) is converted to Plus(exp₁, Times(-1, exp₂)).
Subtract is suitable for both symbolic and numerical manipulation.

Examples

3 - 21

2*x - 3*x-x

2 - 1/4 2 - 0.257/4 1.75

Symbol`s`object

Syntax

s

with a sequence of any kind of unicode characters is a symbol, usually called variable.

Symbol

is the head of a symbol.

Details

The name of a symbol can not start with a number and can not contain operator signs.
Any kind of object can be assigned to a symbol via Define=, DefineDelayed:=, SubDefine@=, or SubDefineDelayed@:=.
The head of an expression is usually a symbol.
Symbols can be created by a string via ToSymbol if name requirements are fulfilled.

Examples

Head(var)Symbol

foo + foo2*foo

Assign numbers to a symbol:

x = 123 y = 4123 4

{ x+y, x*y, x^y }{127, 492, 228886641}

Assign expressions to a greek symbol:

φ = a*b^2a*b^2

{ φ , φ/b }{a*b^2, a*b}

Convert a string to a symbol:

ToSymbol("world")world

Possible Issues

Symbol names are case sensitive!

Var = 123123

{Var, var}{123, var}

Built-in symbols are protected against re-definitions.

True := 123 ; 2*TrueDefineDelayed.Protected: True is protected!2*True

Tanfunction

Syntax

Tan(z)

gives the tangent of z.

Details

Tan gives an exact result when possible.
If z is an exact numerical value, Tan remains unevaluated if no exact solution was found.
z is assumed to be in radians.

Examples

Tan(2.0)-2.18504

Calculate(Tan(2), 70)-2.185039863261518991643306102313682543432017746227663164562955869966774

Tan(2.0+3.0*I)-0.00376403+1.00324*I

Particular arguments and their result:

Tan(0)0

Tan(Pi/2)ComplexInfinity

Tan(Pi/3)3^(1/2)

Tan(Pi/4)1

The tangent of the arcus tangent is identity:

Tan(ArcTan(z))z

Tanhfunction

Syntax

Tanh(z)

gives the hyperbolic tangent of z.

Details

Tanh gives an exact result when possible.
If z is an exact numerical value, Tanh remains unevaluated if no exact solution was found.

Examples

Tanh(1.0)0.761594

Calculate(Tanh(1), 70)0.7615941559557648881194582826047935904127685972579365515968105001219532

Tanh(2.0+0.5*I)0.979941+0.030216*I

Particular arguments and their result:

Tanh(0)0

Tanh(I*Pi)Tanh(I*Pi)

Tanh(Infinity)1

The hyperbolic tangent of the area hyperbolic tangent is identity:

Tanh(ArTanh(z))z

Times*function

Syntax

Times(exp₁, exp₂, … )exp₁ * exp₂ * …

gives the product of all expressions exp_i.

Details

Times is suitable for both symbolic and numerical manipulation.
Times has the attributes Orderless, Flat and Listable.
Times() is defined as 1.
Times(exp) is simplified to exp.

Examples

2 * 3 * 424

x^2 * x^3x^5

2 * 1/4 2 * 0.251/2 0.5

Times is flattened and the arguments are sorted.

(a * c) * (b * 4)4*a*b*c

Times threads over List{…}:

{1, 2, 3} * 10{10, 20, 30}

{1, 2, x} * {5, 10, y}{5, 20, x*y}

ToIntegerfunction

Syntax

ToInteger(exp)

converts the expression exp to an integer number, if possible.

Details and Options

exp can be any expression or object like a number, a string or a symbol.
ToInteger clears the imaginary part of a complex number, unlike Trunc.
The following options can be used if exp is a string:
DigitBase Base of the digits to parse from a text string. The default base is 10.
BinaryFormat Format, how to parse a binary string.
Endianness Byte order in a binary string.

Examples

Convert any object or expressions to an integer:

ToInteger(3/2)1

ToInteger(-3.1415)-3

ToInteger(5+2*I)5

ToInteger(E)2

ToInteger(Pi^2)9

Convert strings to an integer:

ToInteger("12345")12345

ToInteger("FF", DigitBase->16)255

ToInteger('Oa¼\0', BinaryFormat->"Integer32")12345679

Without specifying BinaryFormat, the whole binary string is interpreted as bytes of an integer:

ToInteger('\0\0\0@êítFÐ\x9C,\x9F\f')1000000000000000000000000000000

Possible Issues

Some expressions or numbers cannot be converted in an integer:

ToInteger(Overflow)ToInteger(Overflow)

ToInteger({1,2,3})ToInteger({1, 2, 3})

ToRealfunction

Syntax

ToReal(exp)

converts the expression exp to a real number, if possible.

Details and Options

exp can be any expression or object like a number, a string or a symbol.
ToReal clears the imaginary part of a complex number, unlike Calculate.
The following options can be used if exp is a string:
DigitBase Base of the digits to parse from a text string. The default base is 10.
BinaryFormat Format, how to parse a binary string.

Examples

Convert any object or expressions to a real number:

ToReal(123)123.0

ToReal(3/5)0.6

ToReal(5+2*I)5.0

ToReal(E)2.71828

ToReal(Pi^2)9.8696

Convert strings to a real number:

ToReal("123.45")123.45

ToReal("FF.8", DigitBase->16)255.5

ToReal('yéöB', BinaryFormat->"float32")123.456

Possible Issues

Some expressions or numbers cannot be converted into a real number:

ToReal(ComplexOverflow)Indeterminate

ToReal({1,2,3})ToReal({1, 2, 3})

ToStringfunction

Syntax

ToString(str)

gives the text string from a binary string str or vice versa.

ToString(exp)

gives the string representation of the expression exp.

Details and Options

exp can be any expression or object like a number or a symbol.
Expressions are converted into strings via the internal format.
The following option can used:
BinaryFormat Format of the string encoding.
DigitBase Base of the digits in a text string. The default base is 10.
Endianness Byte order in a binary string.

Examples

Convert any object or expressions to a string:

ToString(123)"123"

ToString(3/2)"3/2"

ToString(-3.1415)"-3.141500000000000"

ToString(123.45678901234567890123456789e12345)"1.2345678901234567890123456789e12347"

ToString(5+2*I)"5+2i"

ToString(E)"E"

ToString(Pi^2)"Power(Pi, 2)"

Convert a text string into a binary string and vice versa with the specified format:

ToString("yä€𝄞", BinaryFormat->"UTF16")'y\0ä\0¬ 4Ø\x1EÝ'

ToString('y\0\0\0ä\0\0\0¬ \0\0\x1EÑ\x01\0', BinaryFormat->"UTF32")"yä€𝄞"

Convert a number to a text string with the specified base:

ToString(10000, DigitBase->2)"10011100010000"

ToString(10^100, DigitBase->36)"2HQBCZU2OW52BALA8LGC3S5Y9MM5TIY0VO9TKE25466GFI6AX8GS22X7KUU8L1TDS"

ToString(1024.0625, DigitBase->16)"400.1000000000"

Convert a number to a binary string with the specified format:

ToString(123456, BinaryFormat->"Integer32")'@â\x01\0'

ToString(3.1415, BinaryFormat->"Real64")'o\x12\x83ÀÊ!\t@'

ToSymbolfunction

Syntax

ToSymbol(str)

converts the string str to a symbol, if possible.

Details and Options

str must respect the rules for symbol names, see Symbols.

Examples

ToSymbol("var")var

a = 123;Null

ToSymbol("a")123

b = "al"; c = "pha"; alpha = 456;Null

b~c"alpha"

ToSymbol(b~c)456

Possible Issues

An error occurs, when the string does not meet the rules for symbol names:

ToSymbol("3a")ToSymbol.Name: "3a" contains invalid characters for a symbol name.ToSymbol("3a")

ToSymbol("no-var")ToSymbol.Name: "no-var" contains invalid characters for a symbol name.ToSymbol("no-var")

Trueconstant

Syntax

True

represents the boolean value true.

Details

True is a possible result of comparisons and logical operations.

Examples

1 == 1True

Not(True)False

Truncfunction

Syntax

Trunc(x)

gives the integer part of x.

Details

If x is an exact numerical expression, the numerical approximation of x is used to establish the result.
For a complex number x, Trunc is applied separately to the real and imaginary part.

Examples

Trunc(-2.1)-2

Trunc(2.9)2

Trunc(-13/8)-1

Trunc(1.2 + 3.8*I)1+3*I

Trunc(Log(10))2

Processing of Overflow and Underflow:

Trunc(Overflow)Overflow

Trunc(Underflow)0

Trunc(-Underflow)0

Underflowconstant

Syntax

Underflow

represents an underflow in float-pointing arithmetic.

Details

The head of Underflow is Real.
Underflow is always smaller than the lowest not negative possible real value, but always larger than 0.

Examples

Exp(-10.0^20.0)Underflow

Arithmetical and mathematical functions are able to process Underflow:

3.14 + Underflow3.14

Underflow * (-2)-Underflow

3.14 / UnderflowOverflow

Log(Underflow)-Overflow

Unequal!=function

Syntax

Unequal(exp₁, exp₂, … )exp₁ != exp₂ != …

gives True if all expressions exp_i are mathematically unequal, and False if they are equal.

Details

Unequal verify the expressions for mathematical inequality, unlike Same===.
Inexact numbers are considered as unequal if they differ in more then their last five binary digits.

Examples

1 != 2True

1 != Pi != 3.0True

The integer 1 and the real number 1.0 are mathematically not unequal, but also not identical.

1 != 1.0 1 === 1.0False False

All argument combination pairs must be unequal.

1 != 2 != 1False

Unequal stays unevaluated if inequality is unknown.

a != ba != b

Possible Issues

Inexact numbers are considered as unequal if more the last one or two decimal digits are different. This allows an easier handling with floating point numbers.

1.0000000000000000002 != 1.0000000000000000001False

1.00000000000000000020 != 1.00000000000000000010True

Unionfunction

Syntax

Union(list)

gives a sorted version of list without duplicates.

Union(list₁, list₂, … )

gives a sorted list of all distinct elements that appear in any of list_i.

Details

If the lists list_i are considered as sets, Union gives their union list₁ ∪ list₂.
Union works with any kind of expressions as long as they have the same head.

Examples

Union( {4,3,3,1} ){1, 3, 4}

Union( {4,3,3,1} , {2,4,4,5} ){1, 2, 3, 4, 5}

Union( {4,3,3,1} , {2,3.0} , {x} ){1, 2, 3, 3.0, 4, x}

Union works with any expressions, not only lists, as long as they have the same head.

Union( a + b , a + c + d )a + b + c + d

Union( f(1, 2), f(2, 3) )f(1, 2, 3)

Possible Issues

Heads have to be the same when Union is applied on expressions.

Union( f(1, 2), g(2, 3) )Union.Heads: Heads f and g are not the same.Union(f(1, 2), g(2, 3))

Xor!!function

Syntax

Xor(bool₁, bool₂, … )bool₁ !! bool₂ !! …

gives the logical XOR (exclusive OR) bool_i.

Xor(int₁, int₂, … )int₁ !! int₂ !! …

gives the binary XOR (exclusive OR) of the integers int_i.

Xor(str₁, str₂, … )str₁ !! str₂ !! …

gives the binary XOR (exclusive OR) of the strings str_i.

Details

Xor gives True if an odd number of arguments are True, and False if an even number of arguments are True, while the rest are False.
Xor() is defined as False.
Xor(exp) is simplified to exp.
Integers are handled in their two's complement form.
Strings are converted into binary form and Xor is performed bitwise.

Examples

True !! True True !! True !! TrueFalse True

12 !! 711

'BINARY' !! 'abc''#+-ARY'

Xor is simplified depending on the number of True occurs in the arguments.

True !! a > 0a <= 0

True !! a > 0 !! Truea > 0

Assignment and Pattern Matchingoverview

Assignment rules

Define= • DefineDelayed:= • Clear ― definition of replacement rules
SubDefine@= • SubDefineDelayed@:= ― subordinate definition of replacement rules
Rule-> • RuleDelayed:> ― definition of transformation rules

Patterns

Any? • AnySequence?? • AnyNullSequence??? ― placeholder patterns
Pattern • Options ― assignment pattern
Alternatives| • Condition/? • Optional: ― Extension or restriction patterns

Symbol properties

Attributes • Definitions ― properties of a symbol assignment

Assignment attributes

Protected • Locked ― restriction of assignments
HoldAll • HoldFirst • HoldRest • SequenceHold ― evaluation of arguments

Evaluation attributes

Flat • Orderless • Listable ― reconstruction of arguments
NumericFunction • NumericConstant • OneIdentity ― numerical evaluation
Temporary ― storage type

Comparison and Logicoverview

Comparison

Same=== • Order ― canonical comparison
Equal== • Unequal!= ― numerial comparison
Greater> • GreaterEqual>= • Less< • LessEqual<= ― numerical inequalities
Matching ― pattern matching
If ― decision for evaluation flow

Boolean Algebra

False • True ― boolean constants
Boole ― converts a boolean value into an integer
Not! • And&& • Or|| • Xor!! ― boolean operators

Core Languageoverview

Object Types

Expressionf(…) ― expressions with a head and arguments
Symbols ― named variables, constants or symbols
String"…",'…' ― character strings or binary data
Integern • Rationala/b • Realx • Complexx+y*I ― number formats

Object Conversion

ToSymbol • ToInteger • ToReal • ToString ― convert into other objects
DigitBase • BinaryFormat • Endianness ― formatting rules

Evaluation Structures

Compound; • Sequence • List{…} ― sequence of expressions
If • Scope ― evaluation flow and scope
Function& • Slot# ― anonymous functions

Output Forms

Output • Print • InternalForm ― output formats

Introduction

Getting started

The syntax of Lizard is organized in six different types of input tokens:

Numbers	`123` , `3.14`	a sequence of decimal digits with an optional decimal point
Operators	`+` , `!=`, `->`	individual defined character groups
Symbols	`x` , `φ`, `var`	a sequence of any unicode characters which are not defined as operator
Strings	`"yä€𝄞"` , `'\0\0\0ÿ'`	a sequence of unicode or binary characters
Expressions	`head(arg1, arg2)`	a function with a head and arguments
Comments	`/* no code */`	not interpreted code blocks

In Lizard all operators are just the short form of their functional definition.
This means you can either enter calculations in operator form like 2 + 3 ^ 5 or in functional form like Plus(2, Power(3, 5)).
Lizard is a symbolic computation scripting language.
This means you can either perform a numerical calculation like 1 + 2 * 3 which will give 7,
or a symbolic evaluation like 2*a - 3*a which will give -a.
Everything which can not evaluated into a simple object type will be kept and handled as a general symbolic expression.
Most of the built-in functions of Lizard working with such general symbolic expressions, too.
Lizard uses polymorphic functions.
This means functions like Random() give different results depending on parameter type and count.
Many functions in Lizard use optional arguments or named parameters in form like option -> value.
This allows a specification of functions without a restricted sequence of arguments.
Lizard keeps calculation exact as long as exact inputs are given.
This means an input like Cos(Pi/6) gives 1/2*3^(1/2), while an input like Cos(Pi/6.0) gives 0.866025. To perform fast numerical calculations it is advised to use floating point numbers.
Lizard performs calculations first of all with fast processor word sized (64-bit) integers as well as floating point numbers.
Only if larger integers or floating point numbers with huge magnitudes or higher precisions are needed, slower arbitrary size and precision arithmetic is performed.

Highlighted features

Full support of symbolic expression.
Support of arbitrary size integers.
Support of real numbers with arbitrary precision.
Support of rational and complex numbers.
Full unicode character string and binary string support.
Support of polymorphic or anonymous functions.
Powerful pattern matching engine for assignments and replacements.
Support of named parameters in functions.
High flexibility in work with subparts of strings, lists or general expressions.
Numerous conversion functions, supporting different number formats and string formats under consideration of endianness and digit base.

Lists and Expressionsoverview

Properties

Head • Depth • Length ― shape and dimension of lists and expressions
Flat • Orderless • Listable ― reconstruction of elements

Handling

Construction and combination

Expressionf(…) • List{…} • Iterate ― constucting lists or expressions
Join~ • Union • Intersection • Complement ― combining lists or expressions

Reshape

Partition ― subdividing elements
Sort ― re-order elements
Apply • Map/@ ― replacing heads

Extraction and exchange

Part[…] • Span.. • Select ― extracting elements
Replace/: ― exchange elements

Mathematicsoverview

Objects, Constants and Boundaries

Numbers Types

Integern ― integer numbers
Rationala/b ― rational numbers
Realx ― real numbers
Complexx+y*I ― complex numbers

Numerical Constants

Pi ― π ≅ 3.14159
E ― Euler's number e ≅ 2.71828
EulerMascheroni ― Euler–Mascheroni constant γ ≅ 0.577216
GoldenRatio ― golden ratio φ ≅ 1.61803
GoldenAngle ― golden angle ≅ 137.5°

Numerical Boundaries

Underflow • Overflow ― boundaries of real numbers
ComplexUnderflow • ComplexOverflow ― boundaries of complex numbers
Infinity • ComplexInfinity • DirectedInfinity ― mathematical limits
Indeterminate ― numerical indeterminate

Mathematical Functions

Arithmetic Functions

Plus+ • Subtract- ― first level of arithmetic
Times* • Divide/ • Mod ― second level of arithmetic
Power^ • Exp • Log • Sqrt ― third level of arithmetic

Numerical Functions

Minus- • Abs • Sign ― properties of real numbers
Ceil • Floor • Trunc ― convert real numbers into integer numbers
Min • Max • Sort ― order of numbers

Complex Functions

I ― imaginary unit
Abs • Arg ― properties of complex numbers
Conjugate • Re • Im ― convert complex numbers

Trigonometric Functions

Sin • Cos • Tan ― trigonometric functions
ArcSin • ArcCos • ArcTan ― inverse trigonometric functions

Hyperbolic Functions

Sinh • Cosh • Tanh ― hyperbolic functions
ArSinh • ArCosh • ArTanh ― inverse hyperbolic functions

Special Functions

Factorial! • Binomial ― combinatoric functions
Fibonacci • Prime ― number series
Random ― random numbers

Syntax

Brackets

Expressions

`f(x)`	`f(x)`	Expression`f`(…)
`f(x)(y)`	`(f(x))(y)`	Expression`f`(…)

Part

`x[y]`	`Part(x, y)`
`x[y][z]`	`Part(Part(x, y), z)`
`x[y,z,…]`	`Part(x, y, z, …)`

Lists

{x, y, …} List(x, y, …)

Strings

`"x"`		String"…",'…'
`'x'`		String"…",'…'

Operators and Separators

Level 20 (high)

`?h`	`Any(h)`
`??h`	`AnySequence(h)`
`???h`	`AnyNullSequence(h)`
`s?h`	`Pattern(s, Any(h))`
`s??h`	`Pattern(s, AnySequence(h))`
`s???h`	`Pattern(s, AnyNullSequence(h))`

Level 19

f @ g @ x f(g(x)) Expressionf(…)

Level 18

`x!`	`Factorial(x)`

Level 17

x ~ y ~ … Join(x, y, …)

Level 16

x ^ y ^ z Power(x, Power(y, z))

Level 15

`x * y * …`	`Times(x, y, …)`
`x / y / z`	`Divide(Divide(x, y), z)`

Level 14

`-x`	`Minus(x)`
`x + y + …`	`Plus(x, y, …)`
`x - y - z`	`Subtract(Subtract(x, y), z)`

Level 13

`x == y == …`	`Equal(x, y, …)`
`x != y != …`	`Unequal(x, y, …)`
`x < y < …`	`Less(x, y, …)`
`x <= y <= …`	`LessEqual(x, y, …)`
`x > y > …`	`Greater(x, y, …)`
`x >= y >= …`	`GreaterEqual(x, y, …)`

Level 12

`x === y === …`	`Same(x, y, …)`
`x .. y .. …`	`Span(x, y, …)`

Level 11

!b Not(b)

Level 10

`x \|\| y \|\| …`	`Or(x, y, …)`
`x && y && …`	`And(x, y, …)`
`x !! y !! …`	`Xor(x, y, …)`

Level 9

x | y | … Alternatives(x, y, …)

Level 8

x /? y /? f Condition(x, Condition(y, f))

Level 7

x : y : z Optional(Optional(x, y), z)

Level 6

`x -> y -> z`	`Rule(x, Rule(y, z))`
`x :> y :> z`	`RuleDelayed(x, RuleDelayed(y, z))`

Level 5

x /: y /: z Replace(Replace(x, y), z))

Level 4

`x // f // g`	`f(g(x))`	Expression`f`(…)
`f /@ g /@ x`	`Map(f, Map(g, x))`

Level 3

f & Function(f)

Level 2

`x = y = z`	`Define(x, Define(y, z))`
`x := y := z`	`DefineDelayed(x, DefineDelayed(y, z))`
`x @= y @= z`	`SubDefine(x, SubDefine(y, z))`
`x @:= y @:= z`	`SubDefineDelayed(x, SubDefineDelayed(y, z))`

Level 1

x ; y ; … Compound(x, y, …)

Level 0 (low)

x , y , … Sequence(x, y, …)

`True`	`e₁` and `e₂` are in order
`False`	`e₁` and `e₂` are out of order
`1`	`e₁` comes before `e₂`
`-1`	`e₁` comes after `e₂`
`0`	`e₁` and `e₂` are identical

`\0`	NUL	`\f`	FF
`\a`	BEL	`\r`	CR
`\b`	BS	`\"`	"
`\t`	TAB	`\'`	'
`\n`	LF	`\\`	\
`\v`	VT	`\x00` – `\xFF`	Two-digit hexadecimal code

DigitBase	Base of the digits to parse from a text string. The default base is `10`.
BinaryFormat	Format, how to parse a binary string.
Endianness	Byte order in a binary string.

BinaryFormat	Format of the string encoding.
DigitBase	Base of the digits in a text string. The default base is `10`.
Endianness	Byte order in a binary string.

Index

Absfunction

Syntax

Details

Examples

See also

Allconstant

Syntax

Details

Examples

See also

Alternatives|function

Syntax

Details

Examples

See also

And&&function

Syntax

Details

Examples

See also

Any?function

Syntax

Details

Examples

Possible Issues

See also

AnyNullSequence???function

Syntax

Details

Examples

See also

AnySequence??function

Syntax

Details

Examples

See also

Applyfunction

Syntax

Details

Examples

See also

ArcCosfunction

Syntax

Details

Examples

See also

ArCoshfunction

Syntax

Details

Examples

See also

ArcSinfunction

Syntax

Details

Examples

See also

ArcTanfunction

Syntax

Details

Examples

See also

Argfunction

Syntax

Details

Examples

See also

ArSinhfunction

Syntax

Details

Examples

See also

ArTanhfunction

Syntax

Details

Examples

See also

Attributesfunction

Syntax

Details

Complex`x`+`y`*Iobject