gstaichi 0.1.23.dev0__cp310-cp310-win_amd64.whl → 0.1.25.dev0__cp310-cp310-win_amd64.whl

{taichi → gstaichi}/lang/matrix.py

@@ -7,34 +7,34 @@ from itertools import product
 
 import numpy as np
 
-from taichi._lib import core as ti_python_core
-from taichi._lib.utils import ti_python_core as _ti_python_core
-from taichi.lang import expr, impl, runtime_ops
-from taichi.lang import ops as ops_mod
-from taichi.lang._ndarray import Ndarray, NdarrayHostAccess
-from taichi.lang.common_ops import TaichiOperations
-from taichi.lang.exception import (
-    TaichiRuntimeError,
-    TaichiRuntimeTypeError,
-    TaichiSyntaxError,
-    TaichiTypeError,
+from gstaichi._lib import core as ti_python_core
+from gstaichi._lib.utils import ti_python_core as _ti_python_core
+from gstaichi.lang import expr, impl, runtime_ops
+from gstaichi.lang import ops as ops_mod
+from gstaichi.lang._ndarray import Ndarray, NdarrayHostAccess
+from gstaichi.lang.common_ops import GsTaichiOperations
+from gstaichi.lang.exception import (
+    GsTaichiRuntimeError,
+    GsTaichiRuntimeTypeError,
+    GsTaichiSyntaxError,
+    GsTaichiTypeError,
 )
-from taichi.lang.field import Field, ScalarField, SNodeHostAccess
-from taichi.lang.util import (
+from gstaichi.lang.field import Field, ScalarField, SNodeHostAccess
+from gstaichi.lang.util import (
     cook_dtype,
     get_traceback,
+    gstaichi_scope,
     in_python_scope,
     python_scope,
-    taichi_scope,
     to_numpy_type,
     to_paddle_type,
     to_pytorch_type,
     warning,
 )
-from taichi.types import primitive_types
-from taichi.types.compound_types import CompoundType
-from taichi.types.enums import Layout
-from taichi.types.utils import is_signed
+from gstaichi.types import primitive_types
+from gstaichi.types.compound_types import CompoundType
+from gstaichi.types.enums import Layout
+from gstaichi.types.utils import is_signed
 
 _type_factory = _ti_python_core.get_type_factory_instance()
 
@@ -71,7 +71,7 @@ def _gen_swizzles(cls):
             if len(diff):
                 valid_attribs = tuple(sorted(valid_attribs))
                 pattern = tuple(pattern)
-                raise TaichiSyntaxError(f"vec{instance.n} only has " f"attributes={valid_attribs}, got={pattern}")
+                raise GsTaichiSyntaxError(f"vec{instance.n} only has " f"attributes={valid_attribs}, got={pattern}")
 
         return check
 
@@ -116,7 +116,7 @@ def _gen_swizzles(cls):
                 @python_scope
                 def prop_setter(instance, value):
                     if len(pattern) != len(value):
-                        raise TaichiRuntimeError(f"value len does not match the swizzle pattern={pattern}")
+                        raise GsTaichiRuntimeError(f"value len does not match the swizzle pattern={pattern}")
                     checker(instance, pattern)
                     for ch, val in zip(pattern, value):
                         instance[key_group.index(ch)] = val
@@ -138,9 +138,9 @@ def _infer_entry_dt(entry):
     if isinstance(entry, expr.Expr):
         dt = entry.ptr.get_rvalue_type()
         if dt == ti_python_core.DataType_unknown:
-            raise TaichiTypeError("Element type of the matrix cannot be inferred. Please set dt instead for now.")
+            raise GsTaichiTypeError("Element type of the matrix cannot be inferred. Please set dt instead for now.")
         return dt
-    raise TaichiTypeError("Element type of the matrix is invalid.")
+    raise GsTaichiTypeError("Element type of the matrix is invalid.")
 
 
 def _infer_array_dt(arr):
@@ -204,18 +204,18 @@ def _write_host_access(x, value):
 
 
 @_gen_swizzles
-class Matrix(TaichiOperations):
+class Matrix(GsTaichiOperations):
     """The matrix class.
 
     A matrix is a 2-D rectangular array with scalar entries, it's row-majored, and is
     aligned continuously. We recommend only use matrix with no more than 32 elements for
     efficiency considerations.
 
-    Note: in taichi a matrix is strictly two-dimensional and only stores scalars.
+    Note: in gstaichi a matrix is strictly two-dimensional and only stores scalars.
 
     Args:
         arr (Union[list, tuple, np.ndarray]): the initial values of a matrix.
-        dt (:mod:`~taichi.types.primitive_types`): the element data type.
+        dt (:mod:`~gstaichi.types.primitive_types`): the element data type.
         ndim (int optional): the number of dimensions of the matrix; forced reshape if given.
 
     Example::
@@ -245,13 +245,13 @@ class Matrix(TaichiOperations):
         0
     """
 
-    _is_taichi_class = True
+    _is_gstaichi_class = True
     _is_matrix_class = True
     __array_priority__ = 1000
 
     def __init__(self, arr, dt=None):
         if not isinstance(arr, (list, tuple, np.ndarray)):
-            raise TaichiTypeError("An Matrix/Vector can only be initialized with an array-like object")
+            raise GsTaichiTypeError("An Matrix/Vector can only be initialized with an array-like object")
         if len(arr) == 0:
             self.ndim = 0
             self.n, self.m = 0, 0
@@ -280,7 +280,7 @@ class Matrix(TaichiOperations):
 
         if self.n * self.m > 32:
             warning(
-                f"Taichi matrices/vectors with {self.n}x{self.m} > 32 entries are not suggested."
+                f"GsTaichi matrices/vectors with {self.n}x{self.m} > 32 entries are not suggested."
                 " Matrices/vectors will be automatically unrolled at compile-time for performance."
                 " So the compilation time could be extremely long if the matrix size is too big."
                 " You may use a field to store a large matrix like this, e.g.:\n"
@@ -308,7 +308,7 @@ class Matrix(TaichiOperations):
             The matrix-matrix product or matrix-vector product.
 
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops.matmul(self, other)
 
@@ -418,16 +418,16 @@ class Matrix(TaichiOperations):
             return [[_read_host_access(self.entries[i][j]) for j in range(self.m)] for i in range(self.n)]
         return self.entries.tolist()
 
-    @taichi_scope
+    @gstaichi_scope
     def cast(self, dtype):
         """Cast the matrix elements to a specified data type.
 
         Args:
-            dtype (:mod:`~taichi.types.primitive_types`): data type of the
+            dtype (:mod:`~gstaichi.types.primitive_types`): data type of the
                 returned matrix.
 
         Returns:
-            :class:`taichi.Matrix`: A new matrix with the specified data dtype.
+            :class:`gstaichi.Matrix`: A new matrix with the specified data dtype.
 
         Example::
 
@@ -455,7 +455,7 @@ class Matrix(TaichiOperations):
             5
         """
         # pylint: disable-msg=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.trace(self)
 
@@ -466,12 +466,12 @@ class Matrix(TaichiOperations):
             The matrix dimension should be less than or equal to 4.
 
         Returns:
-            :class:`~taichi.Matrix`: The inverse of a matrix.
+            :class:`~gstaichi.Matrix`: The inverse of a matrix.
 
         Raises:
             Exception: Inversions of matrices with sizes >= 5 are not supported.
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops.inverse(self)
 
@@ -492,7 +492,7 @@ class Matrix(TaichiOperations):
             [0.6, 0.8]
         """
         # pylint: disable-msg=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.normalized(self, eps)
 
@@ -500,7 +500,7 @@ class Matrix(TaichiOperations):
         """Returns the transpose of a matrix.
 
         Returns:
-            :class:`~taichi.Matrix`: The transpose of this matrix.
+            :class:`~gstaichi.Matrix`: The transpose of this matrix.
 
         Example::
 
@@ -509,11 +509,11 @@ class Matrix(TaichiOperations):
             [[0, 2], [1, 3]]
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.transpose(self)
 
-    @taichi_scope
+    @gstaichi_scope
     def determinant(a):
         """Returns the determinant of this matrix.
 
@@ -527,7 +527,7 @@ class Matrix(TaichiOperations):
             Exception: Determinants of matrices with sizes >= 5 are not supported.
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.determinant(a)
 
@@ -541,7 +541,7 @@ class Matrix(TaichiOperations):
             val (TypeVar): value for the diagonal elements.
 
         Returns:
-            :class:`~taichi.Matrix`: The wanted diagonal matrix.
+            :class:`~gstaichi.Matrix`: The wanted diagonal matrix.
 
         Example::
 
@@ -551,7 +551,7 @@ class Matrix(TaichiOperations):
              [0, 0, 1]]
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.diag(dim, val)
 
@@ -565,7 +565,7 @@ class Matrix(TaichiOperations):
             10
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.sum(self)
 
@@ -586,12 +586,12 @@ class Matrix(TaichiOperations):
             The square root of the sum of the absolute squares of its elements.
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.norm(self, eps=eps)
 
     def norm_inv(self, eps=0):
-        """The inverse of the matrix :func:`~taichi.lang.matrix.Matrix.norm`.
+        """The inverse of the matrix :func:`~gstaichi.lang.matrix.Matrix.norm`.
 
         Args:
             eps (float): a safe-guard value for sqrt, usually 0.
@@ -600,28 +600,28 @@ class Matrix(TaichiOperations):
             The inverse of the matrix/vector `norm`.
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.norm_inv(self, eps=eps)
 
     def norm_sqr(self):
         """Returns the sum of the absolute squares of its elements."""
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.norm_sqr(self)
 
     def max(self):
         """Returns the maximum element value."""
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.max(self)
 
     def min(self):
         """Returns the minimum element value."""
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.min(self)
 
@@ -638,7 +638,7 @@ class Matrix(TaichiOperations):
             True
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.any(self)
 
@@ -655,7 +655,7 @@ class Matrix(TaichiOperations):
             False
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.all(self)
 
@@ -673,7 +673,7 @@ class Matrix(TaichiOperations):
             [-1, -1, -1, -1]
         """
         # pylint: disable=C0415
-        from taichi.lang import matrix_ops
+        from gstaichi.lang import matrix_ops
 
         return matrix_ops.fill(self, val)
 
@@ -694,7 +694,7 @@ class Matrix(TaichiOperations):
             return np.array(self.to_list())
         return self.entries
 
-    @taichi_scope
+    @gstaichi_scope
     def __ti_repr__(self):
         yield "["
         for i in range(self.n):
@@ -718,9 +718,9 @@ class Matrix(TaichiOperations):
             to invoke `repr` to show the object... e.g.:
 
             TypeError: make_const_expr_f32(): incompatible function arguments. The following argument types are supported:
-                1. (arg0: float) -> taichi_python.Expr
+                1. (arg0: float) -> gstaichi_python.Expr
 
-            Invoked with: <Taichi 2x1 Matrix>
+            Invoked with: <GsTaichi 2x1 Matrix>
 
             So we have to make it happy with a dummy string...
             """
@@ -731,7 +731,7 @@ class Matrix(TaichiOperations):
         return str(self.to_numpy())
 
     @staticmethod
-    @taichi_scope
+    @gstaichi_scope
     def zero(dt, n, m=None):
         """Constructs a Matrix filled with zeros.
 
@@ -741,17 +741,17 @@ class Matrix(TaichiOperations):
             m (int, optional): The second dimension (column) of the matrix.
 
         Returns:
-            :class:`~taichi.lang.matrix.Matrix`: A :class:`~taichi.lang.matrix.Matrix` instance filled with zeros.
+            :class:`~gstaichi.lang.matrix.Matrix`: A :class:`~gstaichi.lang.matrix.Matrix` instance filled with zeros.
 
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         if m is None:
             return matrix_ops._filled_vector(n, dt, 0)
         return matrix_ops._filled_matrix(n, m, dt, 0)
 
     @staticmethod
-    @taichi_scope
+    @gstaichi_scope
     def one(dt, n, m=None):
         """Constructs a Matrix filled with ones.
 
@@ -761,17 +761,17 @@ class Matrix(TaichiOperations):
             m (int, optional): The second dimension (column) of the matrix.
 
         Returns:
-            :class:`~taichi.lang.matrix.Matrix`: A :class:`~taichi.lang.matrix.Matrix` instance filled with ones.
+            :class:`~gstaichi.lang.matrix.Matrix`: A :class:`~gstaichi.lang.matrix.Matrix` instance filled with ones.
 
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         if m is None:
             return matrix_ops._filled_vector(n, dt, 1)
         return matrix_ops._filled_matrix(n, m, dt, 1)
 
     @staticmethod
-    @taichi_scope
+    @gstaichi_scope
     def unit(n, i, dt=None):
         """Constructs a n-D vector with the `i`-th entry being equal to one and
         the remaining entries are all zeros.
@@ -779,10 +779,10 @@ class Matrix(TaichiOperations):
         Args:
             n (int): The length of the vector.
             i (int): The index of the entry that will be filled with one.
-            dt (:mod:`~taichi.types.primitive_types`, optional): The desired data type.
+            dt (:mod:`~gstaichi.types.primitive_types`, optional): The desired data type.
 
         Returns:
-            :class:`~taichi.Matrix`: The returned vector.
+            :class:`~gstaichi.Matrix`: The returned vector.
 
         Example::
 
@@ -790,7 +790,7 @@ class Matrix(TaichiOperations):
             >>> A
             [0, 1, 0]
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         if dt is None:
             dt = int
@@ -798,7 +798,7 @@ class Matrix(TaichiOperations):
         return matrix_ops._unit_vector(n, i, dt)
 
     @staticmethod
-    @taichi_scope
+    @gstaichi_scope
     def identity(dt, n):
         """Constructs an identity Matrix with shape (n, n).
 
@@ -807,9 +807,9 @@ class Matrix(TaichiOperations):
             n (int): The number of rows/columns.
 
         Returns:
-            :class:`~taichi.Matrix`: An `n x n` identity matrix.
+            :class:`~gstaichi.Matrix`: An `n x n` identity matrix.
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops._identity_matrix(n, dt)
 
@@ -846,7 +846,7 @@ class Matrix(TaichiOperations):
                 Structure (AOS) or Structure Of Array (SOA).
 
         Returns:
-            :class:`~taichi.Matrix`: A matrix.
+            :class:`~gstaichi.Matrix`: A matrix.
         """
         entries = []
         element_dim = ndim if ndim is not None else 2
@@ -897,9 +897,9 @@ class Matrix(TaichiOperations):
 
         if shape is None:
             if offset is not None:
-                raise TaichiSyntaxError("shape cannot be None when offset is set")
+                raise GsTaichiSyntaxError("shape cannot be None when offset is set")
             if order is not None:
-                raise TaichiSyntaxError("shape cannot be None when order is set")
+                raise GsTaichiSyntaxError("shape cannot be None when order is set")
         else:
             if isinstance(shape, numbers.Number):
                 shape = (shape,)
@@ -907,22 +907,22 @@ class Matrix(TaichiOperations):
                 offset = (offset,)
             dim = len(shape)
             if offset is not None and dim != len(offset):
-                raise TaichiSyntaxError(
+                raise GsTaichiSyntaxError(
                     f"The dimensionality of shape and offset must be the same ({dim} != {len(offset)})"
                 )
             axis_seq = []
             shape_seq = []
             if order is not None:
                 if dim != len(order):
-                    raise TaichiSyntaxError(
+                    raise GsTaichiSyntaxError(
                         f"The dimensionality of shape and order must be the same ({dim} != {len(order)})"
                     )
                 if dim != len(set(order)):
-                    raise TaichiSyntaxError("The axes in order must be different")
+                    raise GsTaichiSyntaxError("The axes in order must be different")
                 for ch in order:
                     axis = ord(ch) - ord("i")
                     if axis < 0 or axis >= dim:
-                        raise TaichiSyntaxError(f"Invalid axis {ch}")
+                        raise GsTaichiSyntaxError(f"Invalid axis {ch}")
                     axis_seq.append(axis)
                     shape_seq.append(shape[axis])
             else:
@@ -949,7 +949,7 @@ class Matrix(TaichiOperations):
     @classmethod
     @python_scope
     def ndarray(cls, n, m, dtype, shape):
-        """Defines a Taichi ndarray with matrix elements.
+        """Defines a GsTaichi ndarray with matrix elements.
         This function must be called in Python scope, and after `ti.init` is called.
 
         Args:
@@ -960,7 +960,7 @@ class Matrix(TaichiOperations):
 
         Example::
 
-            The code below shows how a Taichi ndarray with matrix elements \
+            The code below shows how a GsTaichi ndarray with matrix elements \
             can be declared and defined::
 
                 >>> x = ti.Matrix.ndarray(4, 5, ti.f32, shape=(16, 8))
@@ -972,13 +972,13 @@ class Matrix(TaichiOperations):
     @staticmethod
     def rows(rows):
         """Constructs a matrix by concatenating a list of
-        vectors/lists row by row. Must be called in Taichi scope.
+        vectors/lists row by row. Must be called in GsTaichi scope.
 
         Args:
             rows (List): A list of Vector (1-D Matrix) or a list of list.
 
         Returns:
-            :class:`~taichi.Matrix`: A matrix.
+            :class:`~gstaichi.Matrix`: A matrix.
 
         Example::
 
@@ -992,7 +992,7 @@ class Matrix(TaichiOperations):
             >>> test()
             [[1, 2, 3], [4, 5, 6]]
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops.rows(rows)
 
@@ -1004,7 +1004,7 @@ class Matrix(TaichiOperations):
             cols (List): A list of Vector (1-D Matrix) or a list of list.
 
         Returns:
-            :class:`~taichi.Matrix`: A matrix.
+            :class:`~gstaichi.Matrix`: A matrix.
 
         Example::
 
@@ -1018,7 +1018,7 @@ class Matrix(TaichiOperations):
             >>> test()
             [[1, 4], [2, 5], [3, 6]]
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops.cols(cols)
 
@@ -1034,7 +1034,7 @@ class Matrix(TaichiOperations):
         To call this method, both multiplicatives must be vectors.
 
         Args:
-            other (:class:`~taichi.Matrix`): The input Vector.
+            other (:class:`~gstaichi.Matrix`): The input Vector.
 
         Returns:
             DataType: The dot product result (scalar) of the two Vectors.
@@ -1046,7 +1046,7 @@ class Matrix(TaichiOperations):
             >>> v1.dot(v2)
             26
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops.dot(self, other)
 
@@ -1062,12 +1062,12 @@ class Matrix(TaichiOperations):
         `v x w`.
 
         Args:
-            other (:class:`~taichi.Matrix`): The input Vector.
+            other (:class:`~gstaichi.Matrix`): The input Vector.
 
         Returns:
-            :class:`~taichi.Matrix`: The cross product of the two Vectors.
+            :class:`~gstaichi.Matrix`: The cross product of the two Vectors.
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops.cross(self, other)
 
@@ -1079,12 +1079,12 @@ class Matrix(TaichiOperations):
         entry is equal to `xi*yj`.
 
         Args:
-            other (:class:`~taichi.Matrix`): The input Vector.
+            other (:class:`~gstaichi.Matrix`): The input Vector.
 
         Returns:
-            :class:`~taichi.Matrix`: The outer product of the two Vectors.
+            :class:`~gstaichi.Matrix`: The outer product of the two Vectors.
         """
-        from taichi.lang import matrix_ops  # pylint: disable=C0415
+        from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         return matrix_ops.outer_product(self, other)
 
@@ -1097,10 +1097,10 @@ class Vector(Matrix):
 
         Args:
             arr (Union[list, tuple, np.ndarray]): The initial values of the Vector.
-            dt (:mod:`~taichi.types.primitive_types`): data type of the vector.
+            dt (:mod:`~gstaichi.types.primitive_types`): data type of the vector.
 
         Returns:
-            :class:`~taichi.Matrix`: A vector instance.
+            :class:`~gstaichi.Matrix`: A vector instance.
         Example::
             >>> u = ti.Vector([1, 2])
             >>> print(u.m, u.n)  # verify a vector is a matrix of shape (n, 1)
@@ -1125,7 +1125,7 @@ class Vector(Matrix):
     @classmethod
     @python_scope
     def ndarray(cls, n, dtype, shape):
-        """Defines a Taichi ndarray with vector elements.
+        """Defines a GsTaichi ndarray with vector elements.
 
         Args:
             n (int): Size of the vector.
@@ -1133,7 +1133,7 @@ class Vector(Matrix):
             shape (Union[int, tuple[int]]): Shape of the ndarray.
 
         Example:
-            The code below shows how a Taichi ndarray with vector elements can be declared and defined::
+            The code below shows how a GsTaichi ndarray with vector elements can be declared and defined::
 
                 >>> x = ti.Vector.ndarray(3, ti.f32, shape=(16, 8))
         """
@@ -1143,7 +1143,7 @@ class Vector(Matrix):
 
 
 class MatrixField(Field):
-    """Taichi matrix field with SNode implementation.
+    """GsTaichi matrix field with SNode implementation.
 
     Args:
         vars (List[Expr]): Field members.
@@ -1181,7 +1181,7 @@ class MatrixField(Field):
         return None
 
     def _calc_dynamic_index_stride(self):
-        # Algorithm: https://github.com/taichi-dev/taichi/issues/3810
+        # Algorithm: https://github.com/taichi-dev/gstaichi/issues/3810
         paths = [ScalarField(var).snode._path_from_root() for var in self.vars]
         num_members = len(paths)
         if num_members == 1:
@@ -1241,13 +1241,17 @@ class MatrixField(Field):
             if self.ndim != 1:
                 assert len(val[0]) == self.m
         if in_python_scope():
-            from taichi._kernels import field_fill_python_scope  # pylint: disable=C0415
+            from gstaichi._kernels import (  # pylint: disable=C0415
+                field_fill_python_scope,  # pylint: disable=C0415
+            )
 
             field_fill_python_scope(self, val)
         else:
-            from taichi._funcs import field_fill_taichi_scope  # pylint: disable=C0415
+            from gstaichi._funcs import (  # pylint: disable=C0415
+                field_fill_gstaichi_scope,  # pylint: disable=C0415
+            )
 
-            field_fill_taichi_scope(self, val)
+            field_fill_gstaichi_scope(self, val)
 
     @python_scope
     def to_numpy(self, keep_dims=False, dtype=None):
@@ -1268,7 +1272,7 @@ class MatrixField(Field):
         as_vector = self.m == 1 and not keep_dims
         shape_ext = (self.n,) if as_vector else (self.n, self.m)
         arr = np.zeros(self.shape + shape_ext, dtype=dtype)
-        from taichi._kernels import matrix_to_ext_arr  # pylint: disable=C0415
+        from gstaichi._kernels import matrix_to_ext_arr  # pylint: disable=C0415
 
         matrix_to_ext_arr(self, arr, as_vector)
         runtime_ops.sync()
@@ -1280,7 +1284,7 @@ class MatrixField(Field):
         Args:
             device (torch.device, optional): The desired device of returned tensor.
             keep_dims (bool, optional): Whether to keep the dimension after conversion.
-                See :meth:`~taichi.lang.field.MatrixField.to_numpy` for more detailed explanation.
+                See :meth:`~gstaichi.lang.field.MatrixField.to_numpy` for more detailed explanation.
 
         Returns:
             torch.tensor: The result torch tensor.
@@ -1291,7 +1295,7 @@ class MatrixField(Field):
         shape_ext = (self.n,) if as_vector else (self.n, self.m)
         # pylint: disable=E1101
         arr = torch.empty(self.shape + shape_ext, dtype=to_pytorch_type(self.dtype), device=device)
-        from taichi._kernels import matrix_to_ext_arr  # pylint: disable=C0415
+        from gstaichi._kernels import matrix_to_ext_arr  # pylint: disable=C0415
 
         matrix_to_ext_arr(self, arr, as_vector)
         runtime_ops.sync()
@@ -1303,7 +1307,7 @@ class MatrixField(Field):
         Args:
             place (paddle.CPUPlace()/CUDAPlace(n), optional): The desired place of returned tensor.
             keep_dims (bool, optional): Whether to keep the dimension after conversion.
-                See :meth:`~taichi.lang.field.MatrixField.to_numpy` for more detailed explanation.
+                See :meth:`~gstaichi.lang.field.MatrixField.to_numpy` for more detailed explanation.
 
         Returns:
             paddle.Tensor: The result paddle tensor.
@@ -1318,7 +1322,7 @@ class MatrixField(Field):
             paddle.empty(self.shape + shape_ext, to_paddle_type(self.dtype)),
             place=place,
         )
-        from taichi._kernels import matrix_to_ext_arr  # pylint: disable=C0415
+        from gstaichi._kernels import matrix_to_ext_arr  # pylint: disable=C0415
 
         matrix_to_ext_arr(self, arr, as_vector)
         runtime_ops.sync()
@@ -1334,7 +1338,7 @@ class MatrixField(Field):
             assert len(arr.shape) == len(self.shape) + 2
         dim_ext = 1 if as_vector else 2
         assert len(arr.shape) == len(self.shape) + dim_ext
-        from taichi._kernels import ext_arr_to_matrix  # pylint: disable=C0415
+        from gstaichi._kernels import ext_arr_to_matrix  # pylint: disable=C0415
 
         ext_arr_to_matrix(arr, self, as_vector)
         runtime_ops.sync()
@@ -1420,7 +1424,7 @@ class MatrixType(CompoundType):
 
         """
         if len(args) == 0:
-            raise TaichiSyntaxError("Custom type instances need to be created with an initial value.")
+            raise GsTaichiSyntaxError("Custom type instances need to be created with an initial value.")
         if len(args) == 1:
             # Init from a real Matrix
             if isinstance(args[0], expr.Expr) and args[0].ptr.is_tensor():
@@ -1452,7 +1456,7 @@ class MatrixType(CompoundType):
 
         return self._instantiate(entries)
 
-    def from_taichi_object(self, func_ret, ret_index=()):
+    def from_gstaichi_object(self, func_ret, ret_index=()):
         return self(
             [
                 expr.Expr(
@@ -1475,7 +1479,7 @@ class MatrixType(CompoundType):
         elif self.dtype in primitive_types.real_types:
             get_ret_func = launch_ctx.get_struct_ret_float
         else:
-            raise TaichiRuntimeTypeError(f"Invalid return type on index={ret_index}")
+            raise GsTaichiRuntimeTypeError(f"Invalid return type on index={ret_index}")
         return self([get_ret_func(ret_index + (i,)) for i in range(self.m * self.n)])
 
     def set_kernel_struct_args(self, mat, launch_ctx, ret_index=()):
@@ -1487,7 +1491,7 @@ class MatrixType(CompoundType):
         elif self.dtype in primitive_types.real_types:
             set_arg_func = launch_ctx.set_struct_arg_float
         else:
-            raise TaichiRuntimeTypeError(f"Invalid return type on index={ret_index}")
+            raise GsTaichiRuntimeTypeError(f"Invalid return type on index={ret_index}")
         if self.ndim == 1:
             for i in range(self.n):
                 set_arg_func(ret_index + (i,), mat[i])
@@ -1505,7 +1509,7 @@ class MatrixType(CompoundType):
         elif self.dtype in primitive_types.real_types:
             set_arg_func = argpack.set_arg_float
         else:
-            raise TaichiRuntimeTypeError(f"Invalid return type on index={ret_index}")
+            raise GsTaichiRuntimeTypeError(f"Invalid return type on index={ret_index}")
         if self.ndim == 1:
             for i in range(self.n):
                 set_arg_func(ret_index + (i,), mat[i])
@@ -1591,7 +1595,7 @@ class VectorType(MatrixType):
 
         """
         if len(args) == 0:
-            raise TaichiSyntaxError("Custom type instances need to be created with an initial value.")
+            raise GsTaichiSyntaxError("Custom type instances need to be created with an initial value.")
         if len(args) == 1:
             # Init from a real Matrix
             if isinstance(args[0], expr.Expr) and args[0].ptr.is_tensor():
@@ -1649,7 +1653,7 @@ class VectorType(MatrixType):
 
 
 class MatrixNdarray(Ndarray):
-    """Taichi ndarray with matrix elements.
+    """GsTaichi ndarray with matrix elements.
 
     Args:
         n (int): Number of rows of the matrix.
@@ -1744,7 +1748,7 @@ class MatrixNdarray(Ndarray):
 
     @python_scope
     def _fill_by_kernel(self, val):
-        from taichi._kernels import fill_ndarray_matrix  # pylint: disable=C0415
+        from gstaichi._kernels import fill_ndarray_matrix  # pylint: disable=C0415
 
         shape = self.element_type.shape()
         n = shape[0]
@@ -1766,7 +1770,7 @@ class MatrixNdarray(Ndarray):
 
 
 class VectorNdarray(Ndarray):
-    """Taichi ndarray with vector elements.
+    """GsTaichi ndarray with vector elements.
 
     Args:
         n (int): Size of the vector.
@@ -1858,7 +1862,7 @@ class VectorNdarray(Ndarray):
 
     @python_scope
     def _fill_by_kernel(self, val):
-        from taichi._kernels import fill_ndarray_matrix  # pylint: disable=C0415
+        from gstaichi._kernels import fill_ndarray_matrix  # pylint: disable=C0415
 
         shape = self.element_type.shape()
         prim_dtype = self.element_type.element_type()