# Mathematical Expressions

Using our mathematical expressions you can create unique mathematical calculations or combine multiple calculation variables together in a snap of a finger. In this support doc, we'll be walking you through how to use it and what expressions you can use on this element.

**What mathematical expressions can I use?**

You can use the following expressions on our variable modifiers:

- (...)
- f(), x.y, a[i]
- !
- ^
- +, -, not, sqrt, etc.
- *, /, %
- +, -, ||
- ==, !=, >=, <=, >, <, in
- and
- or
- x ? y : z
- =
- ;

**How do I use these mathematical expressions in the variable modifier?**

Really simple! First, you should refer to the variable you'd like to hook it up with, or refer to the current variable. Here's an example of when you have variables called "Price" and "DeliveryCost":

`@Price + @DeliveryCost`

Alternatively, you can also simple math to these variables, such as shown in this example:

`(@Price + @DeliveryCost) - 0.1`

Or create a variable that adds up all calculations as a total:

`(@Total * 0) + @Variable1 + @Variable2 + @Variable3 + Variable4`

Or make it somewhat more complex as shown in this example:

`(min(@Apple, @Banana) - 0.1) / 2`

You can make this as complicated as you'd like or as simple as you'd like!

*Advanced*: All supported mathematical expressions

*Advanced*: All supported mathematical expressions

### Pre-defined functions

**random(n):** Get a random number in the range [0, n). If n is zero, or not provided, it defaults to 1.

**fac(n):** n! (factorial of n: "n * (n-1) * (n-2) * … * 2 * 1") Deprecated. Use the ! operator instead.

**min(a,b,…):** Get the smallest (minimum) number in the list.

**max(a,b,…):** Get the largest (maximum) number in the list.

**hypot(a,b):** Hypotenuse, i.e. the square root of the sum of squares of its arguments.

**pyt(a, b):** Alias for hypot.

**pow(x, y):** Equivalent to x^y. For consistency with JavaScript's Math object.

**atan2(y, x):** Arc tangent of x/y. i.e. the angle between (0, 0) and (x, y) in radians.

**roundTo(x, n):** Rounds x to n places after the decimal point.

**map(f, a):** Array map: Pass each element of `a`

the function `f`

, and return an array of the results.

**fold(f, y, a): **Array fold: Fold/reduce array `a`

into a single value, `y`

by setting `y = f(y, x, index)`

for each element `x`

of the array.

**filter(f, a):** Array filter: Return an array containing only the values from `a`

where `f(x, index)`

is `true`

.

**indexOf(x, a):** Return the first index of string or array `a`

matching the value `x`

, or `-1`

if not found.

**join(sep, a):** Concatenate the elements of `a`

, separated by `sep`

.

**if(c, a, b):** Function form of c ? a : b. Note: This always evaluates both `a`

and `b`

, regardless of whether `c`

is `true`

or not. Use `c ? a : b`

instead if there are side effects, or if evaluating the branches could be expensive.

### Unary Operators

**-x: **Negation

**+x: **Unary plus. This converts it's operand to a number, but has no other effect.

**x!:** Factorial (x * (x-1) * (x-2) * … * 2 * 1). gamma(x + 1) for non-integers.

**abs x:** Absolute value (magnitude) of x

**acos x:** Arc cosine of x (in radians)

**acosh x:** Hyperbolic arc cosine of x (in radians)

**asin x:** Arc sine of x (in radians)

**asinh x:** Hyperbolic arc sine of x (in radians)

**atan x:** Arc tangent of x (in radians)

**atanh x:** Hyperbolic arc tangent of x (in radians)

**cbrt x:** Cube root of x

**ceil x:** Ceiling of x — the smallest integer that’s >= x

**cos x: **Cosine of x (x is in radians)

**cosh x:** Hyperbolic cosine of x (x is in radians)

**exp x:** e^x (exponential/antilogarithm function with base e)

**expm1:** xe^x - 1

**floor x:** Floor of x — the largest integer that’s <= xlength xString or array length of x

ln x: Natural logarithm of x

**log x:** Natural logarithm of x (synonym for ln, not base-10)

**log10 x:** Base-10 logarithm of x

**log2 x:** Base-2 logarithm of x

**log1p x:** Natural logarithm of (1 + x)

**not x:** Logical NOT operator

**round x:** X, rounded to the nearest integer, using "grade-school rounding"

**sign x:** Sign of x (-1, 0, or 1 for negative, zero, or positive respectively)

**sin x:** Sine of x (x is in radians)

**sinh x: **Hyperbolic sine of x (x is in radians)sqrt xSquare root of x. Result is NaN (Not a Number) if x is negative.

**tan x:** Tangent of x (x is in radians)tanh xHyperbolic tangent of x (x is in radians)

**trunc x:** Integral part of a X, looks like floor(x) unless for negative number