Scalar operations

Operators

Arithmetic operators

  • -a
  • a + b
  • a - b
  • a * b
  • a / b
  • a // b
  • a % b
  • a ** b

Note

The % operator in Taichi follows the Python style instead of C style, e.g.:

# no matter Taichi-scope or Python-scope:
print(2 % 3)   # 2
print(-2 % 3)  # 1

For C-style mod, please use ti.raw_mod:

print(ti.raw_mod(2, 3))   # 2
print(ti.raw_mod(-2, 3))  # -2

Note

Python 3 distinguishes / (true division) and // (floor division). For example, 1.0 / 2.0 = 0.5, 1 / 2 = 0.5, 1 // 2 = 0, 4.2 // 2 = 2. And Taichi follows the same design:

  • true divisions on integral types will first cast their operands to the default float point type.
  • floor divisions on float-point types will first cast their operands to the default integer type.

To avoid such implicit casting, you can manually cast your operands to desired types, using ti.cast. See Default precisions for more details on default numerical types.

Logic operators

  • ~a
  • a == b
  • a != b
  • a > b
  • a < b
  • a >= b
  • a <= b
  • not a
  • a or b
  • a and b
  • a if cond else b

Bitwise operators

  • a & b
  • a ^ b
  • a | b

Functions

Trigonometric functions

ti.sin(x)
ti.cos(x)
ti.tan(x)
ti.asin(x)
ti.acos(x)
ti.atan2(y, x)
ti.tanh(x)

Other arithmetic functions

ti.sqrt(x)
ti.rsqrt(x)

A fast version for 1 / ti.sqrt(x).

ti.exp(x)
ti.log(x)
ti.floor(x)
ti.ceil(x)

Casting types

ti.cast(x, dtype)

See Type system for more details.

int(x)

A shortcut for ti.cast(x, int).

float(x)

A shortcut for ti.cast(x, float).

Builtin-alike functions

abs(x)
max(x, y, ...)
min(x, y, ...)
pow(x, y)

Same as x ** y.

Random number generator

ti.random(dtype = float)

Generates a uniform random float or integer number.

ti.randn(dtype = None)

Generates a random floating point number from the standard normal distribution.

Note

On CPU and CUDA backends, use the random_seed argument in ti.init() to specify the integer seed for random number generation. The random seed is 0 by default.

Element-wise arithmetics for vectors and matrices

When these scalar functions are applied on Matrices and Vectors, they are applied in an element-wise manner. For example:

B = ti.Matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
C = ti.Matrix([[3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])

A = ti.sin(B)
# is equivalent to
for i in ti.static(range(2)):
    for j in ti.static(range(3)):
        A[i, j] = ti.sin(B[i, j])

A = B ** 2
# is equivalent to
for i in ti.static(range(2)):
    for j in ti.static(range(3)):
        A[i, j] = B[i, j] ** 2

A = B ** C
# is equivalent to
for i in ti.static(range(2)):
    for j in ti.static(range(3)):
        A[i, j] = B[i, j] ** C[i, j]

A += 2
# is equivalent to
for i in ti.static(range(2)):
    for j in ti.static(range(3)):
        A[i, j] += 2

A += B
# is equivalent to
for i in ti.static(range(2)):
    for j in ti.static(range(3)):
        A[i, j] += B[i, j]