Logical functions

Overview

Use this category when you need conditions, comparisons, and branching logic in formulas.

These functions help you build boolean-style expressions, typically represented as 1 or 0, and use them to select values, create flags, or diagnose unexpected results.

Start here if…

You are looking up a logical function by name, for example IF, EQ, GT, AND, TRUE, FALSE, or IS_NA.
You want to compare similar logical functions and understand when to use which one.
You need function-specific notes, limits, or troubleshooting.

Not here if…

You want comparison operators and boolean keywords as operators, for example >, =, AND, OR, NOT → see Comparisons & boolean operators
You want numeric transformations such as ROUND, ABS or MIN/MAX→ see Math & numeric

Mental model

Logical functions usually return 1 or 0 across the same dimensionality as their inputs
Conditions are most commonly used inside IF(...) to select between two results
Missing values can affect conditions; use IS_NA(...) when results look unexpectedly empty or incomplete

Common patterns

Apply a business rule
IF('Margin' < 0, 0, 'Margin')
Use when you want to cap, floor, or branch values based on a condition.

Create a threshold flag
GT('Revenue', 100000)
Use when you want to mark where values exceed a threshold.

Compare two nodes for equality
EQ('Actuals', 'Plan')
Use when you want to create match or mismatch flags for validation.

Combine multiple conditions
AND(GT('Node', 0), LT('Node', 10))
Use when you want to build between-rules or multi-part checks.

Invert a condition
NOT(EQ('Status', 1))
Use when you want the opposite of an existing rule.

Check for undefined values
IS_NA('Node')
Use when you want to identify where values are undefined and may affect downstream comparisons.

Functions in this category

Branching

Function	Description
IF	Returns one result when a condition is true and another result when it is false.

Function equivalents of operators

Function	Description
EQ (=)	Returns 1 where matching values are equal; otherwise returns 0.
NEQ (!=)	Returns 1 where matching values are not equal; otherwise returns 0.
GT (>)	Returns 1 where the first input is greater than the second; otherwise returns 0.
GTE (>=)	Returns 1 where the first input is greater than or equal to the second; otherwise returns 0.
LT (<)	Returns 1 where the first input is less than the second; otherwise returns 0.
LTE (<=)	Returns 1 where the first input is less than or equal to the second; otherwise returns 0.
AND (&&)	Returns 1 when both inputs are true; otherwise returns 0.
OR (\|\|)	Returns 1 when at least one input is true; otherwise returns 0.
NOT	Inverts logical values so non-zero becomes 0 and zero becomes 1.
XOR	Returns 1 when exactly one input is true; otherwise returns 0.

Defined / undefined helpers

Function	Description
TRUE	Returns 1 for every defined value in the input node.
FALSE	Returns 0 for every defined value in the input node.
IS_NA	Returns 1 where values are undefined in the input node’s dimensionality; otherwise returns 0.

Choosing between similar functions

IF vs flags (EQ/GT/LT/…)

Use EQ, GT, LT, and similar functions when you need a 1/0 flag for validation, filtering, or diagnostics
Use IF when you want to return one of two result values

EQ vs NEQ

Use EQ to mark matches.
Use NEQ to mark mismatches.

GT/GTE vs LT/LTE

Use GT or GTE for above-threshold rules.
Use LT or LTE for below-threshold rules.

AND/OR vs XOR

Use AND when all conditions must hold.
Use OR when any condition may hold.
Use XOR when exactly one condition should hold.

IS_NA vs FALSE/TRUE

Use IS_NA to detect undefined values.
Use TRUE or FALSE when you want a defined 1 or 0 result across the defined intersections of a node

Pitfalls & troubleshooting

IF(…) result looks incomplete: check whether the condition is undefined for some intersections; use IS_NA to spot where inputs are missing.
Cube size risk: IS_NA expands to a fully expanded cube and can hit maximum cube size.
Conditions look wrong: check both operands at the same intersection in Data preview; the root cause is often upstream values, not the comparison itself.
Multi-part logic is hard to debug: split logic into helper nodes, then combine with AND or OR.
Between logic: make it explicit with AND(GTE(...), LTE(...)) rather than relying on a single comparison.
Missing vs zero confusion: review Troubleshooting guide when results look unexpectedly false or empty.

Related sections

Comparisons & boolean operators: operator syntax for conditions
Math & numeric: use MIN/MAX for simple caps and floors
Troubleshooting guide: missing values and unexpected results
Function catalog: full signatures, parameters, and examples