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

{taichi → gstaichi}/lang/util.py

@@ -8,10 +8,10 @@ import warnings
 import numpy as np
 from colorama import Fore, Style
 
-from taichi._lib import core as _ti_core
-from taichi._logging import is_logging_effective
-from taichi.lang import impl
-from taichi.types.primitive_types import (
+from gstaichi._lib import core as _ti_core
+from gstaichi._logging import is_logging_effective
+from gstaichi.lang import impl
+from gstaichi.types.primitive_types import (
     f16,
     f32,
     f64,
@@ -67,7 +67,7 @@ def has_paddle():
 def get_clangpp():
     from distutils.spawn import find_executable  # pylint: disable=C0415
 
-    # Taichi itself uses llvm-10.0.0 to compile.
+    # GsTaichi itself uses llvm-10.0.0 to compile.
     # There will be some issues compiling CUDA with other clang++ version.
     _clangpp_candidates = ["clang++-10"]
     for c in _clangpp_candidates:
@@ -91,18 +91,18 @@ def is_matrix_class(rhs):
     return matrix_class
 
 
-def is_taichi_class(rhs):
-    taichi_class = False
+def is_gstaichi_class(rhs):
+    gstaichi_class = False
     try:
-        if rhs._is_taichi_class:
-            taichi_class = True
+        if rhs._is_gstaichi_class:
+            gstaichi_class = True
     except:
         pass
-    return taichi_class
+    return gstaichi_class
 
 
 def to_numpy_type(dt):
-    """Convert taichi data type to its counterpart in numpy.
+    """Convert gstaichi data type to its counterpart in numpy.
 
     Args:
         dt (DataType): The desired data type to convert.
@@ -139,7 +139,7 @@ def to_numpy_type(dt):
 
 
 def to_pytorch_type(dt):
-    """Convert taichi data type to its counterpart in torch.
+    """Convert gstaichi data type to its counterpart in torch.
 
     Args:
         dt (DataType): The desired data type to convert.
@@ -184,7 +184,7 @@ def to_pytorch_type(dt):
 
 
 def to_paddle_type(dt):
-    """Convert taichi data type to its counterpart in paddle.
+    """Convert gstaichi data type to its counterpart in paddle.
 
     Args:
         dt (DataType): The desired data type to convert.
@@ -218,17 +218,17 @@ def to_paddle_type(dt):
     assert False
 
 
-def to_taichi_type(dt):
-    """Convert numpy or torch or paddle data type to its counterpart in taichi.
+def to_gstaichi_type(dt):
+    """Convert numpy or torch or paddle data type to its counterpart in gstaichi.
 
     Args:
         dt (DataType): The desired data type to convert.
 
     Returns:
-        DataType: The counterpart data type in taichi.
+        DataType: The counterpart data type in gstaichi.
 
     """
-    if type(dt) == _ti_core.DataType:
+    if type(dt) == _ti_core.DataTypeCxx:
         return dt
 
     if dt == np.float32:
@@ -317,10 +317,10 @@ def to_taichi_type(dt):
 
 
 def cook_dtype(dtype):
-    if isinstance(dtype, _ti_core.DataType):
+    if isinstance(dtype, _ti_core.DataTypeCxx):
         return dtype
     if isinstance(dtype, _ti_core.Type):
-        return _ti_core.DataType(dtype)
+        return _ti_core.DataTypeCxx(dtype)
     if dtype is float:
         return impl.get_runtime().default_fp
     if dtype is int:
@@ -330,18 +330,18 @@ def cook_dtype(dtype):
     raise ValueError(f"Invalid data type {dtype}")
 
 
-def in_taichi_scope():
+def in_gstaichi_scope():
     return impl.inside_kernel()
 
 
 def in_python_scope():
-    return not in_taichi_scope()
+    return not in_gstaichi_scope()
 
 
-def taichi_scope(func):
+def gstaichi_scope(func):
     @functools.wraps(func)
     def wrapped(*args, **kwargs):
-        assert in_taichi_scope(), f"{func.__name__} cannot be called in Python-scope"
+        assert in_gstaichi_scope(), f"{func.__name__} cannot be called in Python-scope"
         return func(*args, **kwargs)
 
     return wrapped
@@ -350,7 +350,7 @@ def taichi_scope(func):
 def python_scope(func):
     @functools.wraps(func)
     def wrapped(*args, **kwargs):
-        assert in_python_scope(), f"{func.__name__} cannot be called in Taichi-scope"
+        assert in_python_scope(), f"{func.__name__} cannot be called in GsTaichi-scope"
         return func(*args, **kwargs)
 
     return wrapped

gstaichi/linalg/__init__.py

@@ -0,0 +1,8 @@
+# type: ignore
+
+"""GsTaichi support module for sparse matrix operations."""
+
+from gstaichi.linalg.matrixfree_cg import *
+from gstaichi.linalg.sparse_cg import SparseCG
+from gstaichi.linalg.sparse_matrix import *
+from gstaichi.linalg.sparse_solver import SparseSolver

{taichi → gstaichi}/linalg/matrixfree_cg.py

@@ -2,11 +2,11 @@
 
 from math import sqrt
 
-from taichi.lang import misc
-from taichi.lang.exception import TaichiRuntimeError, TaichiTypeError
-from taichi.lang.impl import FieldsBuilder, field, grouped
-from taichi.lang.kernel_impl import data_oriented, kernel
-from taichi.types import primitive_types, template
+from gstaichi.lang import misc
+from gstaichi.lang.exception import GsTaichiRuntimeError, GsTaichiTypeError
+from gstaichi.lang.impl import FieldsBuilder, field, grouped
+from gstaichi.lang.kernel_impl import data_oriented, kernel
+from gstaichi.types import primitive_types, template
 
 
 @data_oriented
@@ -16,7 +16,7 @@ class LinearOperator:
 
     def matvec(self, x, Ax):
         if x.shape != Ax.shape:
-            raise TaichiRuntimeError(f"Dimension mismatch x.shape{x.shape} != Ax.shape{Ax.shape}.")
+            raise GsTaichiRuntimeError(f"Dimension mismatch x.shape{x.shape} != Ax.shape{Ax.shape}.")
         self._matvec(x, Ax)
 
 
@@ -36,15 +36,15 @@ def MatrixFreeCG(A, b, x, tol=1e-6, maxiter=5000, quiet=True):
     """
 
     if b.dtype != x.dtype:
-        raise TaichiTypeError(f"Dtype mismatch b.dtype({b.dtype}) != x.dtype({x.dtype}).")
+        raise GsTaichiTypeError(f"Dtype mismatch b.dtype({b.dtype}) != x.dtype({x.dtype}).")
     if str(b.dtype) == "f32":
         solver_dtype = primitive_types.f32
     elif str(b.dtype) == "f64":
         solver_dtype = primitive_types.f64
     else:
-        raise TaichiTypeError(f"Not supported dtype: {b.dtype}")
+        raise GsTaichiTypeError(f"Not supported dtype: {b.dtype}")
     if b.shape != x.shape:
-        raise TaichiRuntimeError(f"Dimension mismatch b.shape{b.shape} != x.shape{x.shape}.")
+        raise GsTaichiRuntimeError(f"Dimension mismatch b.shape{b.shape} != x.shape{x.shape}.")
 
     size = b.shape
     vector_fields_builder = FieldsBuilder()
@@ -59,7 +59,7 @@ def MatrixFreeCG(A, b, x, tol=1e-6, maxiter=5000, quiet=True):
     elif len(size) == 3:
         axes = misc.ijk
     else:
-        raise TaichiRuntimeError(f"MatrixFreeCG only support 1D, 2D, 3D inputs; your inputs is {len(size)}-D.")
+        raise GsTaichiRuntimeError(f"MatrixFreeCG only support 1D, 2D, 3D inputs; your inputs is {len(size)}-D.")
     vector_fields_builder.dense(axes, size).place(p, r, Ap, Ax)
     vector_fields_snode_tree = vector_fields_builder.finalize()
 
@@ -157,15 +157,15 @@ def MatrixFreeBICGSTAB(A, b, x, tol=1e-6, maxiter=5000, quiet=True):
     """
 
     if b.dtype != x.dtype:
-        raise TaichiTypeError(f"Dtype mismatch b.dtype({b.dtype}) != x.dtype({x.dtype}).")
+        raise GsTaichiTypeError(f"Dtype mismatch b.dtype({b.dtype}) != x.dtype({x.dtype}).")
     if str(b.dtype) == "f32":
         solver_dtype = primitive_types.f32
     elif str(b.dtype) == "f64":
         solver_dtype = primitive_types.f64
     else:
-        raise TaichiTypeError(f"Not supported dtype: {b.dtype}")
+        raise GsTaichiTypeError(f"Not supported dtype: {b.dtype}")
     if b.shape != x.shape:
-        raise TaichiRuntimeError(f"Dimension mismatch b.shape{b.shape} != x.shape{x.shape}.")
+        raise GsTaichiRuntimeError(f"Dimension mismatch b.shape{b.shape} != x.shape{x.shape}.")
 
     size = b.shape
     vector_fields_builder = FieldsBuilder()
@@ -186,7 +186,7 @@ def MatrixFreeBICGSTAB(A, b, x, tol=1e-6, maxiter=5000, quiet=True):
     elif len(size) == 3:
         axes = misc.ijk
     else:
-        raise TaichiRuntimeError(f"MatrixFreeBICGSTAB only support 1D, 2D, 3D inputs; your inputs is {len(size)}-D.")
+        raise GsTaichiRuntimeError(f"MatrixFreeBICGSTAB only support 1D, 2D, 3D inputs; your inputs is {len(size)}-D.")
     vector_fields_builder.dense(axes, size).place(p, p_hat, r, r_tld, s, s_hat, t, Ap, Ax, Ashat)
     vector_fields_snode_tree = vector_fields_builder.finalize()
 

{taichi → gstaichi}/linalg/sparse_cg.py

@@ -2,11 +2,11 @@
 
 import numpy as np
 
-from taichi._lib import core as _ti_core
-from taichi.lang._ndarray import Ndarray, ScalarNdarray
-from taichi.lang.exception import TaichiRuntimeError
-from taichi.lang.impl import get_runtime
-from taichi.types import f32, f64
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang._ndarray import Ndarray, ScalarNdarray
+from gstaichi.lang.exception import GsTaichiRuntimeError
+from gstaichi.lang.impl import get_runtime
+from gstaichi.types import f32, f64
 
 
 class SparseCG:
@@ -16,8 +16,8 @@ class SparseCG:
 
     Args:
         A (SparseMatrix): The coefficient matrix A of the linear system.
-        b (numpy ndarray, taichi Ndarray): The right-hand side of the linear system.
-        x0 (numpy ndarray, taichi Ndarray): The initial guess for the solution.
+        b (numpy ndarray, gstaichi Ndarray): The right-hand side of the linear system.
+        x0 (numpy ndarray, gstaichi Ndarray): The initial guess for the solution.
         max_iter (int): Maximum number of iterations.
         atol: Tolerance(absolute) for convergence.
     """
@@ -35,7 +35,7 @@ class SparseCG:
             elif self.dtype == f64:
                 self.cg_solver = _ti_core.make_double_cg_solver(A.matrix, max_iter, atol, True)
             else:
-                raise TaichiRuntimeError(f"Unsupported CG dtype: {self.dtype}")
+                raise GsTaichiRuntimeError(f"Unsupported CG dtype: {self.dtype}")
             if isinstance(b, Ndarray):
                 self.cg_solver.set_b_ndarray(get_runtime().prog, b.arr)
             elif isinstance(b, np.ndarray):
@@ -45,7 +45,7 @@ class SparseCG:
             elif isinstance(x0, np.ndarray):
                 self.cg_solver.set_x(x0)
         else:
-            raise TaichiRuntimeError(f"Unsupported CG arch: {self.ti_arch}")
+            raise GsTaichiRuntimeError(f"Unsupported CG arch: {self.ti_arch}")
 
     def solve(self):
         if self.ti_arch == _ti_core.Arch.cuda:
@@ -53,7 +53,7 @@ class SparseCG:
                 x = ScalarNdarray(self.b.dtype, [self.matrix.m])
                 self.cg_solver.solve(get_runtime().prog, x.arr, self.b.arr)
                 return x, True
-            raise TaichiRuntimeError(f"Unsupported CG RHS type: {type(self.b)}")
+            raise GsTaichiRuntimeError(f"Unsupported CG RHS type: {type(self.b)}")
         else:
             self.cg_solver.solve()
             return self.cg_solver.get_x(), self.cg_solver.is_success()

{taichi → gstaichi}/linalg/sparse_matrix.py

@@ -4,16 +4,16 @@ from functools import reduce
 
 import numpy as np
 
-from taichi._lib import core as _ti_core
-from taichi.lang._ndarray import Ndarray, ScalarNdarray
-from taichi.lang.exception import TaichiRuntimeError
-from taichi.lang.field import Field
-from taichi.lang.impl import get_runtime
-from taichi.types import f32
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang._ndarray import Ndarray, ScalarNdarray
+from gstaichi.lang.exception import GsTaichiRuntimeError
+from gstaichi.lang.field import Field
+from gstaichi.lang.impl import get_runtime
+from gstaichi.types import f32
 
 
 class SparseMatrix:
-    """Taichi's Sparse Matrix class
+    """GsTaichi's Sparse Matrix class
 
     A sparse matrix allows the programmer to solve a large linear system.
 
@@ -151,13 +151,13 @@ class SparseMatrix:
             return self.matrix.mat_vec_mul(other)
         if isinstance(other, Ndarray):
             if self.m != other.shape[0]:
-                raise TaichiRuntimeError(
+                raise GsTaichiRuntimeError(
                     f"Dimension mismatch between sparse matrix ({self.n}, {self.m}) and vector ({other.shape})"
                 )
             res = ScalarNdarray(dtype=other.dtype, arr_shape=(self.n,))
             self.matrix.spmv(get_runtime().prog, other.arr, res.arr)
             return res
-        raise TaichiRuntimeError(
+        raise GsTaichiRuntimeError(
             f"Sparse matrix-matrix/vector multiplication does not support {type(other)} for now. Supported types are SparseMatrix, ti.field, and numpy ndarray."
         )
 
@@ -186,7 +186,7 @@ class SparseMatrix:
             ndarray (Union[ti.ndarray, ti.Vector.ndarray, ti.Matrix.ndarray]): the ndarray to build the sparse matrix from.
 
         Raises:
-            TaichiRuntimeError: If the input is not a ndarray or the length is not divisible by 3.
+            GsTaichiRuntimeError: If the input is not a ndarray or the length is not divisible by 3.
 
         Example::
             >>> N = 5
@@ -208,10 +208,10 @@ class SparseMatrix:
         if isinstance(ndarray, Ndarray):
             num_scalars = reduce(lambda x, y: x * y, ndarray.shape + ndarray.element_shape)
             if num_scalars % 3 != 0:
-                raise TaichiRuntimeError("The number of ndarray elements must have a length that is divisible by 3.")
+                raise GsTaichiRuntimeError("The number of ndarray elements must have a length that is divisible by 3.")
             get_runtime().prog.make_sparse_matrix_from_ndarray(self.matrix, ndarray.arr)
         else:
-            raise TaichiRuntimeError(
+            raise GsTaichiRuntimeError(
                 "Sparse matrix only supports building from [ti.ndarray, ti.Vector.ndarray, ti.Matrix.ndarray]"
             )
 
@@ -249,8 +249,8 @@ class SparseMatrixBuilder:
         self.num_cols = num_cols if num_cols else num_rows
         self.dtype = dtype
         if num_rows is not None:
-            taichi_arch = get_runtime().prog.config().arch
-            if taichi_arch in [
+            gstaichi_arch = get_runtime().prog.config().arch
+            if gstaichi_arch in [
                 _ti_core.Arch.x64,
                 _ti_core.Arch.arm64,
                 _ti_core.Arch.cuda,
@@ -264,7 +264,7 @@ class SparseMatrixBuilder:
                 )
                 self.ptr.create_ndarray(get_runtime().prog)
             else:
-                raise TaichiRuntimeError("SparseMatrix only supports CPU and CUDA for now.")
+                raise GsTaichiRuntimeError("SparseMatrix only supports CPU and CUDA for now.")
 
     def _get_addr(self):
         """Get the address of the sparse matrix"""
@@ -276,24 +276,24 @@ class SparseMatrixBuilder:
 
     def print_triplets(self):
         """Print the triplets stored in the builder"""
-        taichi_arch = get_runtime().prog.config().arch
-        if taichi_arch in [_ti_core.Arch.x64, _ti_core.Arch.arm64]:
+        gstaichi_arch = get_runtime().prog.config().arch
+        if gstaichi_arch in [_ti_core.Arch.x64, _ti_core.Arch.arm64]:
             self.ptr.print_triplets_eigen()
-        elif taichi_arch == _ti_core.Arch.cuda:
+        elif gstaichi_arch == _ti_core.Arch.cuda:
             self.ptr.print_triplets_cuda()
 
     def build(self, dtype=f32, _format="CSR"):
         """Create a sparse matrix using the triplets"""
-        taichi_arch = get_runtime().prog.config().arch
-        if taichi_arch in [_ti_core.Arch.x64, _ti_core.Arch.arm64]:
+        gstaichi_arch = get_runtime().prog.config().arch
+        if gstaichi_arch in [_ti_core.Arch.x64, _ti_core.Arch.arm64]:
             sm = self.ptr.build()
             return SparseMatrix(sm=sm, dtype=self.dtype)
-        if taichi_arch == _ti_core.Arch.cuda:
+        if gstaichi_arch == _ti_core.Arch.cuda:
             if self.dtype != f32:
-                raise TaichiRuntimeError("CUDA sparse matrix only supports f32.")
+                raise GsTaichiRuntimeError("CUDA sparse matrix only supports f32.")
             sm = self.ptr.build_cuda()
             return SparseMatrix(sm=sm, dtype=self.dtype)
-        raise TaichiRuntimeError("Sparse matrix only supports CPU and CUDA backends.")
+        raise GsTaichiRuntimeError("Sparse matrix only supports CPU and CUDA backends.")
 
     def __del__(self):
         if get_runtime() is not None and get_runtime().prog is not None:

{taichi → gstaichi}/linalg/sparse_solver.py

@@ -2,14 +2,14 @@
 
 import numpy as np
 
-import taichi.lang
-from taichi._lib import core as _ti_core
-from taichi.lang._ndarray import Ndarray, ScalarNdarray
-from taichi.lang.exception import TaichiRuntimeError
-from taichi.lang.field import Field
-from taichi.lang.impl import get_runtime
-from taichi.linalg.sparse_matrix import SparseMatrix
-from taichi.types.primitive_types import f32
+import gstaichi.lang
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang._ndarray import Ndarray, ScalarNdarray
+from gstaichi.lang.exception import GsTaichiRuntimeError
+from gstaichi.lang.field import Field
+from gstaichi.lang.impl import get_runtime
+from gstaichi.linalg.sparse_matrix import SparseMatrix
+from gstaichi.types.primitive_types import f32
 
 
 class SparseSolver:
@@ -28,24 +28,24 @@ class SparseSolver:
         solver_type_list = ["LLT", "LDLT", "LU"]
         solver_ordering = ["AMD", "COLAMD"]
         if solver_type in solver_type_list and ordering in solver_ordering:
-            taichi_arch = taichi.lang.impl.get_runtime().prog.config().arch
+            gstaichi_arch = gstaichi.lang.impl.get_runtime().prog.config().arch
             assert (
-                taichi_arch == _ti_core.Arch.x64
-                or taichi_arch == _ti_core.Arch.arm64
-                or taichi_arch == _ti_core.Arch.cuda
+                gstaichi_arch == _ti_core.Arch.x64
+                or gstaichi_arch == _ti_core.Arch.arm64
+                or gstaichi_arch == _ti_core.Arch.cuda
             ), "SparseSolver only supports CPU and CUDA for now."
-            if taichi_arch == _ti_core.Arch.cuda:
+            if gstaichi_arch == _ti_core.Arch.cuda:
                 self.solver = _ti_core.make_cusparse_solver(dtype, solver_type, ordering)
             else:
                 self.solver = _ti_core.make_sparse_solver(dtype, solver_type, ordering)
         else:
-            raise TaichiRuntimeError(
+            raise GsTaichiRuntimeError(
                 f"The solver type {solver_type} with {ordering} is not supported for now. Only {solver_type_list} with {solver_ordering} are supported."
             )
 
     @staticmethod
     def _type_assert(sparse_matrix):
-        raise TaichiRuntimeError(
+        raise GsTaichiRuntimeError(
             f"The parameter type: {type(sparse_matrix)} is not supported in linear solvers for now."
         )
 
@@ -57,10 +57,10 @@ class SparseSolver:
         """
         if isinstance(sparse_matrix, SparseMatrix):
             self.matrix = sparse_matrix
-            taichi_arch = taichi.lang.impl.get_runtime().prog.config().arch
-            if taichi_arch == _ti_core.Arch.x64 or taichi_arch == _ti_core.Arch.arm64:
+            gstaichi_arch = gstaichi.lang.impl.get_runtime().prog.config().arch
+            if gstaichi_arch == _ti_core.Arch.x64 or gstaichi_arch == _ti_core.Arch.arm64:
                 self.solver.compute(sparse_matrix.matrix)
-            elif taichi_arch == _ti_core.Arch.cuda:
+            elif gstaichi_arch == _ti_core.Arch.cuda:
                 self.analyze_pattern(self.matrix)
                 self.factorize(self.matrix)
         else:
@@ -75,7 +75,7 @@ class SparseSolver:
         if isinstance(sparse_matrix, SparseMatrix):
             self.matrix = sparse_matrix
             if self.matrix.dtype != self.dtype:
-                raise TaichiRuntimeError(
+                raise GsTaichiRuntimeError(
                     f"The SparseSolver's dtype {self.dtype} is not consistent with the SparseMatrix's dtype {self.matrix.dtype}."
                 )
             self.solver.analyze_pattern(sparse_matrix.matrix)
@@ -103,7 +103,7 @@ class SparseSolver:
             numpy.array: The solution of linear systems.
         """
         if self.matrix is None:
-            raise TaichiRuntimeError("Please call compute() before calling solve().")
+            raise GsTaichiRuntimeError("Please call compute() before calling solve().")
         if isinstance(b, Field):
             return self.solver.solve(b.to_numpy())
         if isinstance(b, np.ndarray):
@@ -112,7 +112,7 @@ class SparseSolver:
             x = ScalarNdarray(b.dtype, [self.matrix.m])
             self.solver.solve_rf(get_runtime().prog, self.matrix.matrix, b.arr, x.arr)
             return x
-        raise TaichiRuntimeError(f"The parameter type: {type(b)} is not supported in linear solvers for now.")
+        raise GsTaichiRuntimeError(f"The parameter type: {type(b)} is not supported in linear solvers for now.")
 
     def info(self):
         """Check if the linear systems are solved successfully.

{taichi → gstaichi}/math/__init__.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-"""Taichi math module.
+"""GsTaichi math module.
 
 The math module supports glsl-style vectors, matrices and functions.
 """

{taichi → gstaichi}/math/_complex.py

@@ -1,8 +1,9 @@
 # type: ignore
 
+from gstaichi.lang import ops
+from gstaichi.lang.kernel_impl import func
+
 from .mathimpl import dot, vec2
-from taichi.lang import ops
-from taichi.lang.kernel_impl import func
 
 
 @func
@@ -13,8 +14,8 @@ def cmul(z1, z2):
     when `z1` and `z2` are treated as complex numbers.
 
     Args:
-        z1 (:class:`~taichi.math.vec2`): The first input.
-        z2 (:class:`~taichi.math.vec2`): The second input.
+        z1 (:class:`~gstaichi.math.vec2`): The first input.
+        z2 (:class:`~gstaichi.math.vec2`): The second input.
 
     Example::
 
@@ -25,7 +26,7 @@ def cmul(z1, z2):
         >>>     ti.math.cmul(z1, z2)  # [-1, 1]
 
     Returns:
-        :class:`~taichi.math.vec2`: the complex multiplication `z1 * z2`.
+        :class:`~gstaichi.math.vec2`: the complex multiplication `z1 * z2`.
     """
     x1, y1 = z1[0], z1[1]
     x2, y2 = z2[0], z2[1]
@@ -39,10 +40,10 @@ def cconj(z):
     If `z=(x, y)` then the conjugate of `z` is `(x, -y)`.
 
     Args:
-        z (:class:`~taichi.math.vec2`): The input.
+        z (:class:`~gstaichi.math.vec2`): The input.
 
     Returns:
-       :class:`~taichi.math.vec2`: The complex conjugate of `z`.
+       :class:`~gstaichi.math.vec2`: The complex conjugate of `z`.
     """
     return vec2(z[0], -z[1])
 
@@ -55,8 +56,8 @@ def cdiv(z1, z2):
     when `z1` and `z2` are treated as complex numbers.
 
     Args:
-        z1 (:class:`~taichi.math.vec2`): The first input.
-        z2 (:class:`~taichi.math.vec2`): The second input.
+        z1 (:class:`~gstaichi.math.vec2`): The first input.
+        z2 (:class:`~gstaichi.math.vec2`): The second input.
 
     Example::
 
@@ -67,7 +68,7 @@ def cdiv(z1, z2):
         >>>     ti.math.cdiv(z1, z2)  # [1, -1]
 
     Returns:
-        :class:`~taichi.math.vec2`: the complex division of `z1 / z2`.
+        :class:`~gstaichi.math.vec2`: the complex division of `z1 / z2`.
     """
     x1, y1 = z1[0], z1[1]
     x2, y2 = z2[0], z2[1]
@@ -84,7 +85,7 @@ def csqrt(z):
     are zero, the one with non-negative imaginary part is returned.
 
     Args:
-        z (:class:`~taichi.math.vec2`): The input.
+        z (:class:`~gstaichi.math.vec2`): The input.
 
     Example::
 
@@ -94,7 +95,7 @@ def csqrt(z):
         >>>     w = ti.math.csqrt(z)  # [0, 1]
 
     Returns:
-        :class:`~taichi.math.vec2`: The complex square root.
+        :class:`~gstaichi.math.vec2`: The complex square root.
     """
     result = vec2(0.0)
     if any(z):
@@ -110,7 +111,7 @@ def cinv(z):
     """Computes the reciprocal of a complex `z`.
 
     Args:
-        z (:class:`~taichi.math.vec2`): The input.
+        z (:class:`~gstaichi.math.vec2`): The input.
 
     Example::
 
@@ -120,7 +121,7 @@ def cinv(z):
         >>>     w = ti.math.cinv(z)  # [0.5, -0.5]
 
     Returns:
-        :class:`~taichi.math.vec2`: The reciprocal of `z`.
+        :class:`~gstaichi.math.vec2`: The reciprocal of `z`.
     """
     return cconj(z) / dot(z, z)
 
@@ -130,7 +131,7 @@ def cpow(z, n):
     """Computes the power of a complex `z`: :math:`z^a`.
 
     Args:
-        z (:class:`~taichi.math.vec2`): The base.
+        z (:class:`~gstaichi.math.vec2`): The base.
         a (float): The exponent.
 
     Example::
@@ -141,7 +142,7 @@ def cpow(z, n):
         >>>     w = ti.math.cpow(z)  # [-2, 2]
 
     Returns:
-        :class:`~taichi.math.vec2`: The power :math:`z^a`.
+        :class:`~gstaichi.math.vec2`: The power :math:`z^a`.
     """
     result = vec2(0.0)
     if any(z):
@@ -159,7 +160,7 @@ def cexp(z):
     `z` is a 2d vector treated as a complex number.
 
     Args:
-        z (:class:`~taichi.math.vec2`): The exponent.
+        z (:class:`~gstaichi.math.vec2`): The exponent.
 
     Example::
 
@@ -169,7 +170,7 @@ def cexp(z):
         >>>     w = ti.math.cexp(z)  # [1.468694, 2.287355]
 
     Returns:
-        :class:`~taichi.math.vec2`: The power :math:`exp(z)`
+        :class:`~gstaichi.math.vec2`: The power :math:`exp(z)`
     """
     r = ops.exp(z[0])
     return vec2(r * ops.cos(z[1]), r * ops.sin(z[1]))
@@ -184,7 +185,7 @@ def clog(z):
     lies in the range (-pi, pi].
 
     Args:
-        z (:class:`~taichi.math.vec2`): The input.
+        z (:class:`~gstaichi.math.vec2`): The input.
 
     Example::
 
@@ -194,7 +195,7 @@ def clog(z):
         >>>     w = ti.math.clog(z)  # [0.346574, 0.785398]
 
     Returns:
-        :class:`~taichi.math.vec2`: The logarithm of `z`.
+        :class:`~gstaichi.math.vec2`: The logarithm of `z`.
     """
     ang = ops.atan2(z[1], z[0])
     r2 = dot(z, z)