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

{taichi → gstaichi}/lang/matrix_ops.py

@@ -1,10 +1,10 @@
 # type: ignore
 
-import taichi.lang.ops as ops_mod
-from taichi.lang.impl import static
-from taichi.lang.kernel_impl import func, pyfunc
-from taichi.lang.matrix import Matrix, Vector
-from taichi.lang.matrix_ops_utils import (
+import gstaichi.lang.ops as ops_mod
+from gstaichi.lang.impl import static
+from gstaichi.lang.kernel_impl import func, pyfunc
+from gstaichi.lang.matrix import Matrix, Vector
+from gstaichi.lang.matrix_ops_utils import (
     arg_at,
     arg_foreach_check,
     assert_list,
@@ -18,7 +18,7 @@ from taichi.lang.matrix_ops_utils import (
     same_shapes,
     square_matrix,
 )
-from taichi.types.annotations import template
+from gstaichi.types.annotations import template
 
 
 @preconditions(arg_at(0, assert_tensor))

{taichi → gstaichi}/lang/matrix_ops_utils.py

@@ -2,9 +2,9 @@
 
 import functools
 
-from taichi.lang.exception import TaichiCompilationError
-from taichi.lang.expr import Expr
-from taichi.lang.matrix import Matrix
+from gstaichi.lang.exception import GsTaichiCompilationError
+from gstaichi.lang.expr import Expr
+from gstaichi.lang.matrix import Matrix
 
 
 def do_check(checker_fns, *args, **kwargs):
@@ -21,7 +21,7 @@ def preconditions(*checker_funcs):
         def wrapper(*args, **kwargs):
             ok, msg = do_check(checker_funcs, *args, **kwargs)
             if not ok:
-                raise TaichiCompilationError(msg)
+                raise GsTaichiCompilationError(msg)
             return func(*args, **kwargs)
 
         return wrapper

{taichi → gstaichi}/lang/mesh.py

@@ -4,17 +4,17 @@ import json
 
 import numpy as np
 
-from taichi import lang
-from taichi._lib import core as _ti_core
-from taichi.lang import impl
-from taichi.lang.exception import TaichiSyntaxError
-from taichi.lang.field import Field, ScalarField
-from taichi.lang.matrix import Matrix, MatrixField
-from taichi.lang.struct import StructField
-from taichi.lang.util import python_scope
-from taichi.types import u16, u32
-from taichi.types.compound_types import CompoundType
-from taichi.types.enums import Layout
+from gstaichi import lang
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import impl
+from gstaichi.lang.exception import GsTaichiSyntaxError
+from gstaichi.lang.field import Field, ScalarField
+from gstaichi.lang.matrix import Matrix, MatrixField
+from gstaichi.lang.struct import StructField
+from gstaichi.lang.util import python_scope
+from gstaichi.types import u16, u32
+from gstaichi.types.compound_types import CompoundType
+from gstaichi.types.enums import Layout
 
 MeshTopology = _ti_core.MeshTopology
 MeshElementType = _ti_core.MeshElementType
@@ -119,7 +119,7 @@ class MeshElementField:
         layout: ti.Layout.AoS/ti.Layout.SoA
 
         Example::
-        >>> import meshtaichi_patcher as Patcher
+        >>> import meshgstaichi_patcher as Patcher
         >>> vec3 = ti.types.vector(3, ti.f32)
         >>> mesh = Patcher.load_mesh("bunny.obj", relations=['FV'])
         >>> mesh.faces.place({'area' : ti.f32}) # declares a mesh attribute `area` for each face element.
@@ -128,11 +128,11 @@ class MeshElementField:
 
         for key, dtype in members.items():
             if key in {"verts", "edges", "faces", "cells"}:
-                raise TaichiSyntaxError(
-                    f"'{key}' cannot use as attribute name. It has been reserved as MeshTaichi's keyword."
+                raise GsTaichiSyntaxError(
+                    f"'{key}' cannot use as attribute name. It has been reserved as MeshGsTaichi's keyword."
                 )
             if key in self.attr_dict:
-                raise TaichiSyntaxError(f"'{key}' has already use as attribute name.")
+                raise GsTaichiSyntaxError(f"'{key}' has already use as attribute name.")
 
             # init attr type
             self.attr_dict[key] = MeshAttrType(key, dtype, reorder, needs_grad)
@@ -269,8 +269,8 @@ class MeshElement:
         """
         for key, dtype in members.items():
             if key in {"verts", "edges", "faces", "cells"}:
-                raise TaichiSyntaxError(
-                    f"'{key}' cannot use as attribute name. It has been reserved as MeshTaichi's keyword."
+                raise GsTaichiSyntaxError(
+                    f"'{key}' cannot use as attribute name. It has been reserved as MeshGsTaichi's keyword."
                 )
             self.attr_dict[key] = MeshAttrType(key, dtype, reorder, needs_grad)
 
@@ -318,7 +318,7 @@ class MeshInstance:
         """
         if hasattr(self, "_vert_position"):
             return self._vert_position
-        raise TaichiSyntaxError("Position info is not in the file.")
+        raise GsTaichiSyntaxError("Position info is not in the file.")
 
     def set_owned_offset(self, element_type: MeshElementType, owned_offset: ScalarField):
         _ti_core.set_owned_offset(self.mesh_ptr, element_type, owned_offset.vars[0].ptr.snode())
@@ -443,7 +443,7 @@ class MeshMetadata:
 class MeshBuilder:
     def __init__(self):
         if not lang.misc.is_extension_supported(impl.current_cfg().arch, lang.extension.mesh):
-            raise Exception("Backend " + str(impl.current_cfg().arch) + " doesn't support MeshTaichi extension")
+            raise Exception("Backend " + str(impl.current_cfg().arch) + " doesn't support MeshGsTaichi extension")
 
         self.verts = MeshElement(MeshElementType.Vertex, self)
         self.edges = MeshElement(MeshElementType.Edge, self)
@@ -501,11 +501,11 @@ class MeshBuilder:
 class Mesh:
     """The Mesh type class.
 
-    MeshTaichi offers first-class support for triangular/tetrahedral meshes
+    MeshGsTaichi offers first-class support for triangular/tetrahedral meshes
     and allows efficient computation on these irregular data structures,
     only available for backends supporting `ti.extension.mesh`.
 
-    See more details in https://github.com/taichi-dev/meshtaichi
+    See more details in https://github.com/taichi-dev/meshgstaichi
     """
 
     def __init__(self):
@@ -616,7 +616,7 @@ class MeshElementFieldProxy:
                     ),
                 )
             elif isinstance(attr, StructField):
-                raise RuntimeError("MeshTaichi has not support StructField yet")
+                raise RuntimeError("MeshGsTaichi has not support StructField yet")
             else:  # isinstance(attr, Field)
                 var = attr._get_field_members()[0].ptr
                 setattr(

{taichi → gstaichi}/lang/misc.py

@@ -1,22 +1,21 @@
 # type: ignore
 
 import atexit
-import functools
 import os
 import shutil
 import tempfile
 import warnings
 from copy import deepcopy as _deepcopy
 
-from taichi import _logging, _snode, _version_check
-from taichi._lib import core as _ti_core
-from taichi.lang import impl
-from taichi.lang.expr import Expr
-from taichi.lang.impl import axes, get_runtime
-from taichi.profiler.kernel_profiler import get_default_kernel_profiler
-from taichi.types.primitive_types import f32, f64, i32, i64
+from gstaichi import _logging, _snode, _version_check
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import impl
+from gstaichi.lang.expr import Expr
+from gstaichi.lang.impl import axes, get_runtime
+from gstaichi.profiler.kernel_profiler import get_default_kernel_profiler
+from gstaichi.types.primitive_types import f32, f64, i32, i64
 
-warnings.filterwarnings("once", category=DeprecationWarning, module="taichi")
+warnings.filterwarnings("once", category=DeprecationWarning, module="gstaichi")
 
 # ----------------------
 i = axes(0)
@@ -129,37 +128,17 @@ metal = _ti_core.metal
 """
 # ----------------------
 
-opengl = _ti_core.opengl
-"""The OpenGL backend. OpenGL 4.3 required.
-"""
-# ----------------------
-
-gles = _ti_core.gles
-"""The OpenGL ES backend. OpenGL ES 3.1 required.
-"""
-# ----------------------
-
 vulkan = _ti_core.vulkan
 """The Vulkan backend.
 """
 # ----------------------
 
-dx11 = _ti_core.dx11
-"""The DX11 backend.
-"""
-# ----------------------
-
-dx12 = _ti_core.dx12
-"""The DX11 backend.
-"""
-# ----------------------
-
-gpu = [cuda, metal, vulkan, opengl, dx11, dx12, gles, amdgpu]
+gpu = [cuda, metal, vulkan, amdgpu]
 """A list of GPU backends supported on the current system.
-Currently contains 'cuda', 'metal', 'opengl', 'vulkan', 'dx11', 'dx12', 'gles', 'amdgpu'.
+Currently contains 'cuda', 'metal', 'vulkan', 'amdgpu'.
 
-When this is used, Taichi automatically picks the matching GPU backend. If no
-GPU is detected, Taichi falls back to the CPU backend.
+When this is used, GsTaichi automatically picks the matching GPU backend. If no
+GPU is detected, GsTaichi falls back to the CPU backend.
 """
 # ----------------------
 
@@ -167,7 +146,7 @@ cpu = _ti_core.host_arch()
 """A list of CPU backends supported on the current system.
 Currently contains 'x64', 'x86_64', 'arm64'.
 
-When this is used, Taichi automatically picks the matching CPU backend.
+When this is used, GsTaichi automatically picks the matching CPU backend.
 """
 # ----------------------
 
@@ -181,7 +160,7 @@ def timeline_save(fn):
 
 
 extension = _ti_core.Extension
-"""An instance of Taichi extension.
+"""An instance of GsTaichi extension.
 
 The list of currently available extensions is ['sparse', 'quant', \
     'mesh', 'quant_basic', 'data64', 'adstack', 'bls', 'assertion', \
@@ -193,8 +172,8 @@ def is_extension_supported(arch, ext):
     """Checks whether an extension is supported on an arch.
 
     Args:
-        arch (taichi_python.Arch): Specified arch.
-        ext (taichi_python.Extension): Specified extension.
+        arch (gstaichi_python.Arch): Specified arch.
+        ext (gstaichi_python.Extension): Specified extension.
 
     Returns:
         bool: Whether `ext` is supported on `arch`.
@@ -203,7 +182,7 @@ def is_extension_supported(arch, ext):
 
 
 def reset():
-    """Resets Taichi to its initial state.
+    """Resets GsTaichi to its initial state.
     This will destroy all the allocated fields and kernels, and restore
     the runtime to its default configuration.
 
@@ -271,11 +250,11 @@ class _SpecialConfig:
 def prepare_sandbox():
     """
     Returns a temporary directory, which will be automatically deleted on exit.
-    It may contain the taichi_python shared object or some misc. files.
+    It may contain the gstaichi_python shared object or some misc. files.
     """
-    tmp_dir = tempfile.mkdtemp(prefix="taichi-")
+    tmp_dir = tempfile.mkdtemp(prefix="gstaichi-")
     atexit.register(shutil.rmtree, tmp_dir)
-    print(f"[Taichi] preparing sandbox at {tmp_dir}")
+    print(f"[GsTaichi] preparing sandbox at {tmp_dir}")
     os.mkdir(os.path.join(tmp_dir, "runtime/"))
     return tmp_dir
 
@@ -317,7 +296,7 @@ def check_require_version(require_version):
 
     if not match:
         raise Exception(
-            f"Taichi version mismatch. Required version >= {major}.{minor}.{patch}, installed version = {_ti_core.get_version_string()}."
+            f"GsTaichi version mismatch. Required version >= {major}.{minor}.{patch}, installed version = {_ti_core.get_version_string()}."
         )
 
 
@@ -330,32 +309,32 @@ def init(
     require_version=None,
     **kwargs,
 ):
-    """Initializes the Taichi runtime.
+    """Initializes the GsTaichi runtime.
 
-    This should always be the entry point of your Taichi program. Most
+    This should always be the entry point of your GsTaichi program. Most
     importantly, it sets the backend used throughout the program.
 
     Args:
-        arch: Backend to use. This is usually :const:`~taichi.lang.cpu` or :const:`~taichi.lang.gpu`.
+        arch: Backend to use. This is usually :const:`~gstaichi.lang.cpu` or :const:`~gstaichi.lang.gpu`.
         default_fp (Optional[type]): Default floating-point type.
         default_ip (Optional[type]): Default integral type.
         require_version (Optional[string]): A version string.
-        **kwargs: Taichi provides highly customizable compilation through
-            ``kwargs``, which allows for fine grained control of Taichi compiler
+        **kwargs: GsTaichi provides highly customizable compilation through
+            ``kwargs``, which allows for fine grained control of GsTaichi compiler
             behavior. Below we list some of the most frequently used ones. For a
             complete list, please check out
-            https://github.com/taichi-dev/taichi/blob/master/taichi/program/compile_config.h.
+            https://github.com/taichi-dev/gstaichi/blob/master/gstaichi/program/compile_config.h.
 
             * ``cpu_max_num_threads`` (int): Sets the number of threads used by the CPU thread pool.
-            * ``debug`` (bool): Enables the debug mode, under which Taichi does a few more things like boundary checks.
-            * ``print_ir`` (bool): Prints the CHI IR of the Taichi kernels.
-            *``offline_cache`` (bool): Enables offline cache of the compiled kernels. Default to True. When this is enabled Taichi will cache compiled kernel on your local disk to accelerate future calls.
+            * ``debug`` (bool): Enables the debug mode, under which GsTaichi does a few more things like boundary checks.
+            * ``print_ir`` (bool): Prints the CHI IR of the GsTaichi kernels.
+            *``offline_cache`` (bool): Enables offline cache of the compiled kernels. Default to True. When this is enabled GsTaichi will cache compiled kernel on your local disk to accelerate future calls.
             *``random_seed`` (int): Sets the seed of the random generator. The default is 0.
     """
     # Check version for users every 7 days if not disabled by users.
     _version_check.start_version_check_thread()
 
-    # FIXME(https://github.com/taichi-dev/taichi/issues/4811): save the current working directory since it may be
+    # FIXME(https://github.com/taichi-dev/gstaichi/issues/4811): save the current working directory since it may be
     # changed by the Vulkan backend initialization on OS X.
     current_dir = os.getcwd()
 
@@ -448,7 +427,7 @@ def init(
         _logging.info(f"Following TI_ARCH setting up for arch={env_arch}")
         arch = _ti_core.arch_from_name(env_arch)
     cfg.arch = adaptive_arch_select(arch, enable_fallback)
-    print(f"[Taichi] Starting on arch={_ti_core.arch_name(cfg.arch)}")
+    print(f"[GsTaichi] Starting on arch={_ti_core.arch_name(cfg.arch)}")
 
     if _test_mode:
         return spec_cfg
@@ -466,26 +445,26 @@ def init(
     if cfg.debug:
         impl.get_runtime()._register_signal_handlers()
 
-    # Recover the current working directory (https://github.com/taichi-dev/taichi/issues/4811)
+    # Recover the current working directory (https://github.com/taichi-dev/gstaichi/issues/4811)
     os.chdir(current_dir)
     return None
 
 
 def no_activate(*args):
     """Deactivates a SNode pointer."""
-    assert isinstance(get_runtime().compiling_callable, _ti_core.Kernel)
+    assert isinstance(get_runtime().compiling_callable, _ti_core.KernelCxx)
     for v in args:
         get_runtime().compiling_callable.no_activate(v._snode.ptr)
 
 
 def block_local(*args):
-    """Hints Taichi to cache the fields and to enable the BLS optimization.
+    """Hints GsTaichi to cache the fields and to enable the BLS optimization.
 
     Please visit https://docs.taichi-lang.org/docs/performance
     for how BLS is used.
 
     Args:
-        *args (List[Field]): A list of sparse Taichi fields.
+        *args (List[Field]): A list of sparse GsTaichi fields.
     """
     if impl.current_cfg().opt_level == 0:
         _logging.warn("""opt_level = 1 is enforced to enable bls analysis.""")
@@ -502,7 +481,7 @@ def mesh_local(*args):
     and to enable the mesh BLS optimization,
     only available for backends supporting `ti.extension.mesh` and to use with mesh-for loop.
 
-    Related to https://github.com/taichi-dev/taichi/issues/3608
+    Related to https://github.com/taichi-dev/gstaichi/issues/3608
 
     Args:
         *args (List[Attribute]): A list of mesh attributes or fields accessed as attributes.
@@ -703,7 +682,7 @@ def mesh_patch_idx():
     """Returns the internal mesh patch id of this running thread,
     only available for backends supporting `ti.extension.mesh` and to use within mesh-for loop.
 
-    Related to https://github.com/taichi-dev/taichi/issues/3608
+    Related to https://github.com/taichi-dev/gstaichi/issues/3608
     """
     return (
         impl.get_runtime()
@@ -716,7 +695,7 @@ def is_arch_supported(arch):
     """Checks whether an arch is supported on the machine.
 
     Args:
-        arch (taichi_python.Arch): Specified arch.
+        arch (gstaichi_python.Arch): Specified arch.
 
     Returns:
         bool: Whether `arch` is supported on the machine.
@@ -726,11 +705,7 @@ def is_arch_supported(arch):
         cuda: _ti_core.with_cuda,
         amdgpu: _ti_core.with_amdgpu,
         metal: _ti_core.with_metal,
-        opengl: functools.partial(_ti_core.with_opengl, False),
-        gles: functools.partial(_ti_core.with_opengl, True),
         vulkan: _ti_core.with_vulkan,
-        dx11: _ti_core.with_dx11,
-        dx12: _ti_core.with_dx12,
         cpu: lambda: True,
     }
     with_arch = arch_table.get(arch, lambda: False)
@@ -782,16 +757,12 @@ __all__ = [
     "l",
     "x86_64",
     "x64",
-    "dx11",
-    "dx12",
     "arm64",
     "cpu",
     "cuda",
     "amdgpu",
-    "gles",
     "gpu",
     "metal",
-    "opengl",
     "vulkan",
     "extension",
     "loop_config",