tensoratlas 0.1.0__py3-none-any.whl

tensoratlas/__init__.py

@@ -0,0 +1,37 @@
+"""Public TensorAtlas package interface."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import Any
+
+from .public_api import (
+    __all__,
+    _LAZY_EXPORTS,
+    chart_property_names,
+    mapping_property_names,
+    resolve_public_attribute,
+)
+
+try:
+    __version__ = version("tensoratlas")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+if "__version__" not in __all__:
+    __all__ = tuple(__all__) + ("__version__",)
+
+
+def __getattr__(name: str) -> Any:
+    value = resolve_public_attribute(__name__, name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_LAZY_EXPORTS))
+
+
+# Matrix simplification guards are intentionally not installed at package import time.
+# Use tensoratlas.symbolic_simplification_policy.install_matrix_simplify_guard
+# explicitly in workflows that need a guarded replacement for broad sympy.simplify calls.

tensoratlas/_internal/sympy_matrix_guard.py

@@ -0,0 +1,53 @@
+"""Opt-in SymPy integration hooks kept outside the public API."""
+
+from __future__ import annotations
+
+import sympy as sp
+
+
+def install_matrix_simplify_guard() -> bool:
+    """Install a bounded matrix simplification guard for compatibility tests.
+
+    This modifies ``sympy.simplify`` and is therefore intentionally internal and
+    opt-in.  Normal TensorAtlas imports never patch SymPy.
+    """
+    try:
+        from ..normal_forms import TNFMatrix
+    except Exception:
+        TNFMatrix = ()
+    if getattr(sp.simplify, "_tensoratlas_matrix_guard", False):
+        return False
+    original_simplify = sp.simplify
+
+    def cheap_matrix_entry_simplify(entry):
+        entry = sp.cancel(entry)
+        try:
+            has_derivative = entry.has(sp.Derivative)
+            has_undefined = any(
+                getattr(node, "is_Function", False) and node.func.__name__ not in {"sin", "cos", "tan", "cot"}
+                for node in entry.atoms(sp.Function)
+            )
+        except Exception:
+            has_derivative = False
+            has_undefined = False
+        if has_derivative or has_undefined:
+            return entry
+        if entry.count_ops() <= 80 and any(entry.has(fn) for fn in (sp.sin, sp.cos, sp.tan, sp.cot)):
+            return sp.trigsimp(entry)
+        return entry
+
+    def guarded_simplify(expr, *args, **kwargs):
+        if TNFMatrix != () and isinstance(expr, TNFMatrix):
+            if all(entry == 0 for entry in expr):
+                return sp.zeros(expr.rows, expr.cols)
+            return sp.Matrix(expr.rows, expr.cols, lambda row, col: cheap_matrix_entry_simplify(expr[row, col]))
+        if isinstance(expr, sp.MatrixBase):
+            entries = list(expr)
+            if all(entry == 0 for entry in entries):
+                return sp.zeros(expr.rows, expr.cols)
+            return expr.applyfunc(cheap_matrix_entry_simplify)
+        return original_simplify(expr, *args, **kwargs)
+
+    guarded_simplify._tensoratlas_matrix_guard = True
+    sp.simplify = guarded_simplify
+    return True