# operators¶

Adds two or more `Number` -s. The `add()` gear is automatically instantiated when a “+” operator is used on two interfaces.

`add`(a: Number, b: Number)
`add`(din: Tuple[Number, Number])

Add two `Number` -s together:

```a = drv(t=Uint[4], seq=[0, 1, 2])
b = drv(t=Uint[4], seq=[0, 1, 2])

(a + b) | check(ref=[0, 2, 4])
```

Divide `Number` -s . The `div()` gear is automatically instantiated when a “//” operator is used on two interfaces.

`div`(a: Number, b: Number)
`div`(din: Tuple[Number, Number])

Divide a `Number` by a constant:

```a = drv(t=Uint[4], seq=[2, 5, 9])

(a // 3) | check(ref=[0, 1, 3])
```

Test whether the data from two interfaces is equal. The `eq()` gear is automatically instantiated when a “==” operator is used on two interfaces.

`eq`(a, b) → Bool
`eq`(din: Tuple[Any, Any]) → Bool

Compare if two values are equal:

```a = drv(t=Uint[4], seq=[1, 2, 3, 4, 5])
b = drv(t=Uint[4], seq=[4, 4, 4, 4, 4])

(a == b) | check(ref=[False, False, False, True, False])
```

Test whether a `Number` from one interface is greater then a `Number` from the other. The `gt()` gear is automatically instantiated when a “>” operator is used on two interfaces.

`gt`(a: Number, b: Number)
`gt`(din: Tuple[Number, Number])

Compare if one value is greater than the other:

```a = drv(t=Uint[4], seq=[1, 2, 3, 4, 5])
b = drv(t=Uint[4], seq=[4, 4, 4, 4, 4])

(a > b) | check(ref=[False, False, False, False, True])
```

Test whether a `Number` from one interface is greater or equal to the `Number` from the other. The `ge()` gear is automatically instantiated when a “>=” operator is used on two interfaces.

`ge`(a: Number, b: Number)
`ge`(din: Tuple[Number, Number])

Compare if one value is greater or equal to the other:

```a = drv(t=Uint[4], seq=[1, 2, 3, 4, 5])
b = drv(t=Uint[4], seq=[4, 4, 4, 4, 4])

(a >= b) | check(ref=[False, False, False, True, True])
```

Adds two or more `Number` data received from the input interfaces and outputs the result. The `add()` gear is automatically instantiated when a “+” operator is used on two interfaces.

`add`(a: Number, b: Number)
`add`(din: Tuple[Number, Number])

```a = drv(t=Uint[4], seq=[0, 1, 2])
b = drv(t=Uint[4], seq=[0, 1, 2])

(a + b) | check(ref=[0, 2, 4])
```

Bitwise inverts data. The `invert()` gear is automatically instantiated when a “~” operator is used on an interface.

`invert`(a)

Bitwise inverts a number:

```a = drv(t=Uint[8], seq=[0x01, 0x0f, 0xff])

(~a) | check(ref=[0xfe, 0xf0, 0x00])
```

Test whether a `Number` from one interface is less then a `Number` from the other. The `lt()` gear is automatically instantiated when a “<” operator is used on two interfaces.

`lt`(a: Number, b: Number)
`lt`(din: Tuple[Number, Number])

Compare if one value is greater than the other:

```a = drv(t=Uint[4], seq=[1, 2, 3, 4, 5])
b = drv(t=Uint[4], seq=[4, 4, 4, 4, 4])

(a < b) | check(ref=[True, True, True, False, False])
```

Test whether a `Number` from one interface is less than or equal to a `Number` from the other. The `le()` lear is automatically instantiated when a “<=” operator is used on two interfaces.

`le`(a: Number, b: Number)
`le`(din: Tuple[Number, Number])

Compare if one value is less than or equal to the other:

```a = drv(t=Uint[4], seq=[1, 2, 3, 4, 5])
b = drv(t=Uint[4], seq=[4, 4, 4, 4, 4])

(a <= b) | check(ref=[True, True, True, True, False])
```

Performs integer modulo operation. The `mod()` gear is automatically instantiated when a “%” operator is used on two interfaces.

`mod`(a: Integer, b: Integer)
`mod`(din: Tuple[Integer, Integer])

Performs integer modulo operation:

```a = drv(t=Uint[4], seq=[0, 2, 4, 6, 8])

(a % 3) | check(ref=[0, 2, 1, 0, 2])
```

Multiplies two `Number` data received from the input interfaces and outputs the result. The `mul()` gear is automatically instantiated when a “*” operator is used on two interfaces.

`mul`(a: Number, b: Number)
`mul`(din: Tuple[Number, Number])

```a = drv(t=Uint[4], seq=[0, 1, 2])
b = drv(t=Uint[4], seq=[0, 1, 2])

(a * b) | check(ref=[0, 1, 4])
```

Test whether the data from two interfaces is not equal. The `ne()` gear is automatically instantiated when a “!=” operator is used on two interfaces.

`ne`(a, b) → Bool
`ne`(din: Tuple[Any, Any]) → Bool

Compare if two values are not equal:

```a = drv(t=Uint[4], seq=[1, 2, 3, 4, 5])
b = drv(t=Uint[4], seq=[4, 4, 4, 4, 4])

(a != b) | check(ref=[True, True, True, False, True])
```

Negates data. The `neg()` gear is automatically instantiated when unary “-” operator is used on an interface.

`neg`(a: Number)

Negates a number:

```a = drv(t=Uint[4], seq=[0, 7, 15])

(-a) | check(ref=[0, -7, -15])
```