Functions and Variables for Math Expressions


Values at the current location:

  • Symbols of the selected volumes, specifying the value of the volume at this location.
  • Symbols of the selected horizons, specifying the horizon value at this location.

Values representing the current location:

  • Variables "nan" and "null" to specify an invalid value at this location.
  • Variables "twt_ms" and "twt_s", defined to be the time of a sample in milliseconds or seconds respectively.
  • Variables "tvdss_m" and "tvdss_ft", defined to be the true vertical depth (MSL) of a sample in metres or feet respectively.
  • Variables "offset", "freq", "channel", "realisation", "semblance", "rotation", "offset_m" and "offset_ft" for those dimensions of a sample, if operating on gathers.
  • Surface location variables ("x", "y", "il", "cl" and "cmp") applicable to the resulting output horizon. These variables are only available in Horizon Maths.
    For example, if the output is a 2D horizon, only the cmp location will be available. For a multi-survey horizon, surface locations will only be available if all horizons are of the same type (i.e. cmp is available if all are 2D CMP horizons).

Variables 'pi' and 'e' to define values of π and e.

Defining your own variables

If you are re-using the same value multiple times, or if you wish to organise your equations, defining your own variables can be very useful (and sometimes even more efficient!).

Variable Syntax:

  • The variable name appears on the left, followed by an equals sign (=), your expression, and finally a semi-colon (;).
  • Example:     
a = v1 * 2;     
res = a + sin(v1);
  • The semi-colon is very important. It must be there to separate the declaration of each variable.


You can build complex expressions that result in different behaviour in different situations. Conditional statements take the form:

if (condition, true statement, false statement)

where the true statement is used if the condition is true, or vice-versa. Note that those statements can themselves be arbitrary expressions, such as another conditional statement.

Standard comparison operators may be used, which may be combined with standard boolean operators. You can preface any boolean expression with a! to negate it:

<, >, <=, >=
Comparison: Less Than, Greater Than, Less Than or Equal, Greater Than or Equal
!=, ==
Equality: Not Equal, Equal
&&, ||, !
Boolean: AND, OR and NOT
isnan(...), isnull(...), ismissing(...)
These functions will evaluate to "true" if the expression is NaN (missing/undefined value), otherwise "false"
These functions are the opposite of isnan/isnull/ismissing -- they will evaluate to true if the value is defined at this location (not NaN)

Warning: Do not use != nan or == nan to check for invalid values in conditional statements. Use one of isnan(), isnull(), isvalid(), etc. functions instead.

Conditional Examples:

If both a and b are less than zero, use the value of c; otherwise use the sum of a and b:

  • if (a < 0 && b < 0, c, a + b)

A more-complicated way of writing the same thing, using one conditional inside another:

  • if (a < 0, if (b < 0, c, a + b), a + b)

If either a or b are NaN (invalid), use 1500; otherwise use the sum of a and b:

  • if (isnan(a) || isnan(b), 1500, a + b)

Combining / Merging

The most natural-seeming way to merge two things together would be to "add" them, as in a + b + c. But this doesn't work, for two reasons.

First, in places where they overlap, that would give you the arithmetic sum of the values at that location -- which is probably not what you intend.

Second, missing values are generally represented by the value NaN (not-a-number). NaN plus any other value remains NaN, so this would have the effect of producing output only at locations where all inputs are defined. This is also probably not what you intend.

To simplify this, Insight provides several functions to make combining easy:

  • merge(a, b, c, ...) - combines any number of items, in order of precedence. i.e. where they overlap, the first available value in the list will be used.
  • min(a, b, c, ...) - combines any number of items, using the smallest available value
  • max(a, b, c, ...) - combines any number of items, using the largest available value
  • sum(a, b, c, ...) - arithmetic sum of any number of items, ignoring those that aren't defined at a location
  • avg(a, b, c, ...) - arithmetic mean of any number of items, ignoring those that aren't defined at a location
  • random(max) - generate a random number between 0 and max (inclusive)
  • random(min, max) - generate a random number between min and max (inclusive)


The following operators are supported.



  • sin(x), cos(x), tan(x) sine, cosine, tangent of a value in radians
  • asin, acos, atan, tan2 — arc sine, arc cosine, arc tangent, arc tangent with 2 parameters (y, x)
  • sec, cosec cot — secant, cosecant, co-tangent
  • sinh, cosh, tanh, asinh, acosh, atanh — hyperbolic sine, cosine & tangent; inverse hyperbolic sine cosine & tangent.


  • ln — Natural Logarithm
  • log — Log base 10
  • lg — Log base 2
  • exp — Exponential (e^x)
  • pow — Power

Statistical / Array

Returns a result for all non-nan (valid) arguments specified. If all values are invalid or missing (nan), the result will be nan.

  • avg(a,b,...) — Average
  • min — Minimum
  • max — Maximum
  • sum — Sum
  • merge — Return the first valid value from the list of arguments.


  • round — Round
  • rint — Round to integer
  • floor — Floor
  • ceil — Ceiling


  • if(condition, trueval, falseval) — Evaluate condition, and if true, use truval, otherwise use falseval
  • abs — absolute value
  • rand — random number between 0 and 1
  • mod(x,y) — same as x % y
  • sqrt — square root
  • sum(a,b,...) — sum
  • binom(n, i) — binomial coefficient
  • signum(x) — sign of number (-1, 0, or 1 depending on the sign of x)
  • isnan, isnull, ismissing — true if the argument is nan (empty)
  • isdefined(...), isvalid(...) — true if the value is defined at this location (not nan)
  • random(min, max) — return a random number between min and max


  • re — real component
  • cmod — complex modulus (absolute value)
  • arg — argument (angle of complex value, in radians)
  • conj — complex conjugate
  • complex(r, i) — construct a complex number from imaginary parts
  • polar(r, theta) — construct a complex number from modulus and argument


pimp^2 - 2 * simp^2

  • Will create a Lambda-Rho volume (pimp squared minus 2 times simp squared)

if (!IsNaN(a), a, b)

  • Will use the value of volume "a" for a sample if it exists, otherwise the value of volume "b".

if (d_m < h1, 1500, v1)

  • Will make a copy of volume "v1", with any sample shallower than "h1" (a horizon) set to 1500.