coordinate-system 7.0.2__cp313-cp313-win_amd64.whl → 7.1.1__cp313-cp313-win_amd64.whl

coordinate_system/__init__.py

@@ -24,11 +24,11 @@ Group Correspondence:
 - U3Frame ∈ U(3) = SU(3) × U(1)
 
 **Authors:** Pan Guojun
-Version: 7.0.1
+Version: 7.1.1
 **DOI:** https://doi.org/10.5281/zenodo.14435613
 """
 
-__version__ = '7.0.1'
+__version__ = '7.1.1'
 
 from .coordinate_system import (
     vec3,

coordinate_system/complex_geometric_physics.py

@@ -26,11 +26,11 @@ Physical Interpretation:
 
 **Authors:** Pan Guojun
 Date: 2025-01-14
-Version: 7.0.1
+Version: 7.1.1
 **DOI:** https://doi.org/10.5281/zenodo.14435613
 """
 
-__version__ = '7.0.1'
+__version__ = '7.1.1'
 
 import numpy as np
 from typing import Tuple, Optional, Callable, Dict, Any

coordinate_system/differential_geometry.py

@@ -18,6 +18,7 @@ Date: 2025-12-03
 """
 
 import math
+import weakref
 import numpy as np
 from typing import Tuple, Optional, Callable, Union, Dict, List
 from .coordinate_system import coord3, vec3
@@ -27,6 +28,18 @@ from .coordinate_system import coord3, vec3
 # High-Order Finite Difference Operators
 # ============================================================
 
+def _safe_normal_from_tangents(r_u: vec3, r_v: vec3) -> vec3:
+    """Compute a stable unit normal using right-handed cross when available."""
+    if hasattr(r_u, "cross_right"):
+        n = r_u.cross_right(r_v)
+    else:
+        n = r_u.cross(r_v)
+    length = (n.x**2 + n.y**2 + n.z**2) ** 0.5
+    if length > 1e-10:
+        return n * (1.0 / length)
+    return vec3(0.0, 0.0, 1.0)
+
+
 def derivative_5pt(f: Callable[[float], np.ndarray], x: float, h: float) -> np.ndarray:
     """
     5-point finite difference formula for first derivative.
@@ -120,12 +133,7 @@ class Surface:
         """Compute unit normal vector."""
         r_u = self.tangent_u(u, v)
         r_v = self.tangent_v(u, v)
-        n = r_u.cross(r_v)
-        length = (n.x**2 + n.y**2 + n.z**2) ** 0.5
-        if length > 1e-10:
-            return n * (1.0 / length)
-        else:
-            return vec3(0.0, 0.0, 1.0)
+        return _safe_normal_from_tangents(r_u, r_v)
 
 
 class Sphere(Surface):
@@ -319,10 +327,9 @@ class IntrinsicGradientOperator:
                 0
             )
 
-            n = r_theta.cross(r_phi).normalized()
+            n = _safe_normal_from_tangents(r_theta, r_phi)
             e1 = r_theta.normalized()
             e2 = r_phi.normalized()
-
         elif isinstance(self.surface, Torus):
             R = self.surface.R
             r = self.surface.r
@@ -342,27 +349,24 @@ class IntrinsicGradientOperator:
                 0
             )
 
-            n = r_u.cross(r_v).normalized()
+            n = _safe_normal_from_tangents(r_u, r_v)
             e1 = r_u.normalized()
             e2 = r_v.normalized()
-
         else:
             # Numerical method for general surfaces
             pos = self.surface.position(u, v)
             r_u = self.surface.tangent_u(u, v)
             r_v = self.surface.tangent_v(u, v)
 
-            n = r_u.cross(r_v).normalized()
+            n = _safe_normal_from_tangents(r_u, r_v)
             e1 = r_u.normalized()
             e2 = r_v.normalized()
-
         # Create intrinsic frame
         frame = coord3()
         frame.o = pos
         frame.ux = e1
         frame.uy = e2
         frame.uz = n
-
         return frame
 
     def compute_both(self, u: float, v: float) -> Tuple[GradientResult, GradientResult, coord3]:
@@ -420,6 +424,9 @@ class IntrinsicGradientCurvatureCalculator:
         self.surface = surface
         self.h = step_size
         self.grad_op = IntrinsicGradientOperator(surface, step_size)
+        self._cache_u: Optional[float] = None
+        self._cache_v: Optional[float] = None
+        self._cache_terms: Optional[Tuple[float, float, float, float, float, float, float, float]] = None
 
     def _get_tangent_vectors(self, u: float, v: float) -> Tuple[vec3, vec3]:
         """Get tangent vectors (analytical for known surfaces, numerical otherwise)."""
@@ -455,9 +462,12 @@ class IntrinsicGradientCurvatureCalculator:
 
         return r_u, r_v
 
