ABS(x)

Absolute value

ABS(x)

CEIL(x)

Round up to nearest integer

CEILING(x)

FLOOR(x)

Round down to nearest integer

FLOOR(x)

INT(x)

Truncate to integer (remove decimals)

TRUNC(x)

ROUND(x, digits)

Round to specified decimal places

ROUND(x, digits)

a MOD b

Remainder after division (infix only)

MOD(a, b)

SGN(x)

Sign: 1 (positive), -1 (negative), 0 (zero)

SIGN(x)

SQR(x)

Square (x²)

x*x

SQRT(x)

Square root

SQRT(x)

MAX(x, y, ...)

Maximum of values

MAX(x, y, ...)

MIN(x, y, ...)

Minimum of values

MIN(x, y, ...)

SUM(x, y, ...)

Sum of values

SUM(x, y, ...)

FACT(n)

Factorial (n!)

FACT(n)

SIN(x)

Sine

SIN(x)

COS(x)

Cosine

COS(x)

TAN(x)

Tangent

TAN(x)

ARCSIN(x)

Arcsine (inverse sine), -1 ≤ x ≤ 1

ASIN(x)

ARCCOS(x)

Arccosine (inverse cosine), -1 ≤ x ≤ 1

ACOS(x)

ARCTAN(x)

Arctangent (inverse tangent)

ATAN(x)

ARCTAN2(y, x)

Angle to point (y,x). ⚠️ Prism uses (y,x)

ATAN2(x, y) ⚠️

SINH(x)

Hyperbolic sine

SINH(x)

COSH(x)

Hyperbolic cosine

COSH(x)

TANH(x)

Hyperbolic tangent

TANH(x)

ARCSINH(x)

Inverse hyperbolic sine

ASINH(x)

ARCCOSH(x)

Inverse hyperbolic cosine, x ≥ 1

ACOSH(x)

ARCTANH(x)

Inverse hyperbolic tangent, -1 < x < 1

ATANH(x)

RAD(degrees)

Convert degrees to radians

RADIANS(degrees)

DEG(radians)

Convert radians to degrees

DEGREES(radians)

EXP(x)

e raised to power x

EXP(x)

LN(x)

Natural logarithm (base e), x > 0

LN(x)

LOG(x)

Base-10 logarithm, x > 0

LOG10(x)

LOG10(x)

Base-10 logarithm (alias for LOG)

LOG10(x)

LOG2(x)

Base-2 logarithm, x > 0

LOG(x, 2)

LOGIT(p)

Log-odds: ln(p/(1-p)), 0 < p < 1

LN(p/(1-p))

NORMDIST(x, mean, sd, tail_type)

Cumulative probability. Defaults: mean=0, sd=1, tail="left"

NORM.DIST(x, mean, sd, TRUE)

NORMINV(p, mean, sd, tail_type)

Quantile (inverse CDF). Defaults: mean=0, sd=1, tail="left"

NORM.INV(p, mean, sd)

NORMPDF(x, mean, sd)

Probability density. Defaults: mean=0, sd=1

NORM.DIST(x, mean, sd, FALSE)

ZDIST(z, tail_type)

Cumulative probability. Default: tail="left"

NORM.S.DIST(z, TRUE)

ZINV(p, tail_type)

Quantile. Default: tail="left"

NORM.S.INV(p)

ZPDF(z)

Probability density

NORM.DIST(z, 0, 1, FALSE)

TDIST(t, df)

Upper-tail probability P(T ≥ t)

T.DIST.RT(t, df)

TINV(p, df)

t-value for two-tailed probability p

T.INV.2T(p, df)

TPDF(t, df)

Probability density

T.DIST(t, df, FALSE)

CHIDIST(x2, df)

Upper-tail probability P(χ² ≥ x2)

CHISQ.DIST.RT(x2, df)

CHIINV(p, df)

χ² value for upper-tail probability p

CHISQ.INV.RT(p, df)

CHISQC(x, df)

Cumulative probability P(χ² ≤ x)

CHISQ.DIST(x, df, TRUE)

FDIST(f, df1, df2)

Upper-tail probability P(F ≥ f)

F.DIST.RT(f, df1, df2)

FINV(p, df1, df2)

F-value for upper-tail probability p

F.INV.RT(p, df1, df2)

FPDF(f, df1, df2)

Probability density

F.DIST(f, df1, df2, FALSE)

BINOMIAL(k, n, p)

P(X ≥ k) for n trials, probability p

1 - BINOM.DIST(k, n, p, TRUE) + BINOM.DIST(k, n, p, FALSE)

ERF(x)

Error function

ERF(x)

ERFC(x)

Complementary error function: 1 - ERF(x)

ERFC(x)

PROBIT(p)

Probit with offset: 5 + Φ⁻¹(p)

5 + NORM.S.INV(p)

GAUSS(mean, sd)

Random value from normal distribution

NORM.INV(RAND(), mean, sd)

RND(lower, upper)

Random value from uniform distribution

RAND()*(upper-lower)+lower

