coordinate-system 2.5.5__tar.gz → 3.0.0__tar.gz

{coordinate_system-2.5.5/coordinate_system.egg-info → coordinate_system-3.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: coordinate_system
-Version: 2.5.5
-Summary: High-performance 3D coordinate system library with Intrinsic Gradient Operator method for curvature computation, achieving machine-precision accuracy
+Version: 3.0.0
+Summary: High-performance 3D coordinate system library with right-handed conventions, Intrinsic Gradient Operator method for curvature computation, achieving machine-precision accuracy
 Home-page: https://github.com/panguojun/Coordinate-System
 Author: PanGuoJun
 Author-email: 18858146@qq.com
@@ -48,20 +48,27 @@ License-File: LICENSE
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 **Author:** PanGuoJun
-**Version:** 2.4.1
+**Version:** 3.0.0
 **License:** MIT
 
-## 🆕 What's New in v2.4.0
+## 🆕 What's New in v3.0.0
 
-**Critical Fix & Enhancement Release!**
+**Critical Coordinate System Update - Right-Hand System!**
 
-- 🔧 **Fixed Curvature Extraction** - Corrected antisymmetric part extraction: `K = (R_01 - R_10)/(2·det(g))`
-- ✨ **Machine Precision Accuracy** - Gaussian curvature now achieves **0.000% error** on spheres (machine precision)!
-- ✨ **New Convenience Functions** - Added `coord3.identity()`, `coord3.zero()`, `coord3.from_position()`, `coord3.from_rotation()`
-- 📚 **Updated Documentation** - Complete mathematical foundation with verified formulas
-- 🎯 **Removed Experimental Code** - Eliminated incorrect π division hack
+- ⚠️ **BREAKING CHANGE: Right-Hand Coordinate System** - Unified all operations to standard right-hand coordinate system
+  - `vec3.cross()` now uses right-hand rule (standard mathematical definition)
+  - Quaternion rotations follow right-hand convention (counter-clockwise is positive)
+  - `coord3.look_at()` and `coord3.from_forward()` updated accordingly
+  - **Migration Guide:** See [HANDEDNESS_CHANGE.md](HANDEDNESS_CHANGE.md) for details
+  - `cross_left()` method retained for backward compatibility
+- ✅ **Verified Correctness** - Complete test suite validates right-hand system behavior
+- 📚 **Updated Documentation** - All examples and documentation reflect new coordinate system
+- 🎯 **Enhanced Clarity** - Comments and docstrings clarified throughout
 
-**Breaking Change:** Previous versions had ~2.5% error due to incorrect curvature extraction. This version fixes the fundamental formula to achieve theoretical accuracy.
+**Why This Change:**
+1. Mathematical Standard: Right-hand system is the standard in mathematics and physics
+2. Better Interoperability: Compatible with OpenGL, NumPy, SciPy, and most scientific libraries
+3. Improved Readability: Standard cross product formulas match textbook definitions
 
 Perfect for computational geometry, geometric analysis, and discrete differential geometry research!
 
@@ -106,15 +113,8 @@ Perfect for computational geometry, geometric analysis, and discrete differentia
 
 For a comprehensive understanding of the mathematical principles behind coordinate systems, vectors, quaternions, and transformations, see our detailed mathematical guide:
 
-**[📖 Mathematical Foundation of Coordinate Systems](https://github.com/panguojun/Coordinate-System/blob/main/MATHEMATICAL_FOUNDATION.md)**
+**[📖 Mathematical Foundation of Coordinate Systems](https://github.com/panguojun/Coordinate-System)**
 
-This guide covers:
-- Vector mathematics (dot product, cross product, projections)
-- Quaternion theory and applications
-- Coordinate system transformations
-- Euler angles and gimbal lock
-- Interpolation methods (LERP, SLERP, NLERP)
-- Practical applications in graphics, physics, and robotics
 
 ---
 
@@ -192,19 +192,27 @@ lerped = vec3.lerp(v1, v2, 0.5)  # Linear interpolation
 
 ## Coordinate System Type
 
-This library uses a **left-handed coordinate system** for all vector and quaternion operations.
+This library uses a **right-handed coordinate system** for all vector and quaternion operations (as of v3.0.0).
 
 ```
-      +Y
-       |
-       |
-       |
-       +-----> +X
-      /
-     /
-   +Z
+         +Y
+          |
+          |
+          |
+          +-----> +X
+         /
+        /
+      +Z
 ```
 
+**Right-Hand Rule:**
+- Point your right hand's fingers along the +X axis
+- Curl them toward the +Y axis
+- Your thumb points along the +Z axis
+- Cross product: **X × Y = Z** (standard mathematical definition)
+
+**Migration from v2.x:** If your code relied on the previous left-handed system, see [HANDEDNESS_CHANGE.md](HANDEDNESS_CHANGE.md) for migration instructions.
+
 ---
 
 ## API Reference
@@ -425,7 +433,7 @@ v4 = v1 * 5                     # vec3(5, 0, 0)
 
 # Dot and cross products
 dot = v1.dot(v2)                # 0.0 (perpendicular)
-cross = v1.cross(v2)            # vec3(0, 0, 1) in left-handed system
+cross = v1.cross(v2)            # vec3(0, 0, 1) in right-handed system (X × Y = Z)
 
 # Length and normalization
 length = v1.length()            # 1.0

{coordinate_system-2.5.5 → coordinate_system-3.0.0}/README.md

@@ -8,20 +8,27 @@
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 **Author:** PanGuoJun
-**Version:** 2.4.1
+**Version:** 3.0.0
 **License:** MIT
 
-## 🆕 What's New in v2.4.0
+## 🆕 What's New in v3.0.0
 
-**Critical Fix & Enhancement Release!**
+**Critical Coordinate System Update - Right-Hand System!**
 
-- 🔧 **Fixed Curvature Extraction** - Corrected antisymmetric part extraction: `K = (R_01 - R_10)/(2·det(g))`
-- ✨ **Machine Precision Accuracy** - Gaussian curvature now achieves **0.000% error** on spheres (machine precision)!
-- ✨ **New Convenience Functions** - Added `coord3.identity()`, `coord3.zero()`, `coord3.from_position()`, `coord3.from_rotation()`
-- 📚 **Updated Documentation** - Complete mathematical foundation with verified formulas
-- 🎯 **Removed Experimental Code** - Eliminated incorrect π division hack
+- ⚠️ **BREAKING CHANGE: Right-Hand Coordinate System** - Unified all operations to standard right-hand coordinate system
+  - `vec3.cross()` now uses right-hand rule (standard mathematical definition)
+  - Quaternion rotations follow right-hand convention (counter-clockwise is positive)
+  - `coord3.look_at()` and `coord3.from_forward()` updated accordingly
+  - **Migration Guide:** See [HANDEDNESS_CHANGE.md](HANDEDNESS_CHANGE.md) for details
+  - `cross_left()` method retained for backward compatibility
+- ✅ **Verified Correctness** - Complete test suite validates right-hand system behavior
+- 📚 **Updated Documentation** - All examples and documentation reflect new coordinate system
+- 🎯 **Enhanced Clarity** - Comments and docstrings clarified throughout
 
-**Breaking Change:** Previous versions had ~2.5% error due to incorrect curvature extraction. This version fixes the fundamental formula to achieve theoretical accuracy.
+**Why This Change:**
+1. Mathematical Standard: Right-hand system is the standard in mathematics and physics
+2. Better Interoperability: Compatible with OpenGL, NumPy, SciPy, and most scientific libraries
+3. Improved Readability: Standard cross product formulas match textbook definitions
 
 Perfect for computational geometry, geometric analysis, and discrete differential geometry research!
 
@@ -66,15 +73,8 @@ Perfect for computational geometry, geometric analysis, and discrete differentia
 
 For a comprehensive understanding of the mathematical principles behind coordinate systems, vectors, quaternions, and transformations, see our detailed mathematical guide:
 
-**[📖 Mathematical Foundation of Coordinate Systems](https://github.com/panguojun/Coordinate-System/blob/main/MATHEMATICAL_FOUNDATION.md)**
+**[📖 Mathematical Foundation of Coordinate Systems](https://github.com/panguojun/Coordinate-System)**
 
-This guide covers:
-- Vector mathematics (dot product, cross product, projections)
-- Quaternion theory and applications
-- Coordinate system transformations
-- Euler angles and gimbal lock
-- Interpolation methods (LERP, SLERP, NLERP)
-- Practical applications in graphics, physics, and robotics
 
 ---
 
@@ -152,19 +152,27 @@ lerped = vec3.lerp(v1, v2, 0.5)  # Linear interpolation
 
 ## Coordinate System Type
 
-This library uses a **left-handed coordinate system** for all vector and quaternion operations.
+This library uses a **right-handed coordinate system** for all vector and quaternion operations (as of v3.0.0).
 
 ```
-      +Y
-       |
-       |
-       |
-       +-----> +X
-      /
-     /
-   +Z
+         +Y
+          |
+          |
+          |
+          +-----> +X
+         /
+        /
+      +Z
 ```
 
+**Right-Hand Rule:**
+- Point your right hand's fingers along the +X axis
+- Curl them toward the +Y axis
+- Your thumb points along the +Z axis
+- Cross product: **X × Y = Z** (standard mathematical definition)
+
+**Migration from v2.x:** If your code relied on the previous left-handed system, see [HANDEDNESS_CHANGE.md](HANDEDNESS_CHANGE.md) for migration instructions.
+
 ---
 
 ## API Reference
@@ -385,7 +393,7 @@ v4 = v1 * 5                     # vec3(5, 0, 0)
 
 # Dot and cross products
 dot = v1.dot(v2)                # 0.0 (perpendicular)
-cross = v1.cross(v2)            # vec3(0, 0, 1) in left-handed system
+cross = v1.cross(v2)            # vec3(0, 0, 1) in right-handed system (X × Y = Z)
 
 # Length and normalization
 length = v1.length()            # 1.0

{coordinate_system-2.5.5 → coordinate_system-3.0.0}/coordinate_system/__init__.py

@@ -4,7 +4,7 @@ from .coordinate_system import vec3, vec2
 from .coordinate_system import quat
 from .coordinate_system import coord3
 
-# Differential geometry module (v3.0.0+)
+# Differential geometry module (v3.3.0+)
 from .differential_geometry import (
     # Classes
     Surface,
@@ -17,7 +17,8 @@ from .differential_geometry import (
     # Main functions
     compute_intrinsic_gradient,
     compute_gaussian_curvature,
-    compute_curvature_tensor,
+    compute_mean_curvature,
+    compute_riemann_curvature,
     compute_all_curvatures,
 )
 
@@ -30,9 +31,11 @@ from .curvature import (
     principal_curvatures,
     all_curvatures,
 
-    # Lie group method
-    LieGroupCurvatureCalculator,
-    gaussian_curvature_lie,
+    # Intrinsic Gradient Operator method
+    intrinsic_gradient_gaussian_curvature,
+    intrinsic_gradient_mean_curvature,
+    intrinsic_gradient_principal_curvatures,
+    intrinsic_gradient_all_curvatures,
     compare_methods,
 
     # Utility functions
@@ -41,30 +44,34 @@ from .curvature import (
     richardson_extrapolation,
 )
 
-# Intrinsic Gradient Operator method (v2.4.0+)
-# Now imported from curvature module for backward compatibility
-from .curvature import (
-    intrinsic_gradient_gaussian_curvature,
-    intrinsic_gradient_mean_curvature,
-    intrinsic_gradient_principal_curvatures,
-    intrinsic_gradient_all_curvatures,
+# Riemann curvature module (v3.4.0+)
+from .riemann_curvature import (
+    # Classes
+    RiemannCurvatureCalculator,
+
+    # Main functions (renamed to avoid conflicts)
+    compute_riemann_curvature as compute_riemann_curvature_func,
+    compute_gaussian_curvature_riemann,
+    compute_full_riemann_tensor,
+    verify_riemann_properties,
 )
 
 __all__ = [
     # Constants
     'ZERO3','UNITX','UNITY','UNITZ','ONE3','ONE4','ONEC',
-    
+
     # Core types
     'vec3', 'vec2', 'quat', 'coord3', 'lerp',
 
-    # Differential geometry classes (v3.0.0+)
+    # Differential geometry classes (v3.3.0+)
     'Surface', 'Sphere', 'Torus',
     'MetricTensor', 'IntrinsicGradientOperator', 'IntrinsicGradientCurvatureCalculator',
 
-    # Differential geometry functions (v3.0.0+)
+    # Differential geometry functions (v3.3.0+)
     'compute_intrinsic_gradient',
     'compute_gaussian_curvature',
-    'compute_curvature_tensor',
+    'compute_mean_curvature',
+    'compute_riemann_curvature',
     'compute_all_curvatures',
 
     # High-precision curvature module - Classical method (v2.3.0+)
@@ -72,16 +79,19 @@ __all__ = [
     'gaussian_curvature', 'mean_curvature',
     'principal_curvatures', 'all_curvatures',
 
-    # Lie group method (v2.3.0+)
-    'LieGroupCurvatureCalculator',
-    'gaussian_curvature_lie',
-    'compare_methods',
-
-    # Intrinsic Gradient Operator method (v2.4.0+, merged into other modules)
+    # Intrinsic Gradient Operator method (v2.4.0+)
     'intrinsic_gradient_gaussian_curvature',
     'intrinsic_gradient_mean_curvature',
     'intrinsic_gradient_principal_curvatures',
     'intrinsic_gradient_all_curvatures',
+    'compare_methods',
+
+    # Riemann curvature module (v3.4.0+)
+    'RiemannCurvatureCalculator',
+    'compute_riemann_curvature_func',
+    'compute_gaussian_curvature_riemann',
+    'compute_full_riemann_tensor',
+    'verify_riemann_properties',
 
     # Utility functions
     'derivative_5pt', 'derivative_2nd_5pt', 'richardson_extrapolation',

coordinate_system-3.0.0/coordinate_system/curvature.py

@@ -0,0 +1,321 @@
+"""
+High-Precision Discrete Curvature Computation Module
+====================================================
+
+This module provides optimized discrete curvature computation methods
+based on traditional differential geometry with high-order finite differences.
+
+Author: PanGuoJun
+Date: 2025-10-31
+"""
+
+import numpy as np
+from typing import Tuple, Optional, Dict, List, Callable, Union
+from .differential_geometry import (
+    Surface, MetricTensor, IntrinsicGradientOperator, IntrinsicGradientCurvatureCalculator,
+    compute_gaussian_curvature, compute_mean_curvature, compute_all_curvatures
+)
+from .coordinate_system import coord3, vec3
+
+
+# ========== High-Order Finite Difference Operators ==========
+
+def derivative_5pt(f: Callable[[float], np.ndarray], x: float, h: float) -> np.ndarray:
+    """
+    5-point finite difference formula for first derivative
+    """
+    return (-f(x + 2*h) + 8*f(x + h) - 8*f(x - h) + f(x - 2*h)) / (12*h)
+
+
+def derivative_2nd_5pt(f: Callable[[float], np.ndarray], x: float, h: float) -> np.ndarray:
+    """
+    5-point finite difference formula for second derivative
+    """
+    return (-f(x + 2*h) + 16*f(x + h) - 30*f(x) + 16*f(x - h) - f(x - 2*h)) / (12*h*h)
+
+
+def richardson_extrapolation(f_h: float, f_2h: float, order: int = 4) -> float:
+    """
+    Richardson extrapolation for accelerating convergence
+    """
+    return (2**order * f_h - f_2h) / (2**order - 1)
+
+
+# ========== Curvature Computation Class ==========
+
+class CurvatureCalculator:
+    """
+    High-precision discrete curvature calculator using classical differential geometry
+    """
+
+    def __init__(self, surface: Surface, step_size: float = 1e-3):
+        self.surface = surface
+        self.h = step_size
+
+    def _compute_derivatives(self, u: float, v: float) -> Dict[str, np.ndarray]:
+        """使用更稳定的数值导数"""
+        # 避免过小的步长
+        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
+        )
+
+        return {
+            'r_u': r_u, 'r_v': r_v, 
+            'r_uu': r_uu, 'r_vv': r_vv, 'r_uv': r_uv
+        }
+
+    def _position_array(self, u: float, v: float) -> np.ndarray:
+        """Convert vec3 position to numpy array"""
+        pos = self.surface.position(u, v)
+        return np.array([pos.x, pos.y, pos.z])
+
+    def compute_fundamental_forms(self, u: float, v: float) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Compute first and second fundamental forms
+        """
+        derivs = self._compute_derivatives(u, v)
+        r_u = derivs['r_u']
+        r_v = derivs['r_v']
+        r_uu = derivs['r_uu']
+        r_vv = derivs['r_vv']
+        r_uv = derivs['r_uv']
+
+        # First fundamental form
+        E = np.dot(r_u, r_u)
+        F = np.dot(r_u, r_v)
+        G = np.dot(r_v, r_v)
+        g = np.array([[E, F], [F, G]])
+
+        # Normal vector
+        n_vec = np.cross(r_u, r_v)
+        n_norm = np.linalg.norm(n_vec)
+        if n_norm > 1e-14:
+            n = n_vec / n_norm
+        else:
+            n = np.array([0., 0., 1.])
+
+        # Second fundamental form
+        L = np.dot(r_uu, n)
+        M = np.dot(r_uv, n)
+        N = np.dot(r_vv, n)
+        h = np.array([[L, M], [M, N]])
+
+        return g, h, n
+
+    def compute_gaussian_curvature(self, u: float, v: float) -> float:
+        """
+        Compute Gaussian curvature K at a point
+        """
+        g, h, _ = self.compute_fundamental_forms(u, v)
+
+        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
+
+    def compute_mean_curvature(self, u: float, v: float) -> float:
+        """
+        Compute mean curvature H at a point
+        """
+        g, h, _ = self.compute_fundamental_forms(u, v)
+
+        det_g = np.linalg.det(g)
+        if abs(det_g) < 1e-14:
+            return 0.0
+
+        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)
+
+    def compute_principal_curvatures(self, u: float, v: float) -> Tuple[float, float, np.ndarray, np.ndarray]:
+        """
+        Compute principal curvatures and principal directions
+        """
+        g, h, _ = self.compute_fundamental_forms(u, v)
+        derivs = self._compute_derivatives(u, v)
+        r_u = derivs['r_u']
+        r_v = derivs['r_v']
+
+        det_g = np.linalg.det(g)
+        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⁻¹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 tangent plane coordinates to 3D directions
+        dir1_2d = eigenvectors[:, 0]
+        dir2_2d = eigenvectors[:, 1]
+
+        dir1_3d = dir1_2d[0] * r_u + dir1_2d[1] * r_v
+        dir2_3d = dir2_2d[0] * r_u + dir2_2d[1] * r_v
+
+        # Normalize
+        dir1_3d = dir1_3d / (np.linalg.norm(dir1_3d) + 1e-14)
+        dir2_3d = dir2_3d / (np.linalg.norm(dir2_3d) + 1e-14)
+
+        return k1, k2, dir1_3d, dir2_3d
+
+    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)
+
+        return {
+            'K': K,
+            'H': H,
+            'k1': k1,
+            'k2': k2,
+            'dir1': dir1,
+            'dir2': dir2,
+            'g': g,
+            'h': h,
+            'n': n
+        }
+
+
+# ========== Simplified Interface Functions ==========
+
+def gaussian_curvature_classical(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> float:
+    """Compute Gaussian curvature using classical method"""
+    calc = CurvatureCalculator(surface, step_size)
+    return calc.compute_gaussian_curvature(u, v)
+
+def mean_curvature_classical(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> float:
+    """Compute mean curvature using classical method"""
+    calc = CurvatureCalculator(surface, step_size)
+    return calc.compute_mean_curvature(u, v)
+
+def principal_curvatures_classical(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> Tuple[float, float]:
+    """Compute principal curvatures using classical method"""
+    calc = CurvatureCalculator(surface, step_size)
+    k1, k2, _, _ = calc.compute_principal_curvatures(u, v)
+    return k1, k2
+
+def all_curvatures_classical(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> Dict[str, Union[float, np.ndarray]]:
+    """Compute all curvature quantities using classical method"""
+    calc = CurvatureCalculator(surface, step_size)
+    return calc.compute_all_curvatures(u, v)
+
+
+# ========== Intrinsic Gradient Method Functions ==========
+
+def intrinsic_gradient_gaussian_curvature(surface, u, v, step_size=1e-3):
+    """Compute Gaussian curvature using intrinsic gradient method"""
+    return compute_gaussian_curvature(surface, u, v, step_size)
+
+def intrinsic_gradient_mean_curvature(surface, u, v, step_size=1e-3):
+    """Compute mean curvature using intrinsic gradient method"""
+    return compute_mean_curvature(surface, u, v, step_size)
+
+def intrinsic_gradient_principal_curvatures(surface, u, v, step_size=1e-3):
+    """Compute principal curvatures using intrinsic gradient method"""
+    result = compute_all_curvatures(surface, u, v, step_size)
+    return result['principal_curvatures']
+
+def intrinsic_gradient_all_curvatures(surface, u, v, step_size=1e-3):
+    """Compute all curvatures using intrinsic gradient method"""
+    return compute_all_curvatures(surface, u, v, step_size)
+
+
+# ========== Method Comparison ==========
+
+def compare_methods(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> Dict[str, float]:
+    """
+    Compare classical and intrinsic gradient curvature methods
+    """
+    # Classical method
+    K_classical = gaussian_curvature_classical(surface, u, v, step_size)
+    
+    # Intrinsic gradient method
+    K_intrinsic = intrinsic_gradient_gaussian_curvature(surface, u, v, step_size)
+    
+    # Comparison
+    difference = abs(K_classical - K_intrinsic)
+    relative_error = difference / abs(K_classical) if abs(K_classical) > 1e-14 else 0.0
+
+    return {
+        'K_classical': K_classical,
+        'K_intrinsic': K_intrinsic,
+        'difference': difference,
+        'relative_error': relative_error
+    }
+
+
+# ========== Backward Compatibility Functions ==========
+
+def gaussian_curvature(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> float:
+    """Compute Gaussian curvature (default: intrinsic gradient method)"""
+    return intrinsic_gradient_gaussian_curvature(surface, u, v, step_size)
+
+def mean_curvature(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> float:
+    """Compute mean curvature (default: intrinsic gradient method)"""
+    return intrinsic_gradient_mean_curvature(surface, u, v, step_size)
+
+def principal_curvatures(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> Tuple[float, float]:
+    """Compute principal curvatures (default: intrinsic gradient method)"""
+    return intrinsic_gradient_principal_curvatures(surface, u, v, step_size)
+
+def all_curvatures(surface: Surface, u: float, v: float, step_size: float = 1e-3) -> Dict[str, Union[float, np.ndarray]]:
+    """Compute all curvature quantities (default: intrinsic gradient method)"""
+    return intrinsic_gradient_all_curvatures(surface, u, v, step_size)
+
+
+# ========== Export ==========
+
+__all__ = [
+    # Classical method
+    'CurvatureCalculator',
+    'gaussian_curvature_classical',
+    'mean_curvature_classical',
+    'principal_curvatures_classical',
+    'all_curvatures_classical',
+
+    # Intrinsic Gradient Operator method
+    'intrinsic_gradient_gaussian_curvature',
+    'intrinsic_gradient_mean_curvature',
+    'intrinsic_gradient_principal_curvatures',
+    'intrinsic_gradient_all_curvatures',
+    'compare_methods',
+
+    # Backward compatibility (default to intrinsic gradient)
+    'gaussian_curvature',
+    'mean_curvature',
+    'principal_curvatures',
+    'all_curvatures',
+
+    # Utility functions
+    'derivative_5pt',
+    'derivative_2nd_5pt',
+    'richardson_extrapolation',
+]