All

• All is typical used in Part[…].

{ x^2, y^4, z^5 }[All, 1] {x, y, z}

Part[…]

And(bool1, bool2, … ) bool1 && bool2 && … And(int1, int2, … ) int1 && int2 && …

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

True && False False 12 && 7 4 And stops to evaluate its arguments if False occurs. (Print(1);True) && False && (Print(2);True) 1 False Expressions which are evaluated into True will be erased. 2==2 && a==5 && b==10 && True a == 5 && b == 10

False  —  True  —  Or||

Complex x + y*I

• Is the real or imaginary part an unexact number, the other part will converted to an unexact number too.

Head(1+2*I) Complex (1-I)^3 -2-2*I 1/2 + 0.4*I 0.5+0.4*I

Integer  —  Rational  —  Real

Depth(exp)

• For a non-expression objects, Depth is 0.

Depth( { {1,2}, 3, {4,{5,6}} } ) 3 Depth( 123 ) 0 Depth works with any expressions, not only lists. Depth( a + 2*b + c ) 2 Depth( f(x^2) ) 2 Rational and complex numbers have a depth of 0. Depth( 1/3 ) 0 Depth( 1+2*I ) 0

Length  —  Part[…]

E

• E is exact and is not evaluated as long as it is not combined with an inexact computation.

Calculate(E) 2.71828 E*2 2*E E*2.0 5.43656 Some functions give exact results for terms with E. Log(E) 1

I  —  Pi

Equal(exp1, exp2, … ) exp1 == exp2 == …

• Equal verify the expressions for mathematical equality unlike Same===.

1 == 1 True Integer 1 and Real 1.0 are mathematically equal, but not identical. { 1 == 1.0 , 1 === 1.0 } {True, False} The equality of Overflows is unknown, but they are identical. { Overflow == Overflow , Overflow === Overflow } {Overflow == Overflow, True} Equal stays unevaluated if equality is unknown. a == b a == b

Same===  —  Unequal!=

head(arg1, arg2, … )

• head is typical a Symbol, but can by any other Expression.
• Expressions can be assigned with any kind of object.

Head( func(a, b) ) func Head( h(y)(a, b) ) h(y) f(1) = 3 3 { f(0), f(1) } {f(0), 3} { f(0), f(1) } {f(0), 3}

Symbol  —  Head

False

• False is a typical result of locical and comparison operations.

1 == 2 False Not(False) True

True  —  Not!

Greater(x1, x2, … ) x1 > x2 > …

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

2 > 1 True 1/3 > 0 > -0.5 True x > 2 > 2 False The comparison will be simplified if possible. 2 > 1 > x 1 > x The value of an exact expression is approximated for comparison. Sin(2) > 0 True

GreaterEqual>=  —  Less<  —  LessEqual<=  —  Equal==  —  Unequal!=

GreaterEqual(x1, x2, … ) x1 >= x2 >= …

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

2 >= 1 True 3/2 >= 1.5 >= -0.5 True x >= 1 >= 2 False The comparison will be simplified if possible. 2 >= 1 >= x 1 >= x The value of an exact expression is approximated for comparison. Sin(2) >= 0 True

Greater>  —  Less<  —  LessEqual<=  —  Equal==  —  Unequal!=

I

• The imaginary part of Complex numbers are represented with I.

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

E  —  Pi  —  Complex

Integer n

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

Head(123) Integer 3^100 515377520732011331036461129765621272702107522001

Rational  —  Real  —  Complex

Join(exp1, exp2, … ) exp1 ~ exp1 ~ … Join(str1, str2, … ) str1 ~ str1 ~ …

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)

Depth  —  Length  —  Part[…]

Length(exp) Length(str)

• For neither expression nor string, Length is 0.

Length( {1,2,3,4,5} ) 5 Length( "Hello World!" ) 12 Length works with any expressions, not only lists. 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

Depth  —  Part[…]

Less(x1, x2, … ) x1 < x2 < …

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

1 < 2 True -0.5 < 0 < 1/3 True x < 2 < 2 False The comparison will be simplified if possible. 1 < 2 < x 2 < x The value of an exact expression is approximated for comparison. Sin(4) < 0 True

LessEqual<=  —  Greater>  —  GreaterEqual>=  —  Equal==  —  Unequal!=

LessEqual(x1, x2, … ) x1 <= x2 <= …

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

1 <= 2 True -0.5 <= 1.5 <= 3/2 True x <= 2 <= 1 False The comparison will be simplified if possible. 1 <= 2 <= x 2 <= x The value of an exact expression is approximated for comparison. Sin(4) <= 0 True

