Arx does not differ much from other mainstream languages in the way it
deals with expressions and operators. Parentheses `(`

and `)`

can
be used to override default precedence when grouping operands
(“multiplication binds stronger than addition”, etc.).

The operators supported by Arx are listed on this page, grouped by the data types of their operands or results. Next to the operators mentioned here, function calls can also be part of an expression.

Arithmetic operators operate on data types that
represent numeric data, such as integers, reals or fixed-point
numbers. The following *binary infix* operators are supported:

Operator | Explanation |
---|---|

`+` | addition |

`-` | subtraction |

`*` | multiplication |

`max` | maximum |

`min` | minimum |

`/` | division |

`mod` | modulo |

`>>` | arithmetic shift right |

`<<` | arithmetic shift left |

**Remark**: *Division and is only supported for integers and reals;
modulo only for integers. Arx does not support these operators for
VHDL generation. The shift operators are only allowed for fixed-point
data types.*

Arx knows two *unary* operators:

Operator | Explanation |
---|---|

`+` | plus |

`-` | minus |

Arx has the following built-in functions:

Function | Explanation |
---|---|

`abs` | absolute value |

`log2` | base-2 logarithm |

`pow2` | base-2 exponentiation |

`ceil` | ceiling |

`floor` | floor |

The functions `log2`

, `pow2`

, `floor`

and `ceil`

cannot be
used to specify computations in the hardware. They are meant for the
specification of sizes of vectors and arrays expressed in generics.
They can also be used to express the value of constants in terms of
generics.

The example below illustrates several of the functions just mentioned.

- multi_max.arx
component top word_length : generic integer = 8 memory_depth: generic integer = 10 T_IO : generic type = bitvector(word_length) data_in : in T_IO data_out : out T_IO type T_num : signed(word_length) constant addr_bits: integer = ceil(log2(memory_depth)) register storage: array [memory_depth] of T_num = 0 addr_counter: unsigned(addr_bits) = memory_depth - 1 begin if addr_counter == 0 addr_counter = memory_depth - 1 else addr_counter = addr_counter - 1 end storage[addr_counter] = reinterpret(T_num, data_in) max storage[addr_counter] data_out = storage[addr_counter] end

Logic operators operate on bits, bitvectors and booleans. The following operators exist:

Operator | Explanation |
---|---|

`and` | bitwise AND |

`or` | bitwise OR |

`xor` | bitwise exclusive OR |

`not` | bitwise NOT |

All operators are binary infix, except for `not`

which is unary
prefix. The line below shows an expression with logic operators:

c = (not b) xor a

Relational operators operate on numeric values and return a boolean. These are the relational operators supported by Arx:

Operator | Explanation |
---|---|

`<` | less than |

`>` | more than |

`==` | equal |

`!=` | not equal |

`>=` | more than or equal |

`<=` | less than or equal |