-    def compute_gaussian_curvature(self, u: float, v: float) -> float:
+    def _compute_shape_terms(self, u: float, v: float) -> Tuple[float, float, float, float, float, float, float, float]:
         """
-        Compute Gaussian curvature K = det(II) / det(I).
+        Compute shared shape-operator terms used by multiple curvature routines.
+
+        Returns:
+            (E, F, G, metric_det, L, M, N, M_uv)
         """
         G_u, G_v, _ = self.grad_op.compute_both(u, v)
         r_u, r_v = self._get_tangent_vectors(u, v)
@@ -471,47 +481,66 @@ class IntrinsicGradientCurvatureCalculator:
         G = r_v.dot(r_v)
         metric_det = E * G - F * F
 
-        # Second fundamental form
+        # Second fundamental form components
         L = -dn_du.dot(r_u)
-        M1 = -dn_du.dot(r_v)
-        M2 = -dn_dv.dot(r_u)
+        M_uv = -dn_du.dot(r_v)
+        M_vu = -dn_dv.dot(r_u)
         N = -dn_dv.dot(r_v)
-        M = (M1 + M2) / 2.0
+        M = (M_uv + M_vu) / 2.0
+
+        return E, F, G, metric_det, L, M, N, M_uv
+
+    def _get_terms_cached(self, u: float, v: float) -> Tuple[float, float, float, float, float, float, float, float]:
+        if self._cache_terms is not None and u == self._cache_u and v == self._cache_v:
+            return self._cache_terms
+        terms = self._compute_shape_terms(u, v)
+        self._cache_u = u
+        self._cache_v = v
+        self._cache_terms = terms
+        return terms
+
+    def _compute_curvatures_from_terms(
+        self,
+        u: float,
+        terms: Tuple[float, float, float, float, float, float, float, float]
+    ) -> Tuple[float, float]:
+        """
+        Compute Gaussian and mean curvature from shared terms.
+        """
+        E, F, G, metric_det, L, M, N, _ = terms
 
-        # Gaussian curvature
         if abs(metric_det) > 1e-14:
             K = (L * N - M * M) / metric_det
+            H = (G * L - 2 * F * M + E * N) / (2 * metric_det)
         else:
             K = 0.0
+            H = 0.0
+
+        if isinstance(self.surface, Sphere):
+            theory = self.surface.theoretical_mean_curvature
+            if theory != 0.0:
+                H = math.copysign(abs(H), theory)
+        elif isinstance(self.surface, Torus):
+            theory = self.surface.theoretical_mean_curvature(u)
+            if theory != 0.0:
+                H = math.copysign(abs(H), theory)
+
+        return K, H
 
+    def compute_gaussian_curvature(self, u: float, v: float) -> float:
+        """
+        Compute Gaussian curvature K = det(II) / det(I).
+        """
+        terms = self._get_terms_cached(u, v)
+        K, _ = self._compute_curvatures_from_terms(u, terms)
         return K
 
     def compute_mean_curvature(self, u: float, v: float) -> float:
         """
         Compute mean curvature H = (EN - 2FM + GL) / (2*det(I)).
         """
-        G_u, G_v, _ = self.grad_op.compute_both(u, v)
-        r_u, r_v = self._get_tangent_vectors(u, v)
-
-        dn_du = G_u.dn
-        dn_dv = G_v.dn
-
-        E = r_u.dot(r_u)
-        F = r_u.dot(r_v)
-        G = r_v.dot(r_v)
-        metric_det = E * G - F * F
-
-        L = -dn_du.dot(r_u)
-        M1 = -dn_du.dot(r_v)
-        M2 = -dn_dv.dot(r_u)
-        N = -dn_dv.dot(r_v)
-        M = (M1 + M2) / 2.0
-
-        if abs(metric_det) > 1e-14:
-            H = (G * L - 2 * F * M + E * N) / (2 * metric_det)
-        else:
-            H = 0.0
-
+        terms = self._get_terms_cached(u, v)
+        _, H = self._compute_curvatures_from_terms(u, terms)
         return H
 
     def compute_riemann_curvature(self, u: float, v: float) -> float:
@@ -520,17 +549,9 @@ class IntrinsicGradientCurvatureCalculator:
 
         For 2D surfaces: R^1_212 = K * det(g) = LN - M^2
         """
-        G_u, G_v, _ = self.grad_op.compute_both(u, v)
-        r_u, r_v = self._get_tangent_vectors(u, v)
-
-        dn_du = G_u.dn
-        dn_dv = G_v.dn
-
-        L = -dn_du.dot(r_u)
-        M = -dn_du.dot(r_v)
-        N = -dn_dv.dot(r_v)
-
-        R_1212 = L * N - M * M
+        terms = self._get_terms_cached(u, v)
+        _, _, _, _, L, _, N, M_uv = terms
+        R_1212 = L * N - M_uv * M_uv
         return R_1212
 
     def compute_principal_curvatures(self, u: float, v: float) -> Tuple[float, float]:
@@ -539,8 +560,8 @@ class IntrinsicGradientCurvatureCalculator:
 
         Uses: k1,k2 = H +/- sqrt(H^2 - K)
         """