Less<  —  Greater>  —  GreaterEqual>=  —  Equal==  —  Unequal!=

List(e1, e2, … ) { e1, e2, … }

List( 1, 2, 3 ) {1, 2, 3} {{a1,a2}, {b1,b2}} {{a1, a2}, {b1, b2}}

Length  —  Depth  —  Part[…]

Not(bool) !bool Not(int) !int

• Not gives True if bool is False, and False if it is True.
• Integers are handled in their two's complement form.

! False True ! 15 -16 Negation of comparisons are simplified if possible. Not( x < 3 ) x >= 3 Double negation of an expression is the expression itself. Not( Not( exp ) ) exp

False  —  True  —  Or||  —  And&&

Or(bool1, bool2, … ) bool1 || bool2 || … Or(int1, int2, … ) int1 || int2 || …

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

True || False True 12 || 7 15 Or stops to evaluate its arguments if True occurs. (Print(1);False) || True || (Print(2);False) 1 True Expressions which are evaluated into False will be erased. 1==2 || a==5 || b==10 || False a == 5 || b == 10

False  —  True  —  And&&

Part(exp, level1, level2, … ) exp[level1, level2, … ] Part(str, part) str[part] The part and level specifications can have the following forms: …[n] …[-n] …[{n1, n2, … }] …[m..n] …[m..n..s] …[ All ]

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} 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( x^3+2*x+1 , 2, 1) 2

Depth  —  Length  —  Span..

Pi

• Pi is exact and is not evaluated as long as it is not combined with an inexact computation.

Calculate(Pi) 3.14159 Pi*2 2*Pi Pi*2.0 6.28319 Some functions give exact results for terms with Pi. Sin(Pi/2) 1

E  —  I

Rational a/b

• Rational numbers will are reduced as much as possible.
• Rational numbers are always exact values.

Head(1/2) Rational 4/12 1/3

Integer  —  Real  —  Complex

Real x

• Real numbers are stored as a 64-Bit float pointing value.
• Real numbers are inexact values.
• Calculations with at least one inexact value leeds to an inexact result.

Head(1.0) Real 1 + 2.0 3.0

Integer  —  Rational  —  Complex

Same(exp1, exp2, … ) exp1 === exp2 === …

• Same verify the expressions for exact correspondence and ignores the mathematical equality unlike Equal==.

x === y False Integer 1 and Real 1.0 are not identical, but mathematically equal. { 1 === 1.0 , 1 == 1.0 } {False, True} Overflows are identical, but the equality is unknown. { Overflow === Overflow , Overflow == Overflow } {True, Overflow == Overflow}

Equal==

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

• Negative integers for m or n count from the end in the respective scope.

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

Part[…]

String "…"

"Hello World!" "Hello World!" Head("Text") String

Length

Symbol s

• Symbols can be assigned with any kind of object.
• Symbols typically used as a head of an expression.

Head(var) Symbol φ = f(1) 3 φ 3

Length

True

• True is a typical result of locical and comparison operations.

1 == 1 True Not(True) False

False  —  Not!

Unequal(exp1, exp2, … ) exp1 != exp2 != …

• Unequal verify the expressions for mathematical inequality unlike Same===.

1 != 2 True Integer 1 and Real 1.0 are mathematically not unequal. 1 != 1.0 False All argument combination pairs must be unequal. 1 != 2 != 1 False Unequal stays unevaluated if inequality is unknown. a != b a != b

Same===  —  Equal==

Xor(bool1, bool2, … ) bool1 !! bool2 !! … Xor(int1, int2, … ) int1 !! int2 !! …

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

True !! False True 12 !! 7 11 Xor is simplified depending on the number of True ocuurs in the arguments. True !! exp !exp True !! exp !! True exp

False  —  True  —  And&&  —  Or||  —  Not!

Object Types

Integer  —  Rational  —  Real  —  Complex  —  String"…"  —  Symbol  —  Expression

Reserved Symbols

True  —  False  —  All  —  E  —  I  —  Pi  —  Indeterminate

Arithmetic & Mathematical Functions

Plus  —  Subtract  —  Times  —  Divide  —  Power
Abs  —  Arg  —  Calculate  —  Cos  —  Floor  —  Log  —  Minus  —  Mod  —  Random  —  Sin

Comparison

Same===  —  Equal==  —  Unequal!=  —  Greater>  —  GreaterEqual>=  —  Less<  —  LessEqual<=

Logical & Bit Operation

Not!  —  And&&  —  Or||  —  Xor!!

List & Expressions

Depth  —  Length  —  Part[…]  —  Span..  —  Join~  —  List{…}