gstaichi 0.1.23.dev0__cp310-cp310-win_amd64.whl → 1.0.1__cp310-cp310-win_amd64.whl

{taichi → gstaichi}/lang/ops.py

@@ -7,25 +7,30 @@ from typing import Union
 
 import numpy as np
 
-from taichi._lib import core as _ti_core
-from taichi.lang import expr, impl
-from taichi.lang.exception import TaichiSyntaxError
-from taichi.lang.field import Field
-from taichi.lang.util import cook_dtype, is_matrix_class, is_taichi_class, taichi_scope
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import expr, impl
+from gstaichi.lang.exception import GsTaichiSyntaxError
+from gstaichi.lang.field import Field
+from gstaichi.lang.util import (
+    cook_dtype,
+    gstaichi_scope,
+    is_gstaichi_class,
+    is_matrix_class,
+)
 
 
 def stack_info():
     return impl.get_runtime().get_current_src_info()
 
 
-def is_taichi_expr(a):
+def is_gstaichi_expr(a):
     return isinstance(a, expr.Expr)
 
 
 def wrap_if_not_expr(a):
     return (
         expr.Expr(a, dbg_info=_ti_core.DebugInfo(impl.get_runtime().get_current_src_info()))
-        if not is_taichi_expr(a)
+        if not is_gstaichi_expr(a)
         else a
     )
 
@@ -41,8 +46,8 @@ def writeback_binary(foo):
     def wrapped(a, b):
         if isinstance(a, Field) or isinstance(b, Field):
             return NotImplemented
-        if not (is_taichi_expr(a) and a.ptr.is_lvalue()):
-            raise TaichiSyntaxError(f"cannot use a non-writable target as the first operand of '{foo.__name__}'")
+        if not (is_gstaichi_expr(a) and a.ptr.is_lvalue()):
+            raise GsTaichiSyntaxError(f"cannot use a non-writable target as the first operand of '{foo.__name__}'")
         return foo(a, wrap_if_not_expr(b))
 
     return wrapped
@@ -50,13 +55,13 @@ def writeback_binary(foo):
 
 def cast(obj, dtype):
     """Copy and cast a scalar or a matrix to a specified data type.
-    Must be called in Taichi scope.
+    Must be called in GsTaichi scope.
 
     Args:
-        obj (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        obj (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
-        dtype (:mod:`~taichi.types.primitive_types`): A primitive type defined in :mod:`~taichi.types.primitive_types`.
+        dtype (:mod:`~gstaichi.types.primitive_types`): A primitive type defined in :mod:`~gstaichi.types.primitive_types`.
 
     Returns:
         A copy of `obj`, casted to the specified data type `dtype`.
@@ -73,7 +78,7 @@ def cast(obj, dtype):
         [0.0, 1.0, 2.0]
     """
     dtype = cook_dtype(dtype)
-    if is_taichi_class(obj):
+    if is_gstaichi_class(obj):
         # TODO: unify with element_wise_unary
         return obj.cast(dtype)
     return expr.Expr(_ti_core.value_cast(expr.Expr(obj).ptr, dtype))
@@ -81,14 +86,14 @@ def cast(obj, dtype):
 
 def bit_cast(obj, dtype):
     """Copy and cast a scalar to a specified data type with its underlying
-    bits preserved. Must be called in taichi scope.
+    bits preserved. Must be called in gstaichi scope.
 
     This function is equivalent to `reinterpret_cast` in C++.
 
     Args:
-        obj (:mod:`~taichi.types.primitive_types`): Input scalar.
+        obj (:mod:`~gstaichi.types.primitive_types`): Input scalar.
 
-        dtype (:mod:`~taichi.types.primitive_types`): Target data type, must have \
+        dtype (:mod:`~gstaichi.types.primitive_types`): Target data type, must have \
             the same precision bits as the input (hence `f32` -> `f64` is not allowed).
 
     Returns:
@@ -106,44 +111,44 @@ def bit_cast(obj, dtype):
         >>>     print(z)  # 3.14
     """
     dtype = cook_dtype(dtype)
