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]) Adds two numbers 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])
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]) Adds two numbers together:
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])