###Operators

**Abs**

This module returns the absolute value of value A. The absolute value of any number is positive e.g. abs(-4) is 4, abs(17) is 17.
Absolute_Value = abs(Value_A)
This module is useful to avoid negative values or to mirror a function along the x-axis.

**Addition**

Summand A is added to summand B and the sum is returned.
Sum = Summand_A + Summand_B

**Division**

After dividing the dividend by the divisor the result, the quotient, is returned.
Quotient = Dividend / Divisor

**Get angle**

This panel returns the angle of the line formed by point A and B.

**Get distance**

Returns the distance of point A to point B.

**Max**

Max compares value A with value B and returns the bigger number. For instance if A is 17 and B is 5, 17 would be returned.
Max_Value = max(Value_A, Value_B)

**Min**

Value A is compared to value B and the smaller number is the result. If value A is 2 and value B is 65, 2 would be returned.
Min_Value = min(Value_A, Value_B)

**Modulo**

Modulo is similar to a division, the dividend is divided by the divisor and the remainder (and not the quotient) will be returned. If the dividend is 12 and the divisor is 5, 2 would be returned.
Remainder = Dividend mod Divisor

**Multiplication**

The product of the multiplication of factor A by factor B is this function’s result. If factor A is 3 and factor B is 5, 15 would be returned.
Product = Factor_A * Factor_B

**Subtraction**

This module’s result is the difference of the subtrahend and the minuend.
Difference = Minuend – Subtrahend

###Constants

**E**

Returns the value of the Euler number, which is approximately 2.17.
Value_E = e

**PI**

Returns the value of π, which is around 3.14.
Value_Pi = π

**Variable**

This just returns value A, nothing useful in a mathematical sense, but handy for building setups that are more complex or for using one value as basis for several different modules.
Variable = Value_A

###Behaviors

**Ease-out**

This behavior generates an elastic behavior or movement. Value A and value B represent the current and the desired value, and factor defines the elasticity. The resulting sequence starts at value A, moves fast towards value B and slows down.
Value_Ease_out = Value_A + (Value_B - Value_A) / Factor

**Serial chain**

This behavior mimics the motion of objects connected by a rigid chain. The radius defines their distance. The calculation of object B’s position is based on its current position, the radius and the position of the leading object (object A).
This behavior is useful for building up a chain of objects, which follow their leading objects but keep a defined distance from each other.

###Inputs

**Keyboard (cursors)**

Detects which of the cursor keys is pressed. The function returns either 0 or 1.

**Keyboard (digits)**

Detects which of the number keys is pressed. The function returns either 0 or 1.

**Mouse**

This module returns the mouse’s position and the status of its buttons.

###Conditionals

**AND**

Returns 1 if value A and value B are true (not 0), otherwise, 0 is returned.

**Bigger**

Returns 1 if value A is bigger than value B, otherwise, 0 is returned.

**Equal**

Returns 1 if value A is equal value B, otherwise 0 is returned.

**Not_equal**

Returns 1 if value A is not equal value B, otherwise 0 is returned.

**OR**

Returns 1 if value A, value B or both are true (not 0), otherwise 0 is returned.

###Functions

**Cycloid**

A cycloid is ‘… the path of a point on the rim of a wheel of radius R that rolls without slipping along the x-axis’ ([KR] p. 439). The graph drawn by the function looks like a sequence of half circles.

**Ellipse**

Informally an ellipse is a squashed circle; mathematically an ellipse is defined by two points and a constant. Every point whose distance to both points is equal to the constant is part of the ellipse.
The ellipse’s graph is based on horizontal and vertical value. Its proportions are defined by value A and value B, value T defines the current angle and should be kept between 0 and 2* π.
Horizontal_Value = Horizontal_Center + Value_A * cos(Value_T)

Vertical_Value = Vertical_Center + Value_B * sin(Value_T)

**Lemniscate**

The graph of a Lemniscate looks like a horizontal 8. Useful to create some curvy movement.

**Natural Logarithm**

The logarithm of a value A to a base is what you have to raise the base to the power of in order to get value A. The resulting graph moves fast along the y-axis but slows down soon.

**Power**

Returns the Base to the power of the Exponent.
For instance if the base is 5 and the exponent is 2, 25 will be returned.
Power_Value = Base ^ Exponent

**Random**

This module generates a random number. The smallest and the biggest value define the range of possible values.

**Sine**

A sine-function is this module’s result. The function is based on value A and its amplitude is scaled by a factor called ‘Amplitude_Scale’.
Sine_Value = sin(Value_A) * Amplitude_Scale
Sine is useful for smooth and periodic movement. The function’s y-value meanders between –1 and 1.
Adding or subtracting sine curves results in overlays. Remember the addition of two sine curves with a phase-difference of π results in an extinction of both functions.

**Spiral**

This module draws a spiral.
The angle defines the current angle and the factor defines how fast the spiral is growing.
Horizontal_Value = Horizontal_Center + (sin(Angle) [ Angle ](%20Angle%20) Factor)
Vertical_Value = Vertical_Center + (cos(Angle) [ Angle ](%20Angle%20) Factor)
The easiest way to exchange the spiral’s direction is to swap the horizontal with the vertical value.

**Step**

This module returns a sequence of values starting at the smallest value, going up to the biggest value by adding the step value.
After reaching the biggest value the algorithm starts at the smallest value again.
Step_Value(n) = Smallest_Value + n * Step_Value

**Step up and down**
This module returns a sequence of values starting at the smallest value, going up to the biggest value by adding the step value. After reaching the biggest value, the algorithm turns and goes down to the Smallest value again.
Step_Value(n) = Smallest_Value + n * Step_Value

**Tangent**

The function yields the tangent of a given value. The function is based on value A and its amplitude is scaled by a factor called ‘Amplitude Scale’.
Tangent_Value = tan(Value_A) * Amplitude_Scale