This is an old version, view current version.

3.5 Logical Functions

Like C++, BUGS, and R, Stan uses 0 to encode false, and 1 to encode true. Stan supports the usual boolean comparison operations and boolean operators. These all have the same syntax and precedence as in C++; for the full list of operators and precedences, see the reference manual.

3.5.1 Comparison Operators

All comparison operators return boolean values, either 0 or 1. Each operator has two signatures, one for integer comparisons and one for floating-point comparisons. Comparing an integer and real value is carried out by first promoting the integer value.

int operator<(int x, int y)

int operator<(real x, real y)
Return 1 if x is less than y and 0 otherwise. \[ \text{operator<}(x,y) = \begin{cases} 1 & \text{if $x < y$} \\ 0 & \text{otherwise} \end{cases} \]

int operator<=(int x, int y)

int operator<=(real x, real y)
Return 1 if x is less than or equal y and 0 otherwise. \[ \text{operator<=}(x,y) = \begin{cases} 1 & \text{if $x \leq y$} \\ 0 & \text{otherwise} \end{cases} \]

int operator>(int x, int y)

int operator>(real x, real y)
Return 1 if x is greater than y and 0 otherwise. \[ \text{operator>} = \begin{cases} 1 & \text{if $x > y$} \\ 0 & \text{otherwise} \end{cases} \]

int operator>=(int x, int y)

int operator>=(real x, real y)
Return 1 if x is greater than or equal to y and 0 otherwise. \[ \text{operator>=} = \begin{cases} 1 & \text{if $x \geq y$} \\ 0 & \text{otherwise} \end{cases} \]

int operator==(int x, int y)

int operator==(real x, real y)
Return 1 if x is equal to y and 0 otherwise. \[ \text{operator==}(x,y) = \begin{cases} 1 & \text{if $x = y$} \\ 0 & \text{otherwise} \end{cases} \]

int operator!=(int x, int y)

int operator!=(real x, real y)
Return 1 if x is not equal to y and 0 otherwise. \[ \text{operator!=}(x,y) = \begin{cases} 1 & \text{if $x \neq y$} \\ 0 & \text{otherwise} \end{cases} \]

3.5.2 Boolean Operators

Boolean operators return either 0 for false or 1 for true. Inputs may be any real or integer values, with non-zero values being treated as true and zero values treated as false. These operators have the usual precedences, with negation (not) binding the most tightly, conjunction the next and disjunction the weakest; all of the operators bind more tightly than the comparisons. Thus an expression such as !a && b is interpreted as (!a) && b, and a < b || c >= d && e != f as (a < b) || (((c >= d) && (e != f))).

int operator!(int x)

int operator!(real x)
Return 1 if x is zero and 0 otherwise. \[ \text{operator!}(x) = \begin{cases} 0 & \text{if $x \neq 0$} \\ 1 & \text{if $x = 0$} \end{cases} \]

int operator&&(int x, int y)

int operator&&(real x, real y)
Return 1 if x is unequal to 0 and y is unequal to 0. \[ \mathrm{operator\&\&}(x,y) = \begin{cases} 1 & \text{if $x \neq 0$} \text{ and } y \neq 0\\ 0 & \text{otherwise} \end{cases} \]

int operator||(int x, int y)

int operator||(real x, real y)
Return 1 if x is unequal to 0 or y is unequal to 0. \[ \text{operator||}(x,y) = \begin{cases} 1 & \text{if $x \neq 0$} \textrm{ or } y \neq 0\\ 0 & \text{otherwise} \end{cases} \]

3.5.2.1 Boolean Operator Short Circuiting

Like in C++, the boolean operators && and || and are implemented to short circuit directly to a return value after evaluating the first argument if it is sufficient to resolve the result. In evaluating a || b, if a evaluates to a value other than zero, the expression returns the value 1 without evaluating the expression b. Similarly, evaluating a && b first evaluates a, and if the result is zero, returns 0 without evaluating b.

3.5.3 Logical Functions

The logical functions introduce conditional behavior functionally and are primarily provided for compatibility with BUGS and JAGS.

real step(real x)
Return 1 if x is positive and 0 otherwise. \[ \text{step}(x) = \begin{cases} 0 & \text{if } x < 0 \\ 1 & \text{otherwise} \end{cases} \] Warning: int_step(0) and int_step(NaN) return 0 whereas step(0) and step(NaN) return 1.

The step function is often used in BUGS to perform conditional operations. For instance, step(a-b) evaluates to 1 if a is greater than b and evaluates to 0 otherwise. step is a step-like functions; see the warning in section step functions applied to expressions dependent on parameters.

int is_inf(real x)
Return 1 if x is infinite (positive or negative) and 0 otherwise.

int is_nan(real x)
Return 1 if x is NaN and 0 otherwise.

Care must be taken because both of these indicator functions are step-like and thus can cause discontinuities in gradients when applied to parameters; see section step-like functions for details.