coordinate-system 5.2.2__cp313-cp313-win_amd64.whl → 6.0.0__cp313-cp313-win_amd64.whl

coordinate_system/__init__.py

@@ -1,49 +1,60 @@
 # coordinate_system/__init__.py
+"""
+Coordinate System Package
+=========================
+
+A comprehensive 3D coordinate system library with differential geometry support.
+
+Core Components:
+- vec3, vec2: Vector types
+- quat: Quaternion for rotations
+- coord3: 3D coordinate frame
+
+Modules:
+- differential_geometry: Surface curvature computation
+- qframes: Quantum frame algebra
+- visualization: Coordinate system visualization
+- curve_interpolation: Curve and frame interpolation
+"""
 
 from .coordinate_system import vec3, vec2
 from .coordinate_system import quat
 from .coordinate_system import coord3
 
-
-# Coordinate system handedness control (v5.2.1+)
-from .coordinate_system import (
-    set_handedness,
-    get_handedness,
-    is_left_handed,
-    is_right_handed
-)
-# Differential geometry module (v3.3.0+)
+# Differential geometry module (merged from differential_geometry.py and curvature.py)
 from .differential_geometry import (
-    # Classes
+    # Surface classes
     Surface,
     Sphere,
     Torus,
+
+    # Core classes
     MetricTensor,
+    GradientResult,
     IntrinsicGradientOperator,
     IntrinsicGradientCurvatureCalculator,
+    CurvatureCalculator,
 
-    # Main functions
-    compute_intrinsic_gradient,
+    # Intrinsic gradient method functions (default)
     compute_gaussian_curvature,
     compute_mean_curvature,
     compute_riemann_curvature,
     compute_all_curvatures,
-)
+    compute_intrinsic_gradient,
 