MEAN(Variable)

Arithmetic mean (broadcasts to all rows)

AVERAGE(range)

STDEV(Variable)

Sample standard deviation (broadcasts)

STDEV.S(range)

STDERR(Variable)

Standard error of mean (broadcasts)

STDEV.S(range)/SQRT(COUNT(range))

COUNT(Variable)

Count of numeric values

COUNT(range)

CENTER(Variable)

Center data (subtract mean)

value - AVERAGE(range)

STANDARDIZE(Variable)

Convert to z-scores

(value - AVERAGE(range))/STDEV.S(range)

COUNTA(Variable)

Count of non-blank values, including text

COUNTA(range)

RANK(Variable)

Rank of each value, ascending; ties averaged

RANK.AVG(value, range, 1)

ZSCORE(Variable)

Z-scores (same as STANDARDIZE)

STANDARDIZE(value, AVERAGE(range), STDEV.S(range))

MINIF(Variable, condition)

Minimum of values in rows that meet the condition

MINIFS(min_range, range, criteria)

MAXIF(Variable, condition)

Maximum of values in rows that meet the condition

MAXIFS(max_range, range, criteria)

SUMIF(Variable, condition)

Sum of values in rows that meet the condition (0 if none)

SUMIF(range, criteria, sum_range)

MEANIF(Variable, condition)

Mean of values in rows that meet the condition

AVERAGEIF(range, criteria, avg_range)

STDEVIF(Variable, condition)

Sample SD of values in rows that meet the condition

No direct equivalent

STDERRIF(Variable, condition)

Standard error of the mean of values in rows that meet the condition

No direct equivalent

COUNTIF(Variable, condition)

Count of numeric values in rows that meet the condition (0 if none)

COUNTIF(range, criteria)

COUNTAIF(Variable, condition)

Count of non-blank values, including text, in rows that meet the condition (0 if none)

COUNTIF(range, criteria)

OVER partition

Calculate separately within each group of rows that share a value

MEAN(E) OVER B

WHERE filter

Use only rows where the filter is true; all rows still get a result

COUNT(E) WHERE E >= 170

ORDER BY sort [ASC | DESC], ...

Order of rows within each group (ascending by default)

... ORDER BY C DESC

ROWS start end

Limit the window to rows around the current row

... ROWS 1 PRECEDING 1 FOLLOWING

N PRECEDING / UNBOUNDED PRECEDING

Start N rows before the current row, or at the first row of the group

... ROWS UNBOUNDED PRECEDING

N FOLLOWING / UNBOUNDED FOLLOWING

End N rows after the current row, or at the last row of the group

... ROWS 2 FOLLOWING

GAMMA(x)

Gamma function. For integers: Γ(n) = (n-1)!

GAMMA(x)

GAMMALN(x)

Natural log of gamma function

GAMMALN(x)

IGAMMA(shape, x)

Incomplete gamma function

GAMMA.DIST(x, shape, 1, TRUE)

IGAMMAC(shape, x)

Complementary incomplete gamma: 1 - IGAMMA

1 - GAMMA.DIST(x, shape, 1, TRUE)

PSI(x)

Digamma function (derivative of ln Γ)

No equivalent

BETA(a, b)

Beta function: B(a,b) = Γ(a)Γ(b)/Γ(a+b)

EXP(GAMMALN(a) + GAMMALN(b) - GAMMALN(a+b))

IBETA(a, b, x)

Incomplete beta function, 0 ≤ x ≤ 1

BETA.DIST(x, a, b, TRUE)

BESSELJ(n, x)

Bessel function first kind: Jₙ(x)

BESSELJ(x, n) ⚠️

BESSELY(n, x)

Bessel function second kind (Neumann): Yₙ(x)

BESSELY(x, n) ⚠️

BESSELI(n, x)

Modified Bessel first kind: Iₙ(x)

BESSELI(x, n) ⚠️

BESSELK(n, x)

Modified Bessel second kind (Macdonald): Kₙ(x)

BESSELK(x, n) ⚠️

HYPGEOMETRICM(a, b, x)

Confluent hypergeometric M (Kummer's M)

No equivalent

HYPGEOMETRICU(a, b, x)

Confluent hypergeometric U (Tricomi)

No equivalent

HYPGEOMETRICF(a, b, c, x)

Gaussian hypergeometric ₂F₁

No equivalent

IF(condition, if_true, if_false)

Conditional logic. String comparisons not case-sensitive

IF(condition, if_true, if_false)

AND(cond1, cond2, ...)

TRUE if all conditions true

AND(cond1, cond2, ...)

OR(cond1, cond2, ...)

TRUE if any condition true

OR(cond1, cond2, ...)

NOT(condition)

Logical negation

NOT(condition)

IS_DEFINED(x)

TRUE if value exists (not blank)

NOT(ISBLANK(x))

CONCATENATE(text1, text2, ...)

Join strings. Numbers auto-converted to text

CONCATENATE(text1, text2, ...)

PERC(x)

Convert percentage to fraction: x/100

x / 100