Operations
Table of Supported Operations
Operation | Description | Requirements |
---|---|---|
+ | Adds two private input types together | Types must be private input |
- | Subtracts two private input types together | Types must be private input |
* | Multiplies two private input types together | Types must be private input |
/ | Divides two private input types together | Types must be private input |
^ | XOR two private input types together | Types must be integer |
& | AND two private input types together | Types must be integer |
| | OR two private input types together | Types must be integer |
<< | Left shift an integer by another integer amount | Types must be integer, shift must be u8 |
>> | Right shift an integer by another integer amount | Types must be integer, shift must be u8 |
! | Bitwise not of a value | Type must be integer or boolean |
< | returns a bool if one value is less than the other | Upper bound must have a known bit size |
<= | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
> | returns a bool if one value is more than the other | Upper bound must have a known bit size |
>= | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
== | returns a bool if one value is equal to the other | Both types must not be constants |
!= | returns a bool if one value is not equal to the other | Both types must not be constants |
Predicate Operators
<,<=, !=, == , >, >=
are known as predicate/comparison operations because they compare two values.
This differs from the operations such as +
where the operands are used in computation.
Bitwise Operations Example
fn main(x : Field) {
let y = x as u32;
let z = y & y;
}
z
is implicitly constrained to be the result of y & y
. The &
operand is used to denote bitwise
&
.
x & x
would not compile asx
is aField
and not an integer type.
Logical Operators
Noir has no support for the logical operators ||
and &&
. This is because encoding the
short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
use the bitwise operators |
and &
which operate identically for booleans, just without the
short-circuiting.
let my_val = 5;
let mut flag = 1;
if (my_val > 6) | (my_val == 0) {
flag = 0;
}
assert(flag == 1);
if (my_val != 10) & (my_val < 50) {
flag = 0;
}
assert(flag == 0);
Shorthand operators
Noir shorthand operators for most of the above operators, namely +=, -=, *=, /=, %=, &=, |=, ^=, <<=
, and >>=
. These allow for more concise syntax. For example:
let mut i = 0;
i = i + 1;
could be written as:
let mut i = 0;
i += 1;