-    if is_taichi_class(obj):
-        raise ValueError("Cannot apply bit_cast on Taichi classes")
+    if is_gstaichi_class(obj):
+        raise ValueError("Cannot apply bit_cast on GsTaichi classes")
     else:
         return expr.Expr(_ti_core.bits_cast(expr.Expr(obj).ptr, dtype))
 
 
-def _unary_operation(taichi_op, python_op, a):
+def _unary_operation(gstaichi_op, python_op, a):
     if isinstance(a, Field):
         return NotImplemented
-    if is_taichi_expr(a):
-        return expr.Expr(taichi_op(a.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
-    from taichi.lang.matrix import Matrix  # pylint: disable-msg=C0415
+    if is_gstaichi_expr(a):
+        return expr.Expr(gstaichi_op(a.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
+    from gstaichi.lang.matrix import Matrix  # pylint: disable-msg=C0415
 
     if isinstance(a, Matrix):
         return Matrix(python_op(a.to_numpy()))
     return python_op(a)
 
 
-def _binary_operation(taichi_op, python_op, a, b):
+def _binary_operation(gstaichi_op, python_op, a, b):
     if isinstance(a, Field) or isinstance(b, Field):
         return NotImplemented
-    if is_taichi_expr(a) or is_taichi_expr(b):
+    if is_gstaichi_expr(a) or is_gstaichi_expr(b):
         a, b = wrap_if_not_expr(a), wrap_if_not_expr(b)
-        return expr.Expr(taichi_op(a.ptr, b.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
-    from taichi.lang.matrix import Matrix  # pylint: disable-msg=C0415
+        return expr.Expr(gstaichi_op(a.ptr, b.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
+    from gstaichi.lang.matrix import Matrix  # pylint: disable-msg=C0415
 
     if isinstance(a, Matrix) or isinstance(b, Matrix):
         return Matrix(python_op(_read_matrix_or_scalar(a), _read_matrix_or_scalar(b)))
     return python_op(a, b)
 
 
-def _ternary_operation(taichi_op, python_op, a, b, c):
+def _ternary_operation(gstaichi_op, python_op, a, b, c):
     if isinstance(a, Field) or isinstance(b, Field) or isinstance(c, Field):
         return NotImplemented
-    if is_taichi_expr(a) or is_taichi_expr(b) or is_taichi_expr(c):
+    if is_gstaichi_expr(a) or is_gstaichi_expr(b) or is_gstaichi_expr(c):
         a, b, c = wrap_if_not_expr(a), wrap_if_not_expr(b), wrap_if_not_expr(c)
-        return expr.Expr(taichi_op(a.ptr, b.ptr, c.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
-    from taichi.lang.matrix import Matrix  # pylint: disable-msg=C0415
+        return expr.Expr(gstaichi_op(a.ptr, b.ptr, c.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
+    from gstaichi.lang.matrix import Matrix  # pylint: disable-msg=C0415
 
     if isinstance(a, Matrix) or isinstance(b, Matrix) or isinstance(c, Matrix):
         return Matrix(
@@ -160,7 +165,7 @@ def neg(x):
     """Numerical negative, element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
     Returns:
@@ -179,7 +184,7 @@ def sin(x):
     """Trigonometric sine, element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Angle, in radians.
 
     Returns:
@@ -199,7 +204,7 @@ def cos(x):
     """Trigonometric cosine, element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.type.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.type.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Angle, in radians.
 
     Returns:
@@ -221,10 +226,10 @@ def asin(x):
     The inverse of `sin` so that, if `y = sin(x)`, then `x = asin(y)`.
 
     For input `x` not in the domain `[-1, 1]`, this function returns `nan` if \
-        it's called in taichi scope, or raises exception if it's called in python scope.
+        it's called in gstaichi scope, or raises exception if it's called in python scope.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             A scalar or a matrix with elements in [-1, 1].
 
     Returns:
@@ -246,10 +251,10 @@ def acos(x):
     The inverse of `cos` so that, if `y = cos(x)`, then `x = acos(y)`.
 
     For input `x` not in the domain `[-1, 1]`, this function returns `nan` if \
-        it's called in taichi scope, or raises exception if it's called in python scope.
+        it's called in gstaichi scope, or raises exception if it's called in python scope.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             A scalar or a matrix with elements in [-1, 1].
 
     Returns:
@@ -270,7 +275,7 @@ def sqrt(x):
     element wise. If `x < 0` an exception is raised.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The scalar or matrix whose square-roots are required.
 
     Returns:
@@ -290,7 +295,7 @@ def rsqrt(x):
     """The reciprocal of the square root function.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             A scalar or a matrix.
 
     Returns:
@@ -311,10 +316,10 @@ def round(x, dtype=None):  # pylint: disable=redefined-builtin
     """Round to the nearest integer, element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             A scalar or a matrix.
 
-        dtype: (:mod:`~taichi.types.primitive_types`): the returned type, default to `None`. If \
+        dtype: (:mod:`~gstaichi.types.primitive_types`): the returned type, default to `None`. If \
             set to `None` the retuned value will have the same type with `x`.
 
     Returns:
@@ -343,10 +348,10 @@ def floor(x, dtype=None):
     The floor of the scalar `x` is the largest integer `k`, such that `k <= x`.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
-        dtype: (:mod:`~taichi.types.primitive_types`): the returned type, default to `None`. If \
+        dtype: (:mod:`~gstaichi.types.primitive_types`): the returned type, default to `None`. If \
             set to `None` the retuned value will have the same type with `x`.
 
     Returns:
@@ -375,10 +380,10 @@ def ceil(x, dtype=None):
     The ceil of the scalar `x` is the smallest integer `k`, such that `k >= x`.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
-        dtype: (:mod:`~taichi.types.primitive_types`): the returned type, default to `None`. If \
+        dtype: (:mod:`~gstaichi.types.primitive_types`): the returned type, default to `None`. If \
             set to `None` the retuned value will have the same type with `x`.
 
     Returns:
@@ -408,7 +413,7 @@ def tan(x):
     Equivalent to `ti.sin(x)/ti.cos(x)` element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
     Returns:
@@ -433,7 +438,7 @@ def tanh(x):
     """Compute the hyperbolic tangent of `x`, element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
     Returns:
@@ -457,7 +462,7 @@ def exp(x):
     """Compute the exponential of all elements in `x`, element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
     Returns:
@@ -484,7 +489,7 @@ def log(x):
     so that `log(exp(x)) = x`. The natural logarithm is logarithm in base `e`.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
     Returns:
@@ -508,7 +513,7 @@ def abs(x):  # pylint: disable=W0622
     """Compute the absolute value :math:`|x|` of `x`, element-wise.
 
     Args:
-        x (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input scalar or matrix.
 
     Returns:
@@ -532,7 +537,7 @@ def bit_not(a):
     """The bit not function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
 
     Returns:
         Bitwise not of `a`.
@@ -551,7 +556,7 @@ def logical_not(a):
     """The logical not function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
 
     Returns:
         `1` iff `a=0`, otherwise `0`.
@@ -561,7 +566,7 @@ def logical_not(a):
 
 def random(dtype=float) -> Union[float, int]:
     """Return a single random float/integer according to the specified data type.
-    Must be called in taichi scope.
+    Must be called in gstaichi scope.
 
     If the required `dtype` is float type, this function returns a random number
     sampled from the uniform distribution in the half-open interval [0, 1).
@@ -572,7 +577,7 @@ def random(dtype=float) -> Union[float, int]:
     64-bit integer is required.
 
     Args:
-        dtype (:mod:`~taichi.types.primitive_types`): Type of the required random value.
+        dtype (:mod:`~gstaichi.types.primitive_types`): Type of the required random value.
 
     Returns:
         A random value with type `dtype`.
@@ -605,8 +610,8 @@ def add(a, b):
     """The add function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
 
     Returns:
         sum of `a` and `b`.
@@ -618,8 +623,8 @@ def sub(a, b):
     """The sub function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
 
     Returns:
         `a` subtract `b`.
@@ -631,8 +636,8 @@ def mul(a, b):
     """The multiply function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
 
     Returns:
         `a` multiplied by `b`.
@@ -647,10 +652,10 @@ def mod(x1, x2):
     has the same sign as the divisor x2.
 
     Args:
-        x1 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x1 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Dividend scalar or matrix.
 
-        x2 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x2 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Divisor scalar or matrix. When both `x1` and `x2` are matrices they must have the same shape.
 
     Returns:
@@ -696,9 +701,9 @@ def pow(base, exponent):  # pylint: disable=W0622
     - A zero value raised to a non-positive value.
 
     Args:
-        base (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        base (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The bases.
-        exponent (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        exponent (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The exponents.
 
     Returns:
@@ -723,8 +728,8 @@ def floordiv(a, b):
     """The floor division function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix with elements not equal to zero.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix with elements not equal to zero.
 
     Returns:
         The floor function of `a` divided by `b`.
@@ -736,8 +741,8 @@ def truediv(a, b):
     """True division function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix with elements not equal to zero.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix with elements not equal to zero.
 
     Returns:
         The true value of `a` divided by `b`.
@@ -749,8 +754,8 @@ def max_impl(a, b):
     """The maxnimum function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
 
     Returns:
         The maxnimum of `a` and `b`.
@@ -762,8 +767,8 @@ def min_impl(a, b):
     """The minimum function.
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): A number or a matrix.
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): A number or a matrix.
 
     Returns:
         The minimum of `a` and `b`.
@@ -775,9 +780,9 @@ def atan2(x1, x2):
     """Element-wise arc tangent of `x1/x2`.
 
     Args:
-        x1 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x1 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             y-coordinates.
-        x2 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x2 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             x-coordinates.
 
     Returns:
@@ -804,8 +809,8 @@ def raw_div(x1, x2):
     """Return `x1 // x2` if both `x1`, `x2` are integers, otherwise return `x1/x2`.
 
     Args:
-        x1 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): Dividend.
-        x2 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): Divisor.
+        x1 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): Dividend.
+        x2 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): Divisor.
 
     Returns:
         Return `x1 // x2` if both `x1`, `x2` are integers, otherwise return `x1/x2`.
@@ -834,9 +839,9 @@ def raw_mod(x1, x2):
     This is the C-style `mod` function.
 
     Args:
-        x1 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x1 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The dividend.
-        x2 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x2 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The divisor.
 
     Returns:
@@ -860,11 +865,11 @@ def cmp_lt(a, b):
     """Compare two values (less than)
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: True if LHS is strictly smaller than RHS, False otherwise
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: True if LHS is strictly smaller than RHS, False otherwise
 
     """
     return _binary_operation(_ti_core.expr_cmp_lt, _bt_ops_mod.lt, a, b)
@@ -874,11 +879,11 @@ def cmp_le(a, b):
     """Compare two values (less than or equal to)
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: True if LHS is smaller than or equal to RHS, False otherwise
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: True if LHS is smaller than or equal to RHS, False otherwise
 
     """
     return _binary_operation(_ti_core.expr_cmp_le, _bt_ops_mod.le, a, b)
@@ -888,11 +893,11 @@ def cmp_gt(a, b):
     """Compare two values (greater than)
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: True if LHS is strictly larger than RHS, False otherwise
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: True if LHS is strictly larger than RHS, False otherwise
 
     """
     return _binary_operation(_ti_core.expr_cmp_gt, _bt_ops_mod.gt, a, b)
@@ -902,8 +907,8 @@ def cmp_ge(a, b):
     """Compare two values (greater than or equal to)
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
         bool: True if LHS is greater than or equal to RHS, False otherwise
@@ -916,11 +921,11 @@ def cmp_eq(a, b):
     """Compare two values (equal to)
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: True if LHS is equal to RHS, False otherwise.
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: True if LHS is equal to RHS, False otherwise.
 
     """
     return _binary_operation(_ti_core.expr_cmp_eq, _bt_ops_mod.eq, a, b)
@@ -930,11 +935,11 @@ def cmp_ne(a, b):
     """Compare two values (not equal to)
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: True if LHS is not equal to RHS, False otherwise
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: True if LHS is not equal to RHS, False otherwise
 
     """
     return _binary_operation(_ti_core.expr_cmp_ne, _bt_ops_mod.ne, a, b)
@@ -944,11 +949,11 @@ def bit_or(a, b):
     """Computes bitwise-or
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: LHS bitwise-or with RHS
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: LHS bitwise-or with RHS
 
     """
     return _binary_operation(_ti_core.expr_bit_or, _bt_ops_mod.or_, a, b)
@@ -958,11 +963,11 @@ def bit_and(a, b):
     """Compute bitwise-and
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: LHS bitwise-and with RHS
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: LHS bitwise-and with RHS
 
     """
     return _binary_operation(_ti_core.expr_bit_and, _bt_ops_mod.and_, a, b)
@@ -972,11 +977,11 @@ def bit_xor(a, b):
     """Compute bitwise-xor
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: LHS bitwise-xor with RHS
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: LHS bitwise-xor with RHS
 
     """
     return _binary_operation(_ti_core.expr_bit_xor, _bt_ops_mod.xor, a, b)
@@ -986,11 +991,11 @@ def bit_shl(a, b):
     """Compute bitwise shift left
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, int]: LHS << RHS
+        Union[:class:`~gstaichi.lang.expr.Expr`, int]: LHS << RHS
 
     """
     return _binary_operation(_ti_core.expr_bit_shl, _bt_ops_mod.lshift, a, b)
@@ -1000,25 +1005,25 @@ def bit_sar(a, b):
     """Compute bitwise shift right
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, int]: LHS >> RHS
+        Union[:class:`~gstaichi.lang.expr.Expr`, int]: LHS >> RHS
 
     """
     return _binary_operation(_ti_core.expr_bit_sar, _bt_ops_mod.rshift, a, b)
 
 
-@taichi_scope
+@gstaichi_scope
 def bit_shr(x1, x2):
     """Elements in `x1` shifted to the right by number of bits in `x2`.
     Both `x1`, `x2` must have integer type.
 
     Args:
-        x1 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x1 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Input data.
-        x2 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x2 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             Number of bits to remove at the right of `x1`.
 
     Returns:
@@ -1042,11 +1047,11 @@ def logical_and(a, b):
     """Compute logical_and
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: LHS logical-and RHS (with short-circuit semantics)
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: LHS logical-and RHS (with short-circuit semantics)
 
     """
     return _binary_operation(_ti_core.expr_logical_and, lambda a, b: a and b, a, b)
@@ -1056,11 +1061,11 @@ def logical_or(a, b):
     """Compute logical_or
 
     Args:
-        a (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value LHS
-        b (Union[:class:`~taichi.lang.expr.Expr`, :class:`~taichi.lang.matrix.Matrix`]): value RHS
+        a (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value LHS
+        b (Union[:class:`~gstaichi.lang.expr.Expr`, :class:`~gstaichi.lang.matrix.Matrix`]): value RHS
 
     Returns:
-        Union[:class:`~taichi.lang.expr.Expr`, bool]: LHS logical-or RHS (with short-circuit semantics)
+        Union[:class:`~gstaichi.lang.expr.Expr`, bool]: LHS logical-or RHS (with short-circuit semantics)
 
     """
     return _binary_operation(_ti_core.expr_logical_or, lambda a, b: a or b, a, b)
@@ -1071,9 +1076,9 @@ def select(cond, x1, x2):
     depending on the conditions in `cond`.
 
     Args:
-        cond (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        cond (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The array of conditions.
-        x1, x2 (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x1, x2 (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The arrays where the output elements are taken from.
 
     Returns:
@@ -1106,9 +1111,9 @@ def ifte(cond, x1, x2):
     short-circuit semantics: exactly one of `x1` or `x2` will be evaluated.
 
     Args:
-        cond (:mod:`~taichi.types.primitive_types`): \
+        cond (:mod:`~gstaichi.types.primitive_types`): \
             The condition.
-        x1, x2 (:mod:`~taichi.types.primitive_types`): \
+        x1, x2 (:mod:`~gstaichi.types.primitive_types`): \
             The outputs.
 
     Returns:
@@ -1144,7 +1149,7 @@ def atomic_add(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input.
 
     Returns:
@@ -1160,7 +1165,7 @@ def atomic_add(x, y):
         >>>     print(x)  # [1, 2, 3]  the new value of x
         >>>     print(z)  # [0, 0, 0], the old value of x
         >>>
-        >>>     ti.atomic_add(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_add(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(expr.Expr(_ti_core.expr_atomic_add(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info())))
 
@@ -1174,7 +1179,7 @@ def atomic_mul(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input.
 
     Returns:
@@ -1190,7 +1195,7 @@ def atomic_mul(x, y):
         >>>     print(x)  # [1, 2, 3]  the new value of x
         >>>     print(z)  # [4, 10, 18], the old value of x
         >>>
-        >>>     ti.atomic_mul(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_mul(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(expr.Expr(_ti_core.expr_atomic_mul(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info())))
 
@@ -1204,7 +1209,7 @@ def atomic_sub(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input.
 
     Returns:
@@ -1220,7 +1225,7 @@ def atomic_sub(x, y):
         >>>     print(x)  # [-1, -2, -3]  the new value of x
         >>>     print(z)  # [0, 0, 0], the old value of x
         >>>
-        >>>     ti.atomic_sub(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_sub(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(expr.Expr(_ti_core.expr_atomic_sub(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info())))
 
@@ -1234,7 +1239,7 @@ def atomic_min(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input.
 
     Returns:
@@ -1250,7 +1255,7 @@ def atomic_min(x, y):
         >>>     print(x)  # 1  the new value of x
         >>>     print(z)  # 2, the old value of x
         >>>
-        >>>     ti.atomic_min(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_min(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(expr.Expr(_ti_core.expr_atomic_min(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info())))
 
@@ -1264,7 +1269,7 @@ def atomic_max(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input.
 
     Returns:
@@ -1280,7 +1285,7 @@ def atomic_max(x, y):
         >>>     print(x)  # 2  the new value of x
         >>>     print(z)  # 1, the old value of x
         >>>
-        >>>     ti.atomic_max(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_max(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(expr.Expr(_ti_core.expr_atomic_max(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info())))
 
@@ -1294,7 +1299,7 @@ def atomic_and(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input. When both are matrices they must have the same shape.
 
     Returns:
@@ -1310,7 +1315,7 @@ def atomic_and(x, y):
         >>>     print(x)  # [1, 0, 1]  the new value of x
         >>>     print(z)  # [-1, 0, 1], the old value of x
         >>>
-        >>>     ti.atomic_and(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_and(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(
         expr.Expr(_ti_core.expr_atomic_bit_and(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
@@ -1326,7 +1331,7 @@ def atomic_or(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input. When both are matrices they must have the same shape.
 
     Returns:
@@ -1342,7 +1347,7 @@ def atomic_or(x, y):
         >>>     print(x)  # [-1, 2, 3]  the new value of x
         >>>     print(z)  # [-1, 0, 1], the old value of x
         >>>
-        >>>     ti.atomic_or(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_or(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(
         expr.Expr(_ti_core.expr_atomic_bit_or(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
@@ -1358,7 +1363,7 @@ def atomic_xor(x, y):
     are not allowed.
 
     Args:
-        x, y (Union[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        x, y (Union[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input. When both are matrices they must have the same shape.
 
     Returns:
@@ -1374,7 +1379,7 @@ def atomic_xor(x, y):
         >>>     print(x)  # [-2, 2, 2]  the new value of x
         >>>     print(z)  # [-1, 0, 1], the old value of x
         >>>
-        >>>     ti.atomic_xor(1, x)  # will raise TaichiSyntaxError
+        >>>     ti.atomic_xor(1, x)  # will raise GsTaichiSyntaxError
     """
     return impl.expr_init(
         expr.Expr(_ti_core.expr_atomic_bit_xor(x.ptr, y.ptr), dbg_info=_ti_core.DebugInfo(stack_info()))
@@ -1395,7 +1400,7 @@ def max(*args):  # pylint: disable=W0622
     must have the same shape, and scalars will be broadcasted to the same shape as the matrix.
 
     Args:
-        args: (List[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        args: (List[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input.
 
     Returns:
@@ -1427,7 +1432,7 @@ def min(*args):  # pylint: disable=W0622
     must have the same shape, and scalars will be broadcasted to the same shape as the matrix.
 
     Args:
-        args: (List[:mod:`~taichi.types.primitive_types`, :class:`~taichi.Matrix`]): \
+        args: (List[:mod:`~gstaichi.types.primitive_types`, :class:`~gstaichi.Matrix`]): \
             The input.
 
     Returns: