Expressions

The definition of the area constant, in the example above, uses an expression. We now define more precisely what types of expression are supported by PRISM. Expressions can contain literal values (12, 3.141592, true, false, etc.), identifiers (corresponding to variables, constants, etc.) and operators from the following list:

*, / (multiplication, division)
+, - (addition, subtraction)
<, <=, >=, > , =, != (relational operators)
! (not)
& (and)
| (or)
? (condition evaluation: condition ? a : b means "if condition is true then a else b")

All of these operators except ? are left associative (i.e. they are evaluated from left to right). The precedence of the operators is as found in the list above, most strongly binding operators first. Operators on the same line (e.g. + and -) are of equal precedence.

The notation for expressions is hence essentially equivalent to that of C/C++ or Java. One notable exception to this is that the division operator / always performs floating point, not integer, division, i.e. the result of 22/7 is 3.142857... not 3. All expressions must evaluate correctly in terms of type (integer, double or Boolean).

Ranges

A shorthand notation for describing ranges is also supported. For example:

x = 1..5,7,10..13

is equivalent to:

(x>=1 & x<=5) | (x=7) | (x>=10 & x<=13)

All the elements of such an expression (x, 1, 5, etc.) can themselves be expressions. Replacing the = with an != is equivalent to negating the whole expression. So, for example:

x != b-1..b+1,b+6..b+8

is equivalent to:

!((x>=b-1 & x<=b+1) | (x>=b+6 & x<=b+8))

Built-in Functions

Expressions can make use of several built-in functions, which are accessed via the func keyword. Currently, the supported functions are: min and max, which select the minimum and maximum value, respectively, of two or more numbers; floor and ceil, which round down and up, respectively, to the nearest integer; pow which raises one number to the power of another; and mod for integer modulo operations. The format is:

func(name, arg1, arg2, ...)

Examples of their usage are:

func(min, x+1, x_max)

func(max, a,b,c)

func(floor, 13.5)

func(ceil, 13.5)

func(pow, 2, 8)

func(pow, 9.0, 0.5)

func(mod, 1977, 100)

For compatability with older versions of PRISM, min, max,floor and ceil can still be used directly, e.g. max(a,b,c).

Use of Expressions

Expressions can be used in a wide range of places in a PRISM language description, e.g.:

constant definitions
lower/upper bounds and initial values for variables
guards
probabilities/rates
updates

This allows, for example, the probability in a command to be dependent on the current state:

[] (x=1..10) -> x/10 : (x'=max(1,x-1)) + 1-x/10 : (x'=min(10,x+1))

Expressions

PRISM Manual