Go to the previous, next section.

## Operators

These operators can be used to construct expressions by explicitly calling the operator functions See section Constructing Expressions Using Explicit Function Calls.

```enum unary_op { uop_minus,                     // -a

uop_not,                       // !a

uop_lnot,                      // ~a

uop_abs };                     // abs(a) or |a|

enum <binary_op { bop_mul,                       // a * b

bop_div,                       // a / b

bop_mod,                       // a % b

bop_sub,                       // a - b

bop_lshift,                    // a << b

bop_rshift,                    // a >> b

bop_less,                      // (a < b)

bop_gt,                        // (a > b)

bop_leq,                       // (a <= b)

bop_geq,                       // (a >= b)

bop_eq,                        // (a == b)

bop_neq,                       // (a != b)

bop_and,                       // a & b

bop_xor,                       // a ^ b

bop_or,                        // a | b

bop_land,                      // a && b

bop_lor,                       // a || b

bop_divfloor,             // (int)floor((double)a/(double)b)

bop_divceil,              // (int)ceil((double)a/(double)b)

bop_min,                       // min(a, b)
bop_max };                     // max(a, b)

enum assign_op { aop_eq,                        // a = b;

aop_mod,                       // a = a % b;

aop_add,                       // a = a + b;

aop_sub,                       // a = a - b;

aop_mul,                       // a = a * b;

aop_div,                       // a = a / b;

aop_rshift,                    // a = a >> b;

aop_lshift,                    // a = a << b;

aop_and,                       // a = a & b;

aop_xor,                       // a = a ^ b;

aop_or };                      // a = a | b;

```

Go to the previous, next section.