# Operators

Here is a list of operators that can be used in expressions in EasyMorph.

#### Basic operators

Operator | Description | Result |
---|---|---|

+ | Addition | Number |

- | Subtraction | Number |

* | Multiplication | Number |

/ | Division | Number |

& | Text concatenation | Text |

> | Greater than | Boolean |

>= | Greater than or equal | Boolean |

< | Less than | Boolean |

<= | Less than or equal | Boolean |

= | Equal | Boolean |

!= | Not equal | Boolean |

<> | Not equal | Boolean |

and | Logical AND | Boolean |

or | Logical OR | Boolean |

not | Logical NOT | Boolean |

Examples of operators in expressions:

1 + 2 (10 + 5 ) * 3 'Easy' & 'Morph' [Amount] > 1000 ([Amount] > 1000 and [Quantity] > 1) or [Quantity]>10

#### The IF..THEN..ELSE operator

This operator can be used to perform conditional calculations. It has the following syntax:

IF *condition* THEN *expression* ELSE *expression*

A shorter form where the ELSE expression is omitted and always returns an empty value is also possible:

IF *condition* THEN *expression*

Note that unlike the if() function, in the IF operator the "then" expression is only evaluated when the condition is TRUE. The "else" expression in this case is not evaluated (i.e. ignored). Vice versa, if the condition is FALSE, then the "then" expression is ignored, and only the "else" expression is evaluated.

Examples:

IF [Amount] > 1000 THEN 'Large order' ELSE 'Small order'

IF [Year] = year(today()) THEN [Amount] ELSE 0

IF [Qty] = 0 THEN 0 ELSE [Amount] / [Qty] // Doesn't fail when [Qty] = 0

#### The LET operator

The LET operator allows simplifying expressions by declaring repetitive parts as local constants which can later be used instead of the repetitive parts. The operator has the following syntax:

LET *local_constant* = *expression*

Once a local constant is declared, it can be used in the expression(s) that follow the declaration. Example:

LET d = day(today()) IF d=1 THEN 'First day' ELSE 'Day: ' & d

#### The ASSUME operator

The operator allows creating guarding conditions that must evaluate to TRUE before the expression is evaluated. ASSUME can be used to ensure data quality and integrity right in expressions. The operator has the following syntax:

ASSUME *expression*

ASSUME *expression* OTHERWISE FAIL *expression*

Examples:

ASSUME [Tax]>=0 [Amount] + [Tax]

In the expression above, the final statement will only be calculated if [Tax] is not negative. Otherwise, project execution will be aborted with a generic error.

It is also possible to specify a custom error message as follows:

ASSUME [Tax]>=0 OTHERWISE FAIL "Tax must not be negative"

The OTHERWISE keyword is optional. It can be safely omitted:

ASSUME [Tax]>=0 FAIL "Tax must not be negative"

ASSUME can be used together with the other operators. For instance:

ASSUME isnumber({Tax Rate}) OTHERWISE FAIL ("Invalid tax rate: " & {Tax Rate}) LET tax = [Tax base] * {Tax Rate} - [Tax credit] ASSUME tax >= 0 OTHERWISE FAIL "Tax must not be negative" [Amount] + tax