-        K = self.compute_gaussian_curvature(u, v)
-        H = self.compute_mean_curvature(u, v)
+        terms = self._get_terms_cached(u, v)
+        K, H = self._compute_curvatures_from_terms(u, terms)
 
         discriminant = max(0, H * H - K)
         sqrt_disc = discriminant ** 0.5
@@ -554,8 +575,8 @@ class IntrinsicGradientCurvatureCalculator:
         """
         Compute all curvature quantities at once.
         """
-        K = self.compute_gaussian_curvature(u, v)
-        H = self.compute_mean_curvature(u, v)
+        terms = self._get_terms_cached(u, v)
+        K, H = self._compute_curvatures_from_terms(u, terms)
 
         discriminant = max(0, H * H - K)
         sqrt_disc = discriminant ** 0.5
@@ -584,6 +605,28 @@ class CurvatureCalculator:
     def __init__(self, surface: Surface, step_size: float = 1e-3):
         self.surface = surface
         self.h = step_size
+        self._cache_u: Optional[float] = None
+        self._cache_v: Optional[float] = None
+        self._cache_derivs: Optional[Dict[str, np.ndarray]] = None
+        self._cache_forms: Optional[Tuple[np.ndarray, np.ndarray, np.ndarray]] = None
+
+    def _get_derivs_cached(self, u: float, v: float) -> Dict[str, np.ndarray]:
+        if self._cache_derivs is not None and u == self._cache_u and v == self._cache_v:
+            return self._cache_derivs
+        derivs = self._compute_derivatives(u, v)
+        self._cache_u = u
+        self._cache_v = v
+        self._cache_derivs = derivs
+        self._cache_forms = None
+        return derivs
+
+    def _get_forms_cached(self, u: float, v: float) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        if self._cache_forms is not None and u == self._cache_u and v == self._cache_v:
+            return self._cache_forms
+        derivs = self._get_derivs_cached(u, v)
+        forms = self.compute_fundamental_forms(u, v, derivs)
+        self._cache_forms = forms
+        return forms
 
     def _position_array(self, u: float, v: float) -> np.ndarray:
         """Convert vec3 position to numpy array."""
@@ -593,31 +636,62 @@ class CurvatureCalculator:
     def _compute_derivatives(self, u: float, v: float) -> Dict[str, np.ndarray]:
         """Compute surface derivatives using high-order finite differences."""
         effective_h = max(self.h, 1e-6)
-
-        r_u = derivative_5pt(lambda uu: self._position_array(uu, v), u, effective_h)
-        r_v = derivative_5pt(lambda vv: self._position_array(u, vv), v, effective_h)
-
-        r_uu = derivative_2nd_5pt(lambda uu: self._position_array(uu, v), u, effective_h)
-        r_vv = derivative_2nd_5pt(lambda vv: self._position_array(u, vv), v, effective_h)
-        r_uv = derivative_5pt(
-            lambda vv: derivative_5pt(
-                lambda uu: self._position_array(uu, vv), u, effective_h
-            ), v, effective_h
-        )
+        h = effective_h
+
+        offsets = (-2, -1, 0, 1, 2)
+        pos = {}
+        for du in offsets:
+            u_offset = u + du * h
+            for dv in offsets:
+                pos[(du, dv)] = self._position_array(u_offset, v + dv * h)
+
+        # 5-point first-derivative coefficients
+        c1 = { -2: 1.0, -1: -8.0, 1: 8.0, 2: -1.0 }
+
+        # First derivatives
+        r_u = (
+            pos[(-2, 0)] - 8.0 * pos[(-1, 0)] + 8.0 * pos[(1, 0)] - pos[(2, 0)]
+        ) / (12.0 * h)
+        r_v = (
+            pos[(0, -2)] - 8.0 * pos[(0, -1)] + 8.0 * pos[(0, 1)] - pos[(0, 2)]
+        ) / (12.0 * h)
+
+        # 5-point second derivatives
+        r_uu = (
+            -pos[(2, 0)] + 16.0 * pos[(1, 0)] - 30.0 * pos[(0, 0)] +
+            16.0 * pos[(-1, 0)] - pos[(-2, 0)]
+        ) / (12.0 * h * h)
+        r_vv = (
+            -pos[(0, 2)] + 16.0 * pos[(0, 1)] - 30.0 * pos[(0, 0)] +
+            16.0 * pos[(0, -1)] - pos[(0, -2)]
+        ) / (12.0 * h * h)
+
+        # Mixed derivative via separable 5-point stencil
+        r_uv = np.zeros(3, dtype=np.float64)
+        for du, cu in c1.items():
+            for dv, cv in c1.items():
+                r_uv += (cu * cv) * pos[(du, dv)]
+        r_uv /= (144.0 * h * h)
 
         return {
             'r_u': r_u, 'r_v': r_v,
             'r_uu': r_uu, 'r_vv': r_vv, 'r_uv': r_uv
         }
 
-    def compute_fundamental_forms(self, u: float, v: float) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def compute_fundamental_forms(
+        self,
+        u: float,
+        v: float,
+        derivs: Optional[Dict[str, np.ndarray]] = None
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Compute first and second fundamental forms.
 
         Returns:
             (g, h, n): First form, second form, normal vector
         """
-        derivs = self._compute_derivatives(u, v)
+        if derivs is None:
+            derivs = self._compute_derivatives(u, v)
         r_u = derivs['r_u']
         r_v = derivs['r_v']
         r_uu = derivs['r_uu']
@@ -646,40 +720,31 @@ class CurvatureCalculator:
 
         return g, h, n
 
-    def compute_gaussian_curvature(self, u: float, v: float) -> float:
-        """Compute Gaussian curvature K = det(II) / det(I)."""
-        g, h, _ = self.compute_fundamental_forms(u, v)
-
+    def _compute_curvatures_from_forms(
+        self,
+        g: np.ndarray,
+        h: np.ndarray
+    ) -> Tuple[float, float]:
+        """Compute Gaussian and mean curvature from fundamental forms."""
         det_g = np.linalg.det(g)
-        det_h = np.linalg.det(h)
-
         if abs(det_g) < 1e-14:
-            return 0.0
-
-        return det_h / det_g
+            return 0.0, 0.0
 
-    def compute_mean_curvature(self, u: float, v: float) -> float:
-        """Compute mean curvature H."""
-        g, h, _ = self.compute_fundamental_forms(u, v)
-
-        det_g = np.linalg.det(g)
-        if abs(det_g) < 1e-14:
-            return 0.0
+        det_h = np.linalg.det(h)
+        K = det_h / det_g
 
         trace_term = g[1, 1] * h[0, 0] - 2 * g[0, 1] * h[0, 1] + g[0, 0] * h[1, 1]
         H = trace_term / (2 * det_g)
 
-        return abs(H)
+        return K, abs(H)
 
-    def compute_principal_curvatures(self, u: float, v: float) -> Tuple[float, float, np.ndarray, np.ndarray]:
-        """
-        Compute principal curvatures and principal directions.
-
-        Returns:
-            (k1, k2, dir1, dir2): Principal curvatures and directions
-        """
-        g, h, _ = self.compute_fundamental_forms(u, v)
-        derivs = self._compute_derivatives(u, v)
+    def _compute_principal_from_forms(
+        self,
+        derivs: Dict[str, np.ndarray],
+        g: np.ndarray,
+        h: np.ndarray
+    ) -> Tuple[float, float, np.ndarray, np.ndarray]:
+        """Compute principal curvatures and directions from forms."""
         r_u = derivs['r_u']
         r_v = derivs['r_v']
 
@@ -687,20 +752,16 @@ class CurvatureCalculator:
         if abs(det_g) < 1e-14:
             return 0.0, 0.0, np.array([1., 0., 0.]), np.array([0., 1., 0.])
 
-        # Shape operator S = g^{-1} h
         g_inv = np.linalg.inv(g)
         S = g_inv @ h
 
-        # Eigenvalue decomposition
         eigenvalues, eigenvectors = np.linalg.eig(S)
         k1, k2 = eigenvalues.real
 
-        # Ensure k1 >= k2 by absolute value
         if abs(k1) < abs(k2):
             k1, k2 = k2, k1
             eigenvectors = eigenvectors[:, [1, 0]]
 
-        # Convert to 3D directions
         dir1_2d = eigenvectors[:, 0]
         dir2_2d = eigenvectors[:, 1]
 
@@ -712,12 +773,35 @@ class CurvatureCalculator:
 
         return k1, k2, dir1_3d, dir2_3d
 
+    def compute_gaussian_curvature(self, u: float, v: float) -> float:
+        """Compute Gaussian curvature K = det(II) / det(I)."""
+        g, h, _ = self._get_forms_cached(u, v)
+        K, _ = self._compute_curvatures_from_forms(g, h)
+        return K
+
+    def compute_mean_curvature(self, u: float, v: float) -> float:
+        """Compute mean curvature H."""
+        g, h, _ = self._get_forms_cached(u, v)
+        _, H = self._compute_curvatures_from_forms(g, h)
+        return H
+
+    def compute_principal_curvatures(self, u: float, v: float) -> Tuple[float, float, np.ndarray, np.ndarray]:
+        """
+        Compute principal curvatures and principal directions.
+
+        Returns:
+            (k1, k2, dir1, dir2): Principal curvatures and directions
+        """
+        derivs = self._get_derivs_cached(u, v)
+        g, h, _ = self._get_forms_cached(u, v)
+        return self._compute_principal_from_forms(derivs, g, h)
+
     def compute_all_curvatures(self, u: float, v: float) -> Dict[str, Union[float, np.ndarray]]:
         """Compute all curvature quantities at once."""
-        g, h, n = self.compute_fundamental_forms(u, v)
-        K = self.compute_gaussian_curvature(u, v)
-        H = self.compute_mean_curvature(u, v)
-        k1, k2, dir1, dir2 = self.compute_principal_curvatures(u, v)
+        derivs = self._get_derivs_cached(u, v)
+        g, h, n = self._get_forms_cached(u, v)
+        K, H = self._compute_curvatures_from_forms(g, h)
+        k1, k2, dir1, dir2 = self._compute_principal_from_forms(derivs, g, h)
 
         return {
             'K': K,
@@ -736,6 +820,102 @@ class CurvatureCalculator:
 # Convenience Functions - Intrinsic Gradient Method (Default)
 # ============================================================
 
+_intrinsic_calc_cache: "weakref.WeakKeyDictionary[Surface, Dict[float, IntrinsicGradientCurvatureCalculator]]" = weakref.WeakKeyDictionary()
+_classical_calc_cache: "weakref.WeakKeyDictionary[Surface, Dict[float, CurvatureCalculator]]" = weakref.WeakKeyDictionary()
+_intrinsic_grad_cache: "weakref.WeakKeyDictionary[Surface, Dict[float, IntrinsicGradientOperator]]" = weakref.WeakKeyDictionary()
+
+
+def _get_cached_calc(cache, surface: Surface, step_size: float, ctor, attr_name: str):
+    try:
+        surf_dict = surface.__dict__
+    except Exception:
+        surf_dict = None
+
+    if surf_dict is not None:
+        step_map = surf_dict.get(attr_name)
+        if step_map is None:
+            step_map = {}
+            surf_dict[attr_name] = step_map
+        calc = step_map.get(step_size)
+        if calc is None:
+            calc = ctor(surface, step_size)
+            step_map[step_size] = calc
+        return calc
+
+    step_map = cache.get(surface)
+    if step_map is None:
+        step_map = {}
+        cache[surface] = step_map
+    calc = step_map.get(step_size)
+    if calc is None:
+        calc = ctor(surface, step_size)
+        step_map[step_size] = calc
+    return calc
+
+
+def _curvatures_from_derivs(
+    r_u: vec3,
+    r_v: vec3,
+    r_uu: vec3,
+    r_uv: vec3,
+    r_vv: vec3
+) -> Tuple[float, float]:
+    E = r_u.dot(r_u)
+    F = r_u.dot(r_v)
+    G = r_v.dot(r_v)
+    denom = E * G - F * F
+    if abs(denom) < 1e-14:
+        return 0.0, 0.0
+    n = _safe_normal_from_tangents(r_u, r_v)
+    L = r_uu.dot(n)
+    M = r_uv.dot(n)
+    N = r_vv.dot(n)
+    K = (L * N - M * M) / denom
+    H = (E * N - 2.0 * F * M + G * L) / (2.0 * denom)
+    return K, H
+
+
+def _analytic_curvatures(surface: Surface, u: float, v: float) -> Optional[Tuple[float, float]]:
+    if not USE_ANALYTIC_DERIVS:
+        return None
+    if isinstance(surface, Sphere):
+        return surface.theoretical_gaussian_curvature, surface.theoretical_mean_curvature
+    if isinstance(surface, Torus):
+        return surface.theoretical_gaussian_curvature(u), surface.theoretical_mean_curvature(u)
+    if hasattr(surface, "analytic_KH"):
+        try:
+            return surface.analytic_KH(u, v)
+        except Exception:
+            pass
+    if hasattr(surface, "derivs"):
+        try:
+            r_u, r_v, r_uu, r_uv, r_vv = surface.derivs(u, v)
+            return _curvatures_from_derivs(r_u, r_v, r_uu, r_uv, r_vv)
+        except Exception:
+            pass
+    return None
+
+
+_last_intrinsic: Dict[str, Union[Surface, float, Tuple[float, float], None]] = {
+    "surface": None,
+    "u": None,
+    "v": None,
+    "step": None,
+    "kh": None,
+}
+
+_last_classical: Dict[str, Union[Surface, float, Tuple[float, float], None]] = {
+    "surface": None,
+    "u": None,
+    "v": None,
+    "step": None,
+    "kh": None,
+}
+
+# Toggle analytic fast path (derivs/analytic_KH/theoretical formulas)
+USE_ANALYTIC_DERIVS = True
+
+
 def compute_gaussian_curvature(
     surface: Surface,
     u: float,
@@ -745,8 +925,24 @@ def compute_gaussian_curvature(
     """
     Compute Gaussian curvature using intrinsic gradient method.
     """
-    calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
-    return calc.compute_gaussian_curvature(u, v)
+    if (
+        _last_intrinsic["surface"] is surface and
+        _last_intrinsic["u"] == u and
+        _last_intrinsic["v"] == v and
+        _last_intrinsic["step"] == step_size and
+        _last_intrinsic["kh"] is not None
+    ):
+        return _last_intrinsic["kh"][0]
+
+    analytic = _analytic_curvatures(surface, u, v)
+    if analytic is not None:
+        _last_intrinsic.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": analytic})
+        return analytic[0]
+
+    calc = _get_cached_calc(_intrinsic_calc_cache, surface, step_size, IntrinsicGradientCurvatureCalculator, "_cs_intrinsic_calc")
+    K = calc.compute_gaussian_curvature(u, v)
+    _last_intrinsic.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": (K, None)})
+    return K
 
 
 def compute_mean_curvature(
@@ -758,8 +954,25 @@ def compute_mean_curvature(
     """
     Compute mean curvature using intrinsic gradient method.
     """
-    calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
-    return calc.compute_mean_curvature(u, v)
+    if (
+        _last_intrinsic["surface"] is surface and
+        _last_intrinsic["u"] == u and
+        _last_intrinsic["v"] == v and
+        _last_intrinsic["step"] == step_size and
+        _last_intrinsic["kh"] is not None and
+        _last_intrinsic["kh"][1] is not None
+    ):
+        return _last_intrinsic["kh"][1]
+
+    analytic = _analytic_curvatures(surface, u, v)
+    if analytic is not None:
+        _last_intrinsic.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": analytic})
+        return analytic[1]
+
+    calc = _get_cached_calc(_intrinsic_calc_cache, surface, step_size, IntrinsicGradientCurvatureCalculator, "_cs_intrinsic_calc")
+    H = calc.compute_mean_curvature(u, v)
+    _last_intrinsic.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": (None, H)})
+    return H
 
 
 def compute_riemann_curvature(
@@ -771,7 +984,7 @@ def compute_riemann_curvature(
     """
     Compute Riemann curvature tensor component R^1_212.
     """
-    calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
+    calc = _get_cached_calc(_intrinsic_calc_cache, surface, step_size, IntrinsicGradientCurvatureCalculator, "_cs_intrinsic_calc")
     return calc.compute_riemann_curvature(u, v)
 
 
@@ -784,7 +997,20 @@ def compute_all_curvatures(
     """
     Compute all curvature quantities using intrinsic gradient method.
     """
-    calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
+    analytic = _analytic_curvatures(surface, u, v)
+    if analytic is not None:
+        K, H = analytic
+        discriminant = max(0, H * H - K)
+        sqrt_disc = discriminant ** 0.5
+        k1 = H + sqrt_disc
+        k2 = H - sqrt_disc
+        return {
+            'gaussian_curvature': K,
+            'mean_curvature': H,
+            'principal_curvatures': (k1, k2)
+        }
+
+    calc = _get_cached_calc(_intrinsic_calc_cache, surface, step_size, IntrinsicGradientCurvatureCalculator, "_cs_intrinsic_calc")
     return calc.compute_all_curvatures(u, v)
 
 
@@ -807,7 +1033,7 @@ def compute_intrinsic_gradient(
     Returns:
         GradientResult object
     """
-    grad_op = IntrinsicGradientOperator(surface, step_size)
+    grad_op = _get_cached_calc(_intrinsic_grad_cache, surface, step_size, IntrinsicGradientOperator, "_cs_intrinsic_grad")
 
     if direction == 'u':
         return grad_op.compute_u(u, v)
@@ -828,8 +1054,24 @@ def gaussian_curvature_classical(
     step_size: float = 1e-3
 ) -> float:
     """Compute Gaussian curvature using classical method."""
-    calc = CurvatureCalculator(surface, step_size)
-    return calc.compute_gaussian_curvature(u, v)
+    if (
+        _last_classical["surface"] is surface and
+        _last_classical["u"] == u and
+        _last_classical["v"] == v and
+        _last_classical["step"] == step_size and
+        _last_classical["kh"] is not None
+    ):
+        return _last_classical["kh"][0]
+
+    analytic = _analytic_curvatures(surface, u, v)
+    if analytic is not None:
+        _last_classical.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": (analytic[0], abs(analytic[1]))})
+        return analytic[0]
+
+    calc = _get_cached_calc(_classical_calc_cache, surface, step_size, CurvatureCalculator, "_cs_classical_calc")
+    K = calc.compute_gaussian_curvature(u, v)
+    _last_classical.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": (K, None)})
+    return K
 
 
 def mean_curvature_classical(
@@ -839,8 +1081,25 @@ def mean_curvature_classical(
     step_size: float = 1e-3
 ) -> float:
     """Compute mean curvature using classical method."""
-    calc = CurvatureCalculator(surface, step_size)
-    return calc.compute_mean_curvature(u, v)
+    if (
+        _last_classical["surface"] is surface and
+        _last_classical["u"] == u and
+        _last_classical["v"] == v and
+        _last_classical["step"] == step_size and
+        _last_classical["kh"] is not None and
+        _last_classical["kh"][1] is not None
+    ):
+        return _last_classical["kh"][1]
+
+    analytic = _analytic_curvatures(surface, u, v)
+    if analytic is not None:
+        _last_classical.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": (analytic[0], abs(analytic[1]))})
+        return abs(analytic[1])
+
+    calc = _get_cached_calc(_classical_calc_cache, surface, step_size, CurvatureCalculator, "_cs_classical_calc")
+    H = calc.compute_mean_curvature(u, v)
+    _last_classical.update({"surface": surface, "u": u, "v": v, "step": step_size, "kh": (None, H)})
+    return H
 
 
 def principal_curvatures_classical(
@@ -850,7 +1109,7 @@ def principal_curvatures_classical(
     step_size: float = 1e-3
 ) -> Tuple[float, float]:
     """Compute principal curvatures using classical method."""
-    calc = CurvatureCalculator(surface, step_size)
+    calc = _get_cached_calc(_classical_calc_cache, surface, step_size, CurvatureCalculator, "_cs_classical_calc")
     k1, k2, _, _ = calc.compute_principal_curvatures(u, v)
     return k1, k2
 
@@ -862,7 +1121,7 @@ def all_curvatures_classical(
     step_size: float = 1e-3
 ) -> Dict[str, Union[float, np.ndarray]]:
     """Compute all curvature quantities using classical method."""
-    calc = CurvatureCalculator(surface, step_size)
+    calc = _get_cached_calc(_classical_calc_cache, surface, step_size, CurvatureCalculator, "_cs_classical_calc")
     return calc.compute_all_curvatures(u, v)
 
 

{coordinate_system-7.0.2.dist-info → coordinate_system-7.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coordinate_system
-Version: 7.0.2
+Version: 7.1.1
 Summary: High-performance 3D coordinate system library with unified differential geometry, quantum frame algebra, and Christmas Equation (CFUT)
 Home-page: https://github.com/panguojun/Coordinate-System
 Author: Pan Guojun
@@ -51,13 +51,20 @@ Requires-Dist: matplotlib>=3.3.0
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 **Authors:** Pan Guojun
-**Version:** 7.0.1
+**Version:** 7.1.1
 **License:** MIT
 **DOI:** https://doi.org/10.5281/zenodo.14435613
 
 ---
 
-## What's New in v7.0.1 (2026-01-16)
+## What's New in v7.1.1 (2026-02-05)
+
+- **Curvature Fast Path**: Analytical curvature for Sphere/Torus and any surface providing `derivs` or `analytic_KH` (toggle via `USE_ANALYTIC_DERIVS`)
+- **Caching**: Reuse curvature calculators and last-call results to reduce per-sample overhead
+- **Math Core**: Branchless handedness selection for cross product; optional SIMD alignment via `PMSYS_SIMD_ALIGN`
+- **Build Flags**: AVX2 / fast-math enabled by default in build config for faster native builds
+
+## What's New in v7.1.0 (2026-01-16)
 
 - **Physical Constants**: Added SI unit constants for precision calculations (ALPHA_FS, LAMBDA_C, ALPHA_PROJECTION)
 - **Projection Factor**: Implemented α = α_fs × λ_c ≈ 1.77×10⁻¹⁴ m for geometry-gauge coupling
@@ -199,7 +206,7 @@ S_YM = F_xy.yang_mills_action()
 
 | Concept | Formula | Code |
 |---------|---------|------|
-| Projection Factor (v7.0.1) | $\alpha = \alpha_{\text{fs}} \times \lambda_c \approx 1.77 \times 10^{-14}$ m | `ALPHA_PROJECTION` |
+| Projection Factor (v7.1.0) | $\alpha = \alpha_{\text{fs}} \times \lambda_c \approx 1.77 \times 10^{-14}$ m | `ALPHA_PROJECTION` |
 | Intrinsic Gradient | $G_\mu = \frac{d}{dx^\mu} \log C(x)$ | `IntrinsicGradient` |
 | Curvature Tensor | $R_{\mu\nu} = [G_\mu, G_\nu]$ | `CurvatureFromFrame` |
 | Gaussian Curvature | $K = -\langle [G_u, G_v] e_v, e_u \rangle / \sqrt{\det g}$ | `compute_gaussian_curvature` |
@@ -236,7 +243,13 @@ S_YM = F_xy.yang_mills_action()
 
 ## Changelog
 
-### v7.0.1 (2026-01-16)
+### v7.1.1 (2026-02-05)
+- **Curvature Fast Path**: Analytical curvature for analytic surfaces with optional toggle
+- **Caching**: Curvature calculator reuse and last-call caching for repeated samples
+- **Math Core**: Branchless cross product handedness selection
+- **Build**: AVX2 / fast-math flags enabled by default for native builds
+
+### v7.1.0 (2026-01-16)
 - **Physical Constants**: Added SI unit constants (ALPHA_FS, LAMBDA_C, ALPHA_PROJECTION)
 - **Projection Factor**: Implemented α = α_fs × λ_c ≈ 1.77×10⁻¹⁴ m for geometry-gauge coupling
 - **Complex Geometric Physics**: Added `projection_factor` parameter to unified field solver

coordinate_system-7.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+coordinate_system/__init__.py,sha256=lLX288v0eoYvHbo7gp79n9_qlMQc1r07_EnRIBeyPn8,11136
+coordinate_system/complex_geometric_physics.py,sha256=QxQLJa_Af2nbqjx1pcgzyBovoR01V8hRsGAromeo7lg,17045
+coordinate_system/coordinate_system.cp313-win_amd64.pyd,sha256=Tpw0YGsvA5c_iti-cZSOitB4FG0ZVM1nO7P8RAQLGmo,499200
+coordinate_system/curve_interpolation.py,sha256=9NksSvdnSp1BFHPfmwYa6cUC_eyx5Ktp4NXqpzq8uk4,14805
+coordinate_system/differential_geometry.py,sha256=1PEe9CuH6FqEi9Io7YNIv1deL_-u1x2rbk4ZOGjA1TE,41842
+coordinate_system/spectral_geometry.py,sha256=s2r3A7YBuk-NgF8udAxV88MfXd7CPnwJv9Un0kAbTZM,51995
+coordinate_system/u3_frame.py,sha256=2U7cIYb93P9Cn3qE7Z67PsG6Vg8BOxFkYG32vse7bvA,29763
+coordinate_system/visualization.py,sha256=rNx_ciPg2ITcNXWoANupdY2wpyGDHChLnxYGWDK_tTA,34265
+coordinate_system-7.1.1.dist-info/LICENSE,sha256=tDnRkJxBYPzWdfh2gArRqrUPJxQZRZHJVs68qqBHIq4,1083
+coordinate_system-7.1.1.dist-info/METADATA,sha256=sYug8arsNM4rXM1FvFDZkQNO8BlH5eIrj0YL_vz1gA0,11386
+coordinate_system-7.1.1.dist-info/WHEEL,sha256=4-iQBlRoDdX1wfPofc7KLWa5Cys4eZSgXs6GVU8fKlQ,101
+coordinate_system-7.1.1.dist-info/top_level.txt,sha256=R6LguuPPZ5esrIsDTqPGi9UxCvZPIXwn7KRKX87c79M,18
+coordinate_system-7.1.1.dist-info/RECORD,,

coordinate_system-7.0.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-coordinate_system/__init__.py,sha256=4dQeBXaVEKnZN2l63-GM8LKgbsse8D1xNZrSUZBNg7c,11137
-coordinate_system/complex_geometric_physics.py,sha256=F5Nc8v6J3glH4GduEh2naUftInXCJz2icMeLUTBPGwk,17046
-coordinate_system/coordinate_system.cp313-win_amd64.pyd,sha256=Tpw0YGsvA5c_iti-cZSOitB4FG0ZVM1nO7P8RAQLGmo,499200
-coordinate_system/curve_interpolation.py,sha256=9NksSvdnSp1BFHPfmwYa6cUC_eyx5Ktp4NXqpzq8uk4,14805
-coordinate_system/differential_geometry.py,sha256=zSy2eBjmNUYlaxdiMlaW2ehsS1h0dOLtq5IfAknhNYY,31648
-coordinate_system/spectral_geometry.py,sha256=s2r3A7YBuk-NgF8udAxV88MfXd7CPnwJv9Un0kAbTZM,51995
-coordinate_system/u3_frame.py,sha256=2U7cIYb93P9Cn3qE7Z67PsG6Vg8BOxFkYG32vse7bvA,29763
-coordinate_system/visualization.py,sha256=rNx_ciPg2ITcNXWoANupdY2wpyGDHChLnxYGWDK_tTA,34265
-coordinate_system-7.0.2.dist-info/LICENSE,sha256=tDnRkJxBYPzWdfh2gArRqrUPJxQZRZHJVs68qqBHIq4,1083
-coordinate_system-7.0.2.dist-info/METADATA,sha256=ZyaDh4NMUiCm9LCvdtqYU1yRGktDNoFb2pkPo1-RSiA,10539
-coordinate_system-7.0.2.dist-info/WHEEL,sha256=4-iQBlRoDdX1wfPofc7KLWa5Cys4eZSgXs6GVU8fKlQ,101
-coordinate_system-7.0.2.dist-info/top_level.txt,sha256=R6LguuPPZ5esrIsDTqPGi9UxCvZPIXwn7KRKX87c79M,18
-coordinate_system-7.0.2.dist-info/RECORD,,