-# High-precision curvature computation module (v2.3.0+)
-from .curvature import (
-    # Classical method
-    CurvatureCalculator,
+    # Classical method functions
+    gaussian_curvature_classical,
+    mean_curvature_classical,
+    principal_curvatures_classical,
+    all_curvatures_classical,
+
+    # Backward compatibility aliases
     gaussian_curvature,
     mean_curvature,
     principal_curvatures,
     all_curvatures,
 
-    # Intrinsic Gradient Operator method
-    intrinsic_gradient_gaussian_curvature,
-    intrinsic_gradient_mean_curvature,
-    intrinsic_gradient_principal_curvatures,
-    intrinsic_gradient_all_curvatures,
+    # Method comparison
     compare_methods,
 
     # Utility functions
@@ -52,105 +63,93 @@ from .curvature import (
     richardson_extrapolation,
 )
 
-# Fourier spectral analysis module (v4.0.0+)
-from .fourier_spectral import (
-    # Core Fourier analysis
-    FourierTransformer,
-    SpectralAnalyzer,
-    FrameFieldSpectrum,
+# Quantum frame module (QFrame spectral analysis)
+from .qframes import (
+    # Core classes
+    QFrame,
+    QuantumState,
+    PathIntegral,
+    QFrameSpectrum,
 
-    # GPU accelerated transforms
-    GPUFourierTransformer,
-    BatchCoordTransformer,
+    # Dirac notation export
+    DiracBra,
+    DiracKet,
+    bra,
+    ket,
 
-    # Spectral geometry operations
-    spectral_intrinsic_gradient,
-    spectral_curvature_calculator,
-    berry_phase_calculator,
-    topological_invariant_analyzer,
+    # Convenience functions
+    spectral_transform,
+    inverse_spectral_transform,
 
-    # Utility functions
-    fft2_coord_field,
-    ifft2_spectrum,
-    compute_spectral_density,
-    radial_spectrum_average,
+    # Constants
+    HBAR,
+    GPU_AVAILABLE,
 )
 
-# Visualization module (v5.0.0+)
+# Visualization module
 from .visualization import (
-    # Visualizer classes
     CoordinateSystemVisualizer,
     CurveVisualizer,
     ParametricCurve,
-
-    # Convenience functions
     visualize_coord_system,
     visualize_curve,
 )
 
-# Curve interpolation module (v5.1.0+)
+# Curve interpolation module
 from .curve_interpolation import (
-    # Main class
     InterpolatedCurve,
-
-    # Functions
     generate_frenet_frames,
     frame_field_spline,
     frame_field_spline_c2,
     reconstruct_curve_from_polygon,
     compute_curvature_profile,
-
-    # Utility functions
     catmull_rom,
     squad_interp,
 )
 
 __all__ = [
     # Constants
-    'ZERO3','UNITX','UNITY','UNITZ','ONE3','ONE4','ONEC',
+    'ZERO3', 'UNITX', 'UNITY', 'UNITZ', 'ONE3', 'ONE4', 'ONEC',
 
     # Core types
     'vec3', 'vec2', 'quat', 'coord3', 'lerp',
 
-    # Differential geometry classes (v3.3.0+)
+    # Differential geometry - Surface classes
     'Surface', 'Sphere', 'Torus',
-    'MetricTensor', 'IntrinsicGradientOperator', 'IntrinsicGradientCurvatureCalculator',
 
-    # Differential geometry functions (v3.3.0+)
+    # Differential geometry - Core classes
+    'MetricTensor', 'GradientResult',
+    'IntrinsicGradientOperator', 'IntrinsicGradientCurvatureCalculator',
+    'CurvatureCalculator',
+
+    # Differential geometry - Intrinsic gradient method (default)
+    'compute_gaussian_curvature', 'compute_mean_curvature',
+    'compute_riemann_curvature', 'compute_all_curvatures',
     'compute_intrinsic_gradient',
-    'compute_gaussian_curvature',
-    'compute_mean_curvature',
-    'compute_riemann_curvature',
-    'compute_all_curvatures',
 
-    # High-precision curvature module - Classical method (v2.3.0+)
-    'CurvatureCalculator',
+    # Differential geometry - Classical method
+    'gaussian_curvature_classical', 'mean_curvature_classical',
+    'principal_curvatures_classical', 'all_curvatures_classical',
+
+    # Differential geometry - Backward compatibility
     'gaussian_curvature', 'mean_curvature',
     'principal_curvatures', 'all_curvatures',
 
-    # Intrinsic Gradient Operator method (v2.4.0+)
-    'intrinsic_gradient_gaussian_curvature',
-    'intrinsic_gradient_mean_curvature',
-    'intrinsic_gradient_principal_curvatures',
-    'intrinsic_gradient_all_curvatures',
+    # Differential geometry - Comparison and utilities
     'compare_methods',
-
-    # Utility functions
     'derivative_5pt', 'derivative_2nd_5pt', 'richardson_extrapolation',
 
-    # Fourier spectral analysis (v4.0.0+)
-    'FourierTransformer', 'SpectralAnalyzer', 'FrameFieldSpectrum',
-    'GPUFourierTransformer', 'BatchCoordTransformer',
-    'spectral_intrinsic_gradient', 'spectral_curvature_calculator',
-    'berry_phase_calculator', 'topological_invariant_analyzer',
-    'fft2_coord_field', 'ifft2_spectrum',
-    'compute_spectral_density', 'radial_spectrum_average',
+    # Quantum frame module
+    'QFrame', 'QuantumState', 'PathIntegral', 'QFrameSpectrum',
+    'DiracBra', 'DiracKet', 'bra', 'ket',
+    'spectral_transform', 'inverse_spectral_transform',
+    'HBAR', 'GPU_AVAILABLE',
 
-    # Visualization (v5.0.0+)
+    # Visualization
     'CoordinateSystemVisualizer', 'CurveVisualizer', 'ParametricCurve',
     'visualize_coord_system', 'visualize_curve',
 
-    # Curve interpolation (v5.1.0+)
+    # Curve interpolation
     'InterpolatedCurve', 'generate_frenet_frames', 'frame_field_spline',
     'frame_field_spline_c2', 'reconstruct_curve_from_polygon', 'compute_curvature_profile',
     'catmull_rom', 'squad_interp',
@@ -158,7 +157,7 @@ __all__ = [
 
 # Constants for unit vectors and zero point
 ZERO3 = vec3(0.0, 0.0, 0.0)         # Zero vector (origin point)
-UNITX = vec3(1.0, 0.0, 0.0)         # Unit vector in X direction  
+UNITX = vec3(1.0, 0.0, 0.0)         # Unit vector in X direction
 UNITY = vec3(0.0, 1.0, 0.0)         # Unit vector in Y direction
 UNITZ = vec3(0.0, 0.0, 1.0)         # Unit vector in Z direction
 ONE3  = vec3(1.0, 1.0, 1.0)         # Unit scale vector (1,1,1)
@@ -169,125 +168,93 @@ ONE4 = quat(1.0, 0.0, 0.0, 0.0)
 # World coordinate system (the fundamental unit one in 3D space)
 ONEC = coord3(ZERO3, ONE4, ONE3)
 
+
 def lerp(a: vec3, b: vec3, t: float) -> vec3:
     """
-    Linear interpolation between two points in 3D space
-    
-    The concept of interpolation embodies the metaphysical principle of 
-    continuum - the smooth transition between states that preserves 
-    the fundamental unity of spatial relationships
-    
+    Linear interpolation between two points in 3D space.
+
     Args:
-        a: Starting point (thesis)
-        b: End point (antithesis)  
-        t: Interpolation ratio [0,1] (synthesis parameter)
-        
+        a: Starting point
+        b: End point
+        t: Interpolation ratio [0, 1]
+
     Returns:
-        The interpolated point (synthesis)
+        Interpolated point: a + (b - a) * t
     """
     return a + (b - a) * t
 
+
 class CoordTuple(tuple):
     """
-    Custom tuple subclass that supports operations with coord3 objects
-    
-    This class represents the metaphysical concept of 'potentiality' - 
-    the tuple as pure mathematical form that can interact with the 
-    actualized coordinate system (coord3) to produce new actualities
+    Custom tuple subclass that supports operations with coord3 objects.
     """
-    
+
     def __mul__(self, other):
-        """Multiplication operation supporting coord3 interaction"""
+        """Multiplication operation supporting coord3 interaction."""
         if isinstance(other, coord3):
             return self._mul_coord3(other)
         return super().__mul__(other)
-    
+
     def __rmul__(self, other):
-        """Right multiplication operation supporting coord3 interaction"""
+        """Right multiplication operation supporting coord3 interaction."""
         if isinstance(other, coord3):
             return self._mul_coord3(other)
         return super().__rmul__(other)
-    
+
     def __truediv__(self, other):
-        """Division operation supporting coord3 interaction"""
+        """Division operation supporting coord3 interaction."""
         if isinstance(other, coord3):
             return self._div_coord3(other)
         return super().__truediv__(other)
-    
+
     def _mul_coord3(self, coord: coord3) -> tuple:
-        """
-        Tuple multiplication with coordinate system
-        
-        Represents the metaphysical operation where mathematical forms 
-        (tuple) interact with actualized space (coord3) to produce 
-        new spatial relationships
-        """
+        """Tuple multiplication with coordinate system."""
         if len(self) != 3:
             raise ValueError("Tuple must have exactly 3 elements for spatial operations")
-        
+
         x, y, z = self
         scale_vec = vec3(x, y, z)
         result = scale_vec * coord
         return (result.x, result.y, result.z)
-    
+
     def _div_coord3(self, coord: coord3) -> tuple:
-        """
-        Tuple division with coordinate system
-        
-        The inverse operation of multiplication, representing the 
-        decomposition of spatial relationships into their mathematical 
-        components
-        """
+        """Tuple division with coordinate system."""
         if len(self) != 3:
             raise ValueError("Tuple must have exactly 3 elements for spatial operations")
-        
+
         x, y, z = self
-        # Check for division by zero (preservation of metaphysical integrity)
         if x == 0 or y == 0 or z == 0:
-            raise ZeroDivisionError("Division by zero violates the principle of continuity")
-        
+            raise ZeroDivisionError("Division by zero")
+
         scale_vec = vec3(x, y, z)
         result = scale_vec / coord
         return (result.x, result.y, result.z)
 
-# Store original coord3 operators for metaphysical preservation
+
+# Store original coord3 operators
 _original_coord3_mul = coord3.__mul__
 _original_coord3_rmul = coord3.__rmul__
 _original_coord3_truediv = getattr(coord3, '__truediv__', None)
 
+
 def _new_coord3_mul(self, other):
-    """
-    Enhanced multiplication operator for coord3
-    
-    Enables interaction between actualized coordinate systems (coord3) 
-    and mathematical forms (tuples), embodying the Aristotelian concept 
-    of actuality interacting with potentiality
-    """
+    """Enhanced multiplication operator for coord3."""
     if isinstance(other, tuple):
-        # Transform pure form (tuple) into operational entity (CoordTuple)
         other = CoordTuple(other)
         return other * self
     return _original_coord3_mul(self, other)
 
+
 def _new_coord3_rmul(self, other):
-    """
-    Enhanced right multiplication operator for coord3
-    
-    The commutative property in spatial operations reflects the 
-    metaphysical principle of reciprocity in relationships
-    """
+    """Enhanced right multiplication operator for coord3."""
     if isinstance(other, tuple):
         other = CoordTuple(other)
         return other * self
     return _original_coord3_rmul(self, other)
 
+
 def _new_coord3_truediv(self, other):
-    """
-    Enhanced division operator for coord3
-    
-    Division represents the analytical decomposition of spatial 
-    relationships, revealing the underlying mathematical structure
-    """
+    """Enhanced division operator for coord3."""
     if isinstance(other, tuple):
         other = CoordTuple(other)
         return other / self
@@ -295,7 +262,8 @@ def _new_coord3_truediv(self, other):
         return _original_coord3_truediv(self, other)
     raise TypeError(f"unsupported operand type(s) for /: 'coord3' and {type(other).__name__}")
 
-# Apply metaphysical enhancements to coord3 operators
+
+# Apply enhancements to coord3 operators
 coord3.__mul__ = _new_coord3_mul
 coord3.__rmul__ = _new_coord3_rmul
-coord3.__truediv__ = _new_coord3_truediv
+coord3.__truediv__ = _new_coord3_truediv