HPFRACC

Main Documentation:

  • Core Features and Testing Status
    • Production Readiness Status
    • Core Features Overview
      • Mathematical Foundations
    • Integration Testing Results
      • Phase 1: Core Mathematical Integration
      • Phase 2: ML Neural Network Integration
      • Phase 3: GPU Performance Integration
      • Phase 4: End-to-End Workflows
      • Phase 5: Performance Benchmarks
    • Module Coverage Status
      • Core Module
      • Special Functions Module
      • ML Module
      • Algorithms Module
      • Validation Module
      • Utils Module
    • Research Readiness Assessment
      • Computational Physics Applications
      • Biophysics Applications
      • Machine Learning Integration
    • Performance Characteristics
      • Computational Performance
      • Scalability
    • Technical Specifications
      • Supported Fractional Orders
      • Backend Support
      • Mathematical Definitions
    • Quality Assurance
      • Code Quality
      • Testing Methodology
    • Known Limitations
      • Minor Issues
    • Summary
  • Advanced Features
    • Intelligent Backend Selection (v2.2.0)
      • Automatic Optimization
      • Performance Learning
      • Key Benefits
    • GPU Acceleration
      • Full GPU Support
      • GPU Optimization Features
      • Performance Benchmarks
    • Multi-Backend Support
      • Supported Backends
      • Backend Management
      • Intelligent Selection
    • Performance Optimization
      • Memory Optimization
      • Parallel Processing
      • Scalability Features
    • Advanced Optimizations
      • Spectral Domain Computation
      • Chunked FFT Processing
      • Variance-Aware Training
    • Summary
  • Installation and Quick Start
    • Basic Installation
    • Installation with GPU Support
    • Installation with Machine Learning Dependencies
    • Development Installation
    • Requirements
    • GPU Setup Details
      • JAX GPU Configuration
      • CuDNN Compatibility
      • CUDA Version Compatibility
    • Quick Start Examples
      • Basic Fractional Derivative
      • Spectral Autograd with PyTorch
      • Learnable Fractional Orders
      • Intelligent Backend Selection
    • Verification
      • Check Installation
      • Check GPU Availability
    • Troubleshooting Installation
      • Common Issues
    • Next Steps
  • Basic Examples
    • Basic Fractional Derivatives
      • Computing Fractional Derivatives
      • Using Simplified API
    • Fractional Integrals
      • Computing Fractional Integrals
      • Using API Functions
    • Comparison with Analytical Solutions
      • Validating Numerical Accuracy
    • Error Analysis and Convergence
      • Convergence Study
    • Special Functions
      • Working with Special Functions
    • Mathematical Utilities
      • Using Utility Functions
    • Summary
    • Next Steps
  • Advanced Examples
    • Signal Processing Applications
      • Fractional Signal Analysis
    • Image Processing Applications
      • Fractional Image Filtering
    • Fractional Neural Networks
      • Basic Fractional Neural Network
    • Fractional Graph Neural Networks
      • Graph Convolution with Fractional Calculus
    • Performance Benchmarking
      • Comparing Different Backends
    • Summary
    • Next Steps
  • Integrals and Derivatives
    • Classical Fractional Derivatives
      • Riemann-Liouville Derivative
      • Caputo Derivative
      • Grünwald-Letnikov Derivative
    • Novel Fractional Derivatives
      • Caputo-Fabrizio Derivative
      • Atangana-Baleanu Derivative
    • Advanced Methods
      • Weyl Derivative
      • Marchaud Derivative
      • Hadamard Derivative
      • Riesz-Feller Derivative
    • Special Operators
      • Fractional Laplacian
      • Fractional Fourier Transform
      • Riesz-Fisher Operator
    • Fractional Integrals
      • Available Integral Types
    • Usage Examples
      • Basic Usage Pattern
      • Advanced Usage with Parallel Processing
    • Autograd Fractional Derivatives (ML)
    • Performance Considerations
      • Method Selection Guidelines
      • Optimization Tips
    • Mathematical Properties
      • Key Properties
      • Convergence and Stability
    • Summary
    • Next Steps
  • Fractional Neural Networks
    • Overview
    • Spectral Autograd Framework
      • Basic Usage
      • Engine Types
    • Stochastic Memory Sampling
      • Basic Usage
      • Sampling Methods
    • Probabilistic Fractional Orders
      • Basic Usage
      • Distribution Types
    • Neural Fractional ODE Framework
      • Basic Usage
      • Fractional Neural ODE
    • Complete Examples
      • Training Example
    • GPU Optimization
    • Summary
    • Next Steps
  • Fractional Graph Neural Networks
    • Overview
    • Basic Usage
      • Fractional Graph Convolution
    • Architecture Types
      • Graph Convolutional Network (GCN)
      • Graph Attention Network (GAT)
      • GraphSAGE
    • Complete Example
      • Full GNN Model
    • Backend Selection
      • Multi-Backend Support
    • Performance Benchmarking
    • Summary
    • Next Steps
  • Neural Fractional ODEs and SDEs
    • Neural Fractional ODEs
      • Quick Start
      • Fractional Neural ODE
    • Neural Fractional SDEs
      • Introduction
      • Mathematical Foundation
      • Basic Usage
      • Training Example
      • Fractional Orders in SDEs
      • Drift and Diffusion Functions
    • Stochastic Noise Modeling
    • Adjoint Training Methods
    • Summary
    • Next Steps
  • Scientific Applications and Tutorials
    • Performance Optimization Guide
      • Intelligent Backend Selection
      • Performance Benchmarks
    • Error Analysis and Validation
      • Numerical Error Analysis
      • Convergence Analysis
    • Physics and Scientific Examples
      • Computational Physics
      • Biophysics Applications
    • Researchers’ Quick Start Guide
      • Installation
      • Quick Verification
    • Scientific Tutorials
    • Summary
    • Next Steps
  • Advanced Usage
    • Configuration and Settings
      • Precision Settings
      • Logging Configuration
    • Backend Configuration
      • Manual Backend Selection
      • Environment Variables
    • Troubleshooting
      • Common Issues
    • GPU Troubleshooting
      • JAX GPU Setup
      • PyTorch GPU Verification
    • Best Practices
      • Code Organization
      • Error Handling
      • Performance Optimization
    • Backend Optimization
      • Intelligent Selection
    • Known Limitations
      • Solver Limitations
      • Backend Support
    • Summary
    • Next Steps
  • Theoretical Foundations
    • Mathematical Theory
      • Fractional Calculus Fundamentals
      • Key Properties
    • Model Theory
      • Neural Network Integration
      • Autograd Implementation
    • Fractional Operator Theory
      • Special Functions
    • Convergence and Stability
      • Numerical Stability
      • Convergence Analysis
    • Neural fSDE Theory
      • Stochastic Differential Equations
      • Solution Methods
    • Complete Mathematical Reference
    • Summary
    • Next Steps

API Reference:

  • API Reference
    • Sectional API References
      • Core and Fundamentals
      • Derivatives and Integrals
      • Solvers
      • Fractional Neural Networks
      • Fractional Graph Neural Networks
      • Neural ODEs and SDEs
      • Special Methods
    • Complete Module Reference
  • Core API Reference
    • Fractional Order Definitions
      • FractionalOrder
        • FractionalOrder.__init__()
        • FractionalOrder._validate()
        • FractionalOrder.value
        • FractionalOrder.is_integer
        • FractionalOrder.is_fractional
        • FractionalOrder.integer_part
        • FractionalOrder.fractional_part
      • DefinitionType
        • DefinitionType.CAPUTO
        • DefinitionType.RIEMANN_LIOUVILLE
        • DefinitionType.GRUNWALD_LETNIKOV
        • DefinitionType.MILLER_ROSS
        • DefinitionType.WEYL
        • DefinitionType.MARCHAUD
      • FractionalDefinition
        • FractionalDefinition.__init__()
        • FractionalDefinition.get_definition_formula()
        • FractionalDefinition.get_properties()
      • CaputoDefinition
        • CaputoDefinition.__init__()
        • CaputoDefinition.n
        • CaputoDefinition.get_advantages()
        • CaputoDefinition.get_limitations()
      • RiemannLiouvilleDefinition
        • RiemannLiouvilleDefinition.__init__()
        • RiemannLiouvilleDefinition.n
        • RiemannLiouvilleDefinition.get_advantages()
        • RiemannLiouvilleDefinition.get_limitations()
      • GrunwaldLetnikovDefinition
        • GrunwaldLetnikovDefinition.__init__()
        • GrunwaldLetnikovDefinition.get_advantages()
        • GrunwaldLetnikovDefinition.get_limitations()
      • FractionalIntegral
        • FractionalIntegral.__init__()
        • FractionalIntegral.get_formula()
        • FractionalIntegral.get_properties()
      • FractionalCalculusProperties
        • FractionalCalculusProperties.linearity_property()
        • FractionalCalculusProperties.semigroup_property()
        • FractionalCalculusProperties.leibniz_rule()
        • FractionalCalculusProperties.chain_rule()
        • FractionalCalculusProperties.relationship_between_definitions()
        • FractionalCalculusProperties.get_analytical_solutions()
        • FractionalCalculusProperties.get_properties()
        • FractionalCalculusProperties.get_definition_properties()
        • FractionalCalculusProperties.get_integral_properties()
      • create_definition()
      • get_available_definitions()
      • validate_fractional_order()
    • Core Utilities
      • _get_torch()
      • factorial_fractional()
      • binomial_coefficient()
      • pochhammer_symbol()
      • _hypergeometric_series_impl()
      • hypergeometric_series()
      • bessel_function_first_kind()
      • modified_bessel_function_first_kind()
      • validate_fractional_order()
      • validate_function()
      • validate_tensor_input()
      • timing_decorator()
      • memory_usage_decorator()
      • PerformanceMonitor
        • PerformanceMonitor.__init__()
        • PerformanceMonitor.start_timer()
        • PerformanceMonitor.end_timer()
        • PerformanceMonitor.get_statistics()
        • PerformanceMonitor.timer()
        • PerformanceMonitor.memory_tracker()
        • PerformanceMonitor.reset()
      • TimerContext
        • TimerContext.__init__()
      • MemoryTrackerContext
        • MemoryTrackerContext.__init__()
      • FractionalCalculusError
      • ConvergenceError
      • ValidationError
      • safe_divide()
      • check_numerical_stability()
      • vectorize_function()
      • normalize_array()
      • smooth_function()
      • fractional_power()
      • fractional_exponential()
      • get_default_precision()
      • set_default_precision()
      • get_available_methods()
      • get_method_properties()
      • setup_logging()
      • get_logger()
    • Main Module
      • OptimizedRiemannLiouville
        • OptimizedRiemannLiouville.__init__()
        • OptimizedRiemannLiouville.compute()
      • OptimizedCaputo
        • OptimizedCaputo.__init__()
        • OptimizedCaputo.compute()
      • OptimizedGrunwaldLetnikov
        • OptimizedGrunwaldLetnikov.compute()
      • optimized_riemann_liouville()
      • FractionalOrder
        • FractionalOrder.__init__()
        • FractionalOrder._validate()
        • FractionalOrder.value
        • FractionalOrder.is_integer
        • FractionalOrder.is_fractional
        • FractionalOrder.integer_part
        • FractionalOrder.fractional_part
      • WeylDerivative
        • WeylDerivative.__init__()
        • WeylDerivative.compute()
        • WeylDerivative._compute_serial()
        • WeylDerivative._compute_parallel()
        • WeylDerivative._process_chunk()
      • MarchaudDerivative
        • MarchaudDerivative.__init__()
        • MarchaudDerivative.compute()
        • MarchaudDerivative._compute_memory_optimized()
        • MarchaudDerivative._process_marchaud_chunk()
        • MarchaudDerivative._compute_marchaud_segment()
        • MarchaudDerivative._compute_standard()
      • FractionalLaplacian
        • FractionalLaplacian.__init__()
        • FractionalLaplacian.compute()
        • FractionalLaplacian._spectral_method()
        • FractionalLaplacian._finite_difference_method()
        • FractionalLaplacian.compute_numerical()
        • FractionalLaplacian._integral_method()
        • FractionalLaplacian._grunwald_coefficients()
      • FractionalFourierTransform
        • FractionalFourierTransform.__init__()
        • FractionalFourierTransform.transform()
        • FractionalFourierTransform.compute()
        • FractionalFourierTransform._discrete_method()
        • FractionalFourierTransform._fft_based_method()
        • FractionalFourierTransform._chirp_based_method()
        • FractionalFourierTransform._spectral_method()
        • FractionalFourierTransform.compute_numerical()
        • FractionalFourierTransform._compute_transform_matrix()
        • FractionalFourierTransform._hermite_decomposition()
        • FractionalFourierTransform._hermite_function()
        • FractionalFourierTransform._fractional_hermite()
        • FractionalFourierTransform._fast_approximation()
      • RiemannLiouvilleIntegral
        • RiemannLiouvilleIntegral.__init__()
        • RiemannLiouvilleIntegral.compute()
        • RiemannLiouvilleIntegral._coerce_function()
        • RiemannLiouvilleIntegral._compute_scalar()
        • RiemannLiouvilleIntegral._compute_array_numpy()
        • RiemannLiouvilleIntegral._compute_array_torch()
      • CaputoIntegral
        • CaputoIntegral.__init__()
        • CaputoIntegral._coerce_function()
        • CaputoIntegral.compute()
      • CaputoFabrizioDerivative
        • CaputoFabrizioDerivative.__init__()
        • CaputoFabrizioDerivative.compute()
        • CaputoFabrizioDerivative.compute_numerical()
      • AtanganaBaleanuDerivative
        • AtanganaBaleanuDerivative.__init__()
        • AtanganaBaleanuDerivative.compute()
        • AtanganaBaleanuDerivative.compute_numerical()
      • Caputo
      • CaputoDerivative
        • CaputoDerivative.__init__()
        • CaputoDerivative.compute()
        • CaputoDerivative.compute_numerical()
      • HadamardDerivative
        • HadamardDerivative.__init__()
        • HadamardDerivative.compute()
        • HadamardDerivative._compute_hadamard()
      • ReizFellerDerivative
        • ReizFellerDerivative.__init__()
        • ReizFellerDerivative.compute()
        • ReizFellerDerivative._compute_spectral()
      • FractionalZTransform
        • FractionalZTransform.__init__()
        • FractionalZTransform.transform()
        • FractionalZTransform._direct_method()
        • FractionalZTransform._fft_method()
        • FractionalZTransform.inverse_transform()
        • FractionalZTransform._contour_integration()
        • FractionalZTransform._residue_method()
      • FractionalMellinTransform
        • FractionalMellinTransform.__init__()
        • FractionalMellinTransform.transform()
        • FractionalMellinTransform._numerical_method()
        • FractionalMellinTransform._analytical_method()
        • FractionalMellinTransform._fft_method()
        • FractionalMellinTransform.inverse_transform()
        • FractionalMellinTransform._inverse_numerical()
        • FractionalMellinTransform._inverse_fft()
  • Derivatives and Integrals API Reference
    • Core Derivatives
      • BaseFractionalDerivative
        • BaseFractionalDerivative.__init__()
        • BaseFractionalDerivative._validate_parameters()
        • BaseFractionalDerivative.compute()
        • BaseFractionalDerivative.compute_numerical()
        • BaseFractionalDerivative.get_definition_info()
      • FractionalDerivativeOperator
        • FractionalDerivativeOperator.__init__()
        • FractionalDerivativeOperator.compute_numerical()
        • FractionalDerivativeOperator.set_implementation()
        • FractionalDerivativeOperator.get_info()
      • FractionalDerivativeFactory
        • FractionalDerivativeFactory.__init__()
        • FractionalDerivativeFactory.register_implementation()
        • FractionalDerivativeFactory.create()
        • FractionalDerivativeFactory.get_available_implementations()
      • FractionalDerivativeChain
        • FractionalDerivativeChain.__init__()
        • FractionalDerivativeChain._validate_chain()
        • FractionalDerivativeChain.compute()
        • FractionalDerivativeChain.get_total_order()
        • FractionalDerivativeChain.get_chain_info()
      • FractionalDerivativeProperties
        • FractionalDerivativeProperties.check_linearity()
        • FractionalDerivativeProperties.check_semigroup_property()
        • FractionalDerivativeProperties.get_analytical_solutions()
      • create_fractional_derivative()
      • create_derivative_operator()
      • caputo()
      • riemann_liouville()
      • grunwald_letnikov()
    • Optimized Methods
      • _jnp_gradient_edge_order_2()
      • _fast_binomial_coefficients_numpy()
      • _grunwald_letnikov_numpy()
      • _riemann_liouville_numpy()
      • _caputo_numpy()
      • FractionalOperator
        • FractionalOperator.__init__()
        • FractionalOperator.compute()
      • OptimizedGrunwaldLetnikov
        • OptimizedGrunwaldLetnikov.compute()
      • OptimizedRiemannLiouville
        • OptimizedRiemannLiouville.__init__()
        • OptimizedRiemannLiouville.compute()
      • OptimizedCaputo
        • OptimizedCaputo.__init__()
        • OptimizedCaputo.compute()
      • ParallelOptimizedRiemannLiouville
      • ParallelOptimizedCaputo
      • ParallelOptimizedGrunwaldLetnikov
      • ParallelPerformanceMonitor
      • NumbaOptimizer
      • NumbaFractionalKernels
      • optimized_riemann_liouville()
      • optimized_caputo()
      • optimized_grunwald_letnikov()
      • OptimizedFractionalMethods
      • ParallelConfig
        • ParallelConfig.__init__()
      • AdvancedFFTMethods
        • AdvancedFFTMethods.__init__()
        • AdvancedFFTMethods.compute_derivative()
      • L1L2Schemes
      • ParallelLoadBalancer
      • parallel_optimized_riemann_liouville()
      • parallel_optimized_caputo()
      • parallel_optimized_grunwald_letnikov()
    • Advanced Methods
      • WeylDerivative
        • WeylDerivative.__init__()
        • WeylDerivative.compute()
        • WeylDerivative._compute_serial()
        • WeylDerivative._compute_parallel()
        • WeylDerivative._process_chunk()
      • MarchaudDerivative
        • MarchaudDerivative.__init__()
        • MarchaudDerivative.compute()
        • MarchaudDerivative._compute_memory_optimized()
        • MarchaudDerivative._process_marchaud_chunk()
        • MarchaudDerivative._compute_marchaud_segment()
        • MarchaudDerivative._compute_standard()
      • HadamardDerivative
        • HadamardDerivative.__init__()
        • HadamardDerivative.compute()
        • HadamardDerivative._compute_hadamard()
      • ReizFellerDerivative
        • ReizFellerDerivative.__init__()
        • ReizFellerDerivative.compute()
        • ReizFellerDerivative._compute_spectral()
      • AdomianDecomposition
        • AdomianDecomposition.__init__()
        • AdomianDecomposition.solve()
        • AdomianDecomposition._compute_terms_serial()
        • AdomianDecomposition._compute_terms_parallel()
        • AdomianDecomposition._compute_adomian_polynomial()
        • AdomianDecomposition._compute_integral_term()
        • AdomianDecomposition._compute_single_term()
      • weyl_derivative()
      • marchaud_derivative()
      • hadamard_derivative()
      • reiz_feller_derivative()
      • OptimizedWeylDerivative
        • OptimizedWeylDerivative.__init__()
      • OptimizedMarchaudDerivative
        • OptimizedMarchaudDerivative.__init__()
      • OptimizedHadamardDerivative
        • OptimizedHadamardDerivative.__init__()
      • OptimizedReizFellerDerivative
        • OptimizedReizFellerDerivative.__init__()
      • OptimizedAdomianDecomposition
        • OptimizedAdomianDecomposition.__init__()
      • optimized_weyl_derivative()
      • optimized_marchaud_derivative()
      • optimized_hadamard_derivative()
      • optimized_reiz_feller_derivative()
    • Special Methods
      • _factorial()
      • FractionalLaplacian
        • FractionalLaplacian.__init__()
        • FractionalLaplacian.compute()
        • FractionalLaplacian._spectral_method()
        • FractionalLaplacian._finite_difference_method()
        • FractionalLaplacian.compute_numerical()
        • FractionalLaplacian._integral_method()
        • FractionalLaplacian._grunwald_coefficients()
      • FractionalFourierTransform
        • FractionalFourierTransform.__init__()
        • FractionalFourierTransform.transform()
        • FractionalFourierTransform.compute()
        • FractionalFourierTransform._discrete_method()
        • FractionalFourierTransform._fft_based_method()
        • FractionalFourierTransform._chirp_based_method()
        • FractionalFourierTransform._spectral_method()
        • FractionalFourierTransform.compute_numerical()
        • FractionalFourierTransform._compute_transform_matrix()
        • FractionalFourierTransform._hermite_decomposition()
        • FractionalFourierTransform._hermite_function()
        • FractionalFourierTransform._fractional_hermite()
        • FractionalFourierTransform._fast_approximation()
      • FractionalZTransform
        • FractionalZTransform.__init__()
        • FractionalZTransform.transform()
        • FractionalZTransform._direct_method()
        • FractionalZTransform._fft_method()
        • FractionalZTransform.inverse_transform()
        • FractionalZTransform._contour_integration()
        • FractionalZTransform._residue_method()
      • FractionalMellinTransform
        • FractionalMellinTransform.__init__()
        • FractionalMellinTransform.transform()
        • FractionalMellinTransform._numerical_method()
        • FractionalMellinTransform._analytical_method()
        • FractionalMellinTransform._fft_method()
        • FractionalMellinTransform.inverse_transform()
        • FractionalMellinTransform._inverse_numerical()
        • FractionalMellinTransform._inverse_fft()
      • fractional_laplacian()
      • fractional_fourier_transform()
      • fractional_z_transform()
      • fractional_mellin_transform()
      • SpecialMethodsConfig
        • SpecialMethodsConfig.__init__()
      • SpecialOptimizedWeylDerivative
        • SpecialOptimizedWeylDerivative.__init__()
        • SpecialOptimizedWeylDerivative._determine_optimal_method()
        • SpecialOptimizedWeylDerivative.compute()
        • SpecialOptimizedWeylDerivative._compute_frft()
        • SpecialOptimizedWeylDerivative._compute_standard_fft()
        • SpecialOptimizedWeylDerivative._compute_hybrid()
        • SpecialOptimizedWeylDerivative._compute_weyl_kernel()
      • SpecialOptimizedMarchaudDerivative
        • SpecialOptimizedMarchaudDerivative.__init__()
        • SpecialOptimizedMarchaudDerivative.compute()
        • SpecialOptimizedMarchaudDerivative._compute_z_transform()
        • SpecialOptimizedMarchaudDerivative._compute_standard()
      • SpecialOptimizedReizFellerDerivative
        • SpecialOptimizedReizFellerDerivative.__init__()
        • SpecialOptimizedReizFellerDerivative.compute()
        • SpecialOptimizedReizFellerDerivative._compute_laplacian()
        • SpecialOptimizedReizFellerDerivative._compute_spectral()
      • UnifiedSpecialMethods
        • UnifiedSpecialMethods.__init__()
        • UnifiedSpecialMethods.compute_derivative()
        • UnifiedSpecialMethods._auto_select_method()
      • special_optimized_weyl_derivative()
      • special_optimized_marchaud_derivative()
      • special_optimized_reiz_feller_derivative()
      • unified_special_derivative()
    • Fractional Implementations
      • _AlphaCompatibilityWrapper
        • _AlphaCompatibilityWrapper.__init__()
      • RiemannLiouvilleDerivative
        • RiemannLiouvilleDerivative.__init__()
        • RiemannLiouvilleDerivative.compute()
        • RiemannLiouvilleDerivative.compute_numerical()
      • CaputoDerivative
        • CaputoDerivative.__init__()
        • CaputoDerivative.compute()
        • CaputoDerivative.compute_numerical()
      • GrunwaldLetnikovDerivative
        • GrunwaldLetnikovDerivative.__init__()
        • GrunwaldLetnikovDerivative.compute()
        • GrunwaldLetnikovDerivative.compute_numerical()
      • CaputoFabrizioDerivative
        • CaputoFabrizioDerivative.__init__()
        • CaputoFabrizioDerivative.compute()
        • CaputoFabrizioDerivative.compute_numerical()
      • AtanganaBaleanuDerivative
        • AtanganaBaleanuDerivative.__init__()
        • AtanganaBaleanuDerivative.compute()
        • AtanganaBaleanuDerivative.compute_numerical()
      • FractionalLaplacian
        • FractionalLaplacian.__init__()
        • FractionalLaplacian.compute()
        • FractionalLaplacian.compute_numerical()
      • FractionalFourierTransform
        • FractionalFourierTransform.__init__()
        • FractionalFourierTransform.compute()
        • FractionalFourierTransform.compute_numerical()
      • MillerRossDerivative
        • MillerRossDerivative.__init__()
        • MillerRossDerivative.compute()
        • MillerRossDerivative.compute_numerical()
      • WeylDerivative
        • WeylDerivative.__init__()
        • WeylDerivative.compute()
        • WeylDerivative.compute_numerical()
      • MarchaudDerivative
        • MarchaudDerivative.__init__()
        • MarchaudDerivative.compute()
        • MarchaudDerivative.compute_numerical()
      • HadamardDerivative
        • HadamardDerivative.__init__()
        • HadamardDerivative.compute()
        • HadamardDerivative.compute_numerical()
      • ReizFellerDerivative
        • ReizFellerDerivative.__init__()
        • ReizFellerDerivative.compute()
        • ReizFellerDerivative.compute_numerical()
      • ParallelOptimizedRiemannLiouville
        • ParallelOptimizedRiemannLiouville.__init__()
        • ParallelOptimizedRiemannLiouville.compute()
        • ParallelOptimizedRiemannLiouville.compute_numerical()
      • ParallelOptimizedCaputo
        • ParallelOptimizedCaputo.__init__()
        • ParallelOptimizedCaputo.compute()
        • ParallelOptimizedCaputo.compute_numerical()
      • RieszFisherOperator
        • RieszFisherOperator.__init__()
        • RieszFisherOperator.compute()
        • RieszFisherOperator.compute_numerical()
      • AdomianDecompositionMethod
        • AdomianDecompositionMethod.__init__()
        • AdomianDecompositionMethod.solve()
        • AdomianDecompositionMethod.compute_adomian_polynomials()
        • AdomianDecompositionMethod.decompose_function()
        • AdomianDecompositionMethod.solve_equation()
      • create_fractional_integral()
      • create_riesz_fisher_operator()
      • register_fractional_implementations()
    • Core Integrals
      • FractionalIntegral
        • FractionalIntegral.__init__()
        • FractionalIntegral._validate_parameters()
        • FractionalIntegral.compute()
      • RiemannLiouvilleIntegral
        • RiemannLiouvilleIntegral.__init__()
        • RiemannLiouvilleIntegral.compute()
        • RiemannLiouvilleIntegral._coerce_function()
        • RiemannLiouvilleIntegral._compute_scalar()
        • RiemannLiouvilleIntegral._compute_array_numpy()
        • RiemannLiouvilleIntegral._compute_array_torch()
      • CaputoIntegral
        • CaputoIntegral.__init__()
        • CaputoIntegral._coerce_function()
        • CaputoIntegral.compute()
      • WeylIntegral
        • WeylIntegral.__init__()
        • WeylIntegral._compute_scalar()
        • WeylIntegral._compute_array_numpy()
        • WeylIntegral.compute()
        • WeylIntegral._compute_array_torch()
      • HadamardIntegral
        • HadamardIntegral.__init__()
        • HadamardIntegral._compute_scalar()
        • HadamardIntegral._compute_array_numpy()
        • HadamardIntegral._compute_array_torch()
      • create_fractional_integral()
      • analytical_fractional_integral()
      • trapezoidal_fractional_integral()
      • simpson_fractional_integral()
      • fractional_integral_properties()
      • validate_fractional_integral()
      • MillerRossIntegral
        • MillerRossIntegral.__init__()
        • MillerRossIntegral._compute_scalar()
        • MillerRossIntegral._compute_array_numpy()
        • MillerRossIntegral._compute_array_torch()
      • MarchaudIntegral
        • MarchaudIntegral.__init__()
        • MarchaudIntegral._compute_scalar()
        • MarchaudIntegral._compute_array_numpy()
        • MarchaudIntegral._compute_array_torch()
      • FractionalIntegralFactory
        • FractionalIntegralFactory.__init__()
        • FractionalIntegralFactory.register_implementation()
        • FractionalIntegralFactory.create()
        • FractionalIntegralFactory.get_available_methods()
      • create_fractional_integral_factory()
  • Solvers API Reference
    • ODE Solvers
      • _get_gamma_function()
      • _get_intelligent_selector()
      • _select_fft_backend()
      • _fft_convolution()
      • _fast_history_sum()
      • FixedStepODESolver
        • FixedStepODESolver.__init__()
        • FixedStepODESolver._validate_alpha()
        • FixedStepODESolver.solve()
        • FixedStepODESolver._solve_predictor_corrector()
        • FixedStepODESolver._solve_adams_bashforth()
        • FixedStepODESolver._solve_runge_kutta()
        • FixedStepODESolver._solve_euler()
        • FixedStepODESolver._euler_step()
        • FixedStepODESolver._compute_fractional_coefficients()
      • solve_fractional_ode()
      • solve_fractional_system()
    • PDE Solvers
      • _get_intelligent_selector()
      • _select_array_backend()
      • FractionalPDESolver
        • FractionalPDESolver.__init__()
        • FractionalPDESolver._validate_orders()
        • FractionalPDESolver.solve()
      • FractionalDiffusionSolver
        • FractionalDiffusionSolver.__init__()
        • FractionalDiffusionSolver.solve()
        • FractionalDiffusionSolver._solve_spatial_step()
        • FractionalDiffusionSolver._finite_difference_step()
        • FractionalDiffusionSolver._spectral_step()
        • FractionalDiffusionSolver._compute_temporal_derivative()
        • FractionalDiffusionSolver._compute_spatial_derivative()
        • FractionalDiffusionSolver._grunwald_letnikov_coeffs()
        • FractionalDiffusionSolver._validate_orders()
        • FractionalDiffusionSolver._build_spatial_matrix()
        • FractionalDiffusionSolver._get_spatial_operator()
      • FractionalAdvectionSolver
        • FractionalAdvectionSolver.__init__()
        • FractionalAdvectionSolver.solve()
        • FractionalAdvectionSolver._build_spatial_matrix()
        • FractionalAdvectionSolver._get_spatial_operator()
      • FractionalReactionDiffusionSolver
        • FractionalReactionDiffusionSolver.__init__()
        • FractionalReactionDiffusionSolver.solve()
      • solve_fractional_diffusion()
      • solve_fractional_advection()
      • solve_fractional_reaction_diffusion()
      • solve_fractional_pde()
    • SDE Solvers
      • _get_gamma_function()
      • _get_intelligent_selector()
      • _fft_convolution()
      • SDESolution
        • SDESolution.t
        • SDESolution.y
        • SDESolution.fractional_order
        • SDESolution.method
        • SDESolution.drift_func
        • SDESolution.diffusion_func
        • SDESolution.metadata
        • SDESolution.__init__()
      • FractionalSDESolver
        • FractionalSDESolver.__init__()
        • FractionalSDESolver.solve()
      • FastHistoryConvolution
        • FastHistoryConvolution.__init__()
        • FastHistoryConvolution.update()
        • FastHistoryConvolution.convolve()
      • FractionalEulerMaruyama
        • FractionalEulerMaruyama.__init__()
        • FractionalEulerMaruyama.solve()
      • FractionalMilstein
        • FractionalMilstein.__init__()
        • FractionalMilstein.solve()
      • solve_fractional_sde()
      • solve_fractional_sde_system()
    • Noise Models
      • NoiseModel
        • NoiseModel.generate_increment()
      • BrownianMotion
        • BrownianMotion.__init__()
        • BrownianMotion.generate_increment()
        • BrownianMotion.variance()
      • FractionalBrownianMotion
        • FractionalBrownianMotion.__init__()
        • FractionalBrownianMotion.generate_increment()
        • FractionalBrownianMotion.is_standard_bm
      • LevyNoise
        • LevyNoise.__init__()
        • LevyNoise.generate_increment()
      • ColouredNoise
        • ColouredNoise.__init__()
        • ColouredNoise.generate_increment()
        • ColouredNoise.reset()
      • NoiseConfig
        • NoiseConfig.noise_type
        • NoiseConfig.hurst
        • NoiseConfig.scale
        • NoiseConfig.alpha
        • NoiseConfig.beta
        • NoiseConfig.correlation_time
        • NoiseConfig.amplitude
        • NoiseConfig.__init__()
      • create_noise_model()
      • generate_noise_trajectory()
  • Fractional Neural Networks API Reference
    • Spectral Autograd
      • set_fft_backend()
      • get_fft_backend()
      • safe_fft()
      • safe_ifft()
      • robust_fft()
      • robust_ifft()
      • spectral_fractional_derivative()
      • fractional_derivative()
      • SpectralFractionalDerivative
        • SpectralFractionalDerivative.apply()
      • SpectralFractionalFunction
        • SpectralFractionalFunction.forward()
        • SpectralFractionalFunction.backward()
      • SpectralFractionalLayer
        • SpectralFractionalLayer.__init__()
        • SpectralFractionalLayer.alpha
        • SpectralFractionalLayer.learnable
        • SpectralFractionalLayer.get_alpha()
        • SpectralFractionalLayer.forward()
      • SpectralFractionalNetwork
        • SpectralFractionalNetwork.__init__()
        • SpectralFractionalNetwork.forward()
      • BoundedAlphaParameter
        • BoundedAlphaParameter.__init__()
        • BoundedAlphaParameter.forward()
        • BoundedAlphaParameter.extra_repr()
      • create_fractional_layer()
      • benchmark_backends()
      • original_set_fft_backend()
      • original_get_fft_backend()
      • original_safe_fft()
      • original_safe_ifft()
      • original_get_fractional_kernel()
      • original_spectral_fractional_derivative()
      • OriginalSpectral
      • OriginalSpectralFractionalLayer
      • OriginalSpectralFractionalNetwork
      • original_create_fractional_layer()
      • _numpy_fft()
    • Stochastic Memory Sampling
      • StochasticMemorySampler
        • StochasticMemorySampler.__init__()
        • StochasticMemorySampler.sample_indices()
        • StochasticMemorySampler.compute_weights()
        • StochasticMemorySampler.estimate_derivative()
      • ImportanceSampler
        • ImportanceSampler.__init__()
        • ImportanceSampler.sample_indices()
        • ImportanceSampler.compute_weights()
        • ImportanceSampler.estimate_derivative()
      • StratifiedSampler
        • StratifiedSampler.__init__()
        • StratifiedSampler.sample_indices()
        • StratifiedSampler.compute_weights()
        • StratifiedSampler.estimate_derivative()
      • ControlVariateSampler
        • ControlVariateSampler.__init__()
        • ControlVariateSampler.compute_baseline()
        • ControlVariateSampler.sample_indices()
        • ControlVariateSampler.compute_weights()
        • ControlVariateSampler.estimate_derivative()
      • StochasticFractionalDerivative
        • StochasticFractionalDerivative.forward()
        • StochasticFractionalDerivative.backward()
      • StochasticFractionalLayer
        • StochasticFractionalLayer.__init__()
        • StochasticFractionalLayer.forward()
        • StochasticFractionalLayer.extra_repr()
      • stochastic_fractional_derivative()
      • create_stochastic_fractional_layer()
    • Probabilistic Fractional Orders
      • model()
      • guide()
      • ProbabilisticFractionalOrder
        • ProbabilisticFractionalOrder.__init__()
        • ProbabilisticFractionalOrder.init()
        • ProbabilisticFractionalOrder.sample()
        • ProbabilisticFractionalOrder.log_prob()
      • ProbabilisticFractionalLayer
        • ProbabilisticFractionalLayer.__init__()
        • ProbabilisticFractionalLayer.forward()
        • ProbabilisticFractionalLayer.sample_alpha()
        • ProbabilisticFractionalLayer.get_alpha_statistics()
        • ProbabilisticFractionalLayer.extra_repr()
      • create_probabilistic_fractional_layer()
      • create_normal_alpha_layer()
      • create_uniform_alpha_layer()
      • create_beta_alpha_layer()
    • Variance-Aware Training
      • VarianceMetrics
        • VarianceMetrics.mean
        • VarianceMetrics.std
        • VarianceMetrics.variance
        • VarianceMetrics.coefficient_of_variation
        • VarianceMetrics.sample_count
        • VarianceMetrics.timestamp
        • VarianceMetrics.__init__()
      • VarianceMonitor
        • VarianceMonitor.__init__()
        • VarianceMonitor.current_metrics
        • VarianceMonitor.update()
        • VarianceMonitor.get_metrics()
        • VarianceMonitor.get_history()
        • VarianceMonitor.should_adapt()
        • VarianceMonitor.get_summary()
      • StochasticSeedManager
        • StochasticSeedManager.__init__()
        • StochasticSeedManager.set_seed()
        • StochasticSeedManager.get_next_seed()
        • StochasticSeedManager.reset_to_base()
        • StochasticSeedManager.set_deterministic_mode()
      • VarianceAwareCallback
        • VarianceAwareCallback.__init__()
        • VarianceAwareCallback.on_epoch_begin()
        • VarianceAwareCallback.on_batch_begin()
        • VarianceAwareCallback.on_batch_end()
        • VarianceAwareCallback.on_epoch_end()
        • VarianceAwareCallback._check_variance()
        • VarianceAwareCallback._log_variance_summary()
      • AdaptiveSamplingManager
        • AdaptiveSamplingManager.__init__()
        • AdaptiveSamplingManager.update_k()
        • AdaptiveSamplingManager.get_current_k()
      • VarianceAwareTrainer
        • VarianceAwareTrainer.__init__()
        • VarianceAwareTrainer._register_hooks()
        • VarianceAwareTrainer.train_epoch()
        • VarianceAwareTrainer.train()
        • VarianceAwareTrainer.get_variance_summary()
        • VarianceAwareTrainer.set_sampling_budget()
        • VarianceAwareTrainer.enable_deterministic_mode()
      • create_variance_aware_trainer()
      • test_variance_aware_training()
    • GPU Optimization
      • PerformanceMetrics
        • PerformanceMetrics.operation
        • PerformanceMetrics.device
        • PerformanceMetrics.dtype
        • PerformanceMetrics.input_shape
        • PerformanceMetrics.execution_time
        • PerformanceMetrics.memory_used
        • PerformanceMetrics.memory_peak
        • PerformanceMetrics.throughput
        • PerformanceMetrics.timestamp
        • PerformanceMetrics.__init__()
      • GPUProfiler
        • GPUProfiler.__init__()
        • GPUProfiler.start_timer()
        • GPUProfiler.end_timer()
        • GPUProfiler.get_summary()
        • GPUProfiler.clear_history()
      • ChunkedFFT
        • ChunkedFFT.__init__()
        • ChunkedFFT.fft_chunked()
        • ChunkedFFT.ifft_chunked()
        • ChunkedFFT._process_chunks()
      • AMPFractionalEngine
        • AMPFractionalEngine.__init__()
        • AMPFractionalEngine.forward()
        • AMPFractionalEngine.backward()
      • GPUOptimizedSpectralEngine
        • GPUOptimizedSpectralEngine.__init__()
        • GPUOptimizedSpectralEngine.forward()
        • GPUOptimizedSpectralEngine._compute_spectral_transform()
        • GPUOptimizedSpectralEngine._fallback_compute()
        • GPUOptimizedSpectralEngine.get_performance_summary()
      • GPUOptimizedStochasticSampler
        • GPUOptimizedStochasticSampler.__init__()
        • GPUOptimizedStochasticSampler.sample_indices()
        • GPUOptimizedStochasticSampler._gpu_sample_indices()
        • GPUOptimizedStochasticSampler.get_performance_summary()
      • gpu_optimization_context()
      • benchmark_gpu_optimization()
      • create_gpu_optimized_components()
      • test_gpu_optimization()
    • Backend Management
      • BackendType
        • BackendType.TORCH
        • BackendType.JAX
        • BackendType.NUMBA
        • BackendType.AUTO
      • BackendManager
        • BackendManager.__init__()
        • BackendManager._detect_available_backends()
        • BackendManager._select_optimal_backend()
        • BackendManager._initialize_backend_configs()
        • BackendManager.get_backend_config()
        • BackendManager.switch_backend()
        • BackendManager.get_tensor_lib()
        • BackendManager.create_tensor()
        • BackendManager.to_device()
        • BackendManager.compile_function()
      • get_backend_manager()
      • set_backend_manager()
      • get_active_backend()
      • switch_backend()
    • Neural Networks
    • Neural ODEs
      • NeuralODEConfig
        • NeuralODEConfig.input_dim
        • NeuralODEConfig.hidden_dim
        • NeuralODEConfig.output_dim
        • NeuralODEConfig.num_layers
        • NeuralODEConfig.activation
        • NeuralODEConfig.use_adjoint
        • NeuralODEConfig.solver
        • NeuralODEConfig.rtol
        • NeuralODEConfig.atol
        • NeuralODEConfig.fractional_order
        • NeuralODEConfig.device
        • NeuralODEConfig.enable_performance_monitoring
        • NeuralODEConfig.memory_optimization
        • NeuralODEConfig.use_advanced_solvers
        • NeuralODEConfig.__init__()
      • BaseNeuralODE
        • BaseNeuralODE.__init__()
        • BaseNeuralODE._setup_layer()
        • BaseNeuralODE._build_network()
        • BaseNeuralODE._initialize_weights()
        • BaseNeuralODE._get_activation()
        • BaseNeuralODE.ode_func()
        • BaseNeuralODE.forward()
      • NeuralODE
        • NeuralODE.__init__()
        • NeuralODE._check_torchdiffeq()
        • NeuralODE.forward()
        • NeuralODE._solve_torchdiffeq()
        • NeuralODE._solve_optimized_euler()
      • NeuralFODE
        • NeuralFODE.__init__()
        • NeuralFODE.get_fractional_order()
        • NeuralFODE._check_torchdiffeq()
        • NeuralFODE.forward()
        • NeuralFODE._solve_fractional_ode_optimized()
      • NeuralODETrainer
        • NeuralODETrainer.__init__()
        • NeuralODETrainer._setup_optimizer()
        • NeuralODETrainer._setup_loss_function()
        • NeuralODETrainer.train_step()
        • NeuralODETrainer._validate()
        • NeuralODETrainer.train()
      • create_neural_ode()
      • create_neural_ode_trainer()
    • Layers
      • LayerConfig
        • LayerConfig.fractional_order
        • LayerConfig.method
        • LayerConfig.use_fractional
        • LayerConfig.activation
        • LayerConfig.dropout
        • LayerConfig.backend
        • LayerConfig.device
        • LayerConfig.enable_caching
        • LayerConfig.enable_benchmarking
        • LayerConfig.performance_mode
        • LayerConfig.__init__()
      • BackendManager
        • BackendManager.__init__()
        • BackendManager._detect_available_backends()
        • BackendManager.select_optimal_backend()
      • FractionalOps
        • FractionalOps.__init__()
        • FractionalOps.apply_fractional_derivative()
      • FractionalLayerBase
        • FractionalLayerBase.__init__()
        • FractionalLayerBase._setup_layer()
        • FractionalLayerBase.apply_fractional_derivative()
        • FractionalLayerBase.apply_activation()
        • FractionalLayerBase.apply_dropout()
        • FractionalLayerBase.forward()
      • FractionalConv1D
        • FractionalConv1D.__init__()
        • FractionalConv1D._initialize_weights()
        • FractionalConv1D.forward()
      • FractionalConv2D
        • FractionalConv2D.__init__()
        • FractionalConv2D._initialize_weights()
        • FractionalConv2D.forward()
      • FractionalLinear
        • FractionalLinear.__init__()
        • FractionalLinear._initialize_weights()
        • FractionalLinear.forward()
      • FractionalLSTM
        • FractionalLSTM.__init__()
        • FractionalLSTM.forward()
        • FractionalLSTM.forward_with_state()
      • FractionalTransformer
        • FractionalTransformer.__init__()
        • FractionalTransformer.forward()
      • FractionalPooling
        • FractionalPooling.__init__()
        • FractionalPooling.forward()
      • FractionalBatchNorm1d
        • FractionalBatchNorm1d.__init__()
        • FractionalBatchNorm1d.forward()
      • FractionalDropout
        • FractionalDropout.__init__()
        • FractionalDropout.forward()
      • FractionalLayerNorm
        • FractionalLayerNorm.__init__()
        • FractionalLayerNorm.forward()
      • FractionalMaxUnpool1d
        • FractionalMaxUnpool1d.__init__()
        • FractionalMaxUnpool1d.forward()
      • FractionalMaxUnpool2d
        • FractionalMaxUnpool2d.__init__()
        • FractionalMaxUnpool2d.forward()
      • FractionalMaxUnpool3d
        • FractionalMaxUnpool3d.__init__()
        • FractionalMaxUnpool3d.forward()
      • FractionalSelfAttention
        • FractionalSelfAttention.__init__()
        • FractionalSelfAttention.forward()
    • Tensor Operations
      • TensorOps
        • TensorOps.__init__()
        • TensorOps._resolve_backend()
        • TensorOps._get_tensor_lib_for_backend()
        • TensorOps.create_tensor()
        • TensorOps.tensor()
        • TensorOps.from_numpy()
        • TensorOps.to_numpy()
        • TensorOps.no_grad()
        • TensorOps.zeros()
        • TensorOps.ones()
        • TensorOps.eye()
        • TensorOps.arange()
        • TensorOps.linspace()
        • TensorOps.zeros_like()
        • TensorOps.ones_like()
        • TensorOps.sqrt()
        • TensorOps.stack()
        • TensorOps.cat()
        • TensorOps.reshape()
        • TensorOps.repeat()
        • TensorOps.tile()
        • TensorOps.clip()
        • TensorOps.unsqueeze()
        • TensorOps.expand()
        • TensorOps.gather()
        • TensorOps.squeeze()
        • TensorOps.transpose()
        • TensorOps.matmul()
        • TensorOps.einsum()
        • TensorOps.sum()
        • TensorOps.mean()
        • TensorOps.std()
        • TensorOps.median()
        • TensorOps.quantile()
        • TensorOps.max()
        • TensorOps.min()
        • TensorOps.norm()
        • TensorOps.softmax()
        • TensorOps.relu()
        • TensorOps.sigmoid()
        • TensorOps.tanh()
        • TensorOps.log()
        • TensorOps.add()
        • TensorOps.subtract()
        • TensorOps.multiply()
        • TensorOps.divide()
        • TensorOps.power()
        • TensorOps.sin()
        • TensorOps.cos()
        • TensorOps.exp()
        • TensorOps.abs()
        • TensorOps.randn()
        • TensorOps.randn_like()
        • TensorOps.dropout()
        • TensorOps.fft()
        • TensorOps.ifft()
        • TensorOps.clone()
        • TensorOps.concatenate()
      • get_tensor_ops()
      • create_tensor()
      • switch_backend()
  • Fractional Graph Neural Networks API Reference
    • GNN Layers
      • BaseFractionalGNNLayer
        • BaseFractionalGNNLayer.__init__()
        • BaseFractionalGNNLayer._initialize_layer()
        • BaseFractionalGNNLayer.forward()
        • BaseFractionalGNNLayer.apply_fractional_derivative()
        • BaseFractionalGNNLayer._torch_fractional_derivative()
        • BaseFractionalGNNLayer._jax_fractional_derivative()
        • BaseFractionalGNNLayer._numba_fractional_derivative()
      • FractionalGraphConv
        • FractionalGraphConv._initialize_layer()
        • FractionalGraphConv._initialize_weights()
        • FractionalGraphConv.forward()
        • FractionalGraphConv._torch_forward()
        • FractionalGraphConv._jax_forward()
        • FractionalGraphConv._numba_forward()
        • FractionalGraphConv._jax_scatter_add()
        • FractionalGraphConv._numba_scatter_add()
        • FractionalGraphConv._jax_activation()
        • FractionalGraphConv._numba_activation()
        • FractionalGraphConv.train()
        • FractionalGraphConv.eval()
        • FractionalGraphConv.reset_parameters()
        • FractionalGraphConv.parameters()
        • FractionalGraphConv.named_parameters()
        • FractionalGraphConv.state_dict()
        • FractionalGraphConv.load_state_dict()
      • FractionalGraphAttention
        • FractionalGraphAttention.__init__()
        • FractionalGraphAttention._initialize_layer()
        • FractionalGraphAttention.forward()
        • FractionalGraphAttention._aggregate_attention()
        • FractionalGraphAttention._apply_activation()
        • FractionalGraphAttention._jax_activation()
        • FractionalGraphAttention._numba_activation()
        • FractionalGraphAttention._apply_dropout()
        • FractionalGraphAttention.train()
        • FractionalGraphAttention.eval()
        • FractionalGraphAttention.reset_parameters()
        • FractionalGraphAttention.parameters()
        • FractionalGraphAttention.named_parameters()
        • FractionalGraphAttention.state_dict()
        • FractionalGraphAttention.load_state_dict()
      • FractionalGraphPooling
        • FractionalGraphPooling.__init__()
        • FractionalGraphPooling._initialize_layer()
        • FractionalGraphPooling.forward()
        • FractionalGraphPooling.train()
        • FractionalGraphPooling.eval()
        • FractionalGraphPooling.reset_parameters()
        • FractionalGraphPooling.parameters()
        • FractionalGraphPooling.named_parameters()
        • FractionalGraphPooling.state_dict()
        • FractionalGraphPooling.load_state_dict()
    • GNN Models
      • BaseFractionalGNN
        • BaseFractionalGNN.__init__()
        • BaseFractionalGNN._build_network()
        • BaseFractionalGNN.forward()
        • BaseFractionalGNN.get_backend_info()
        • BaseFractionalGNN.parameters()
      • FractionalGCN
        • FractionalGCN._build_network()
        • FractionalGCN.forward()
      • FractionalGAT
        • FractionalGAT.__init__()
        • FractionalGAT._build_network()
        • FractionalGAT.forward()
      • FractionalGraphSAGE
        • FractionalGraphSAGE.__init__()
        • FractionalGraphSAGE._build_network()
        • FractionalGraphSAGE.forward()
      • FractionalGraphUNet
        • FractionalGraphUNet.__init__()
        • FractionalGraphUNet._build_network()
        • FractionalGraphUNet.forward()
      • FractionalGNNFactory
        • FractionalGNNFactory.create_model()
        • FractionalGNNFactory.get_available_models()
        • FractionalGNNFactory.get_model_info()
  • Neural ODEs and SDEs API Reference
    • Neural ODEs
      • NeuralODEConfig
        • NeuralODEConfig.input_dim
        • NeuralODEConfig.hidden_dim
        • NeuralODEConfig.output_dim
        • NeuralODEConfig.num_layers
        • NeuralODEConfig.activation
        • NeuralODEConfig.use_adjoint
        • NeuralODEConfig.solver
        • NeuralODEConfig.rtol
        • NeuralODEConfig.atol
        • NeuralODEConfig.fractional_order
        • NeuralODEConfig.device
        • NeuralODEConfig.enable_performance_monitoring
        • NeuralODEConfig.memory_optimization
        • NeuralODEConfig.use_advanced_solvers
        • NeuralODEConfig.__init__()
      • BaseNeuralODE
        • BaseNeuralODE.__init__()
        • BaseNeuralODE._setup_layer()
        • BaseNeuralODE._build_network()
        • BaseNeuralODE._initialize_weights()
        • BaseNeuralODE._get_activation()
        • BaseNeuralODE.ode_func()
        • BaseNeuralODE.forward()
      • NeuralODE
        • NeuralODE.__init__()
        • NeuralODE._check_torchdiffeq()
        • NeuralODE.forward()
        • NeuralODE._solve_torchdiffeq()
        • NeuralODE._solve_optimized_euler()
      • NeuralFODE
        • NeuralFODE.__init__()
        • NeuralFODE.get_fractional_order()
        • NeuralFODE._check_torchdiffeq()
        • NeuralFODE.forward()
        • NeuralFODE._solve_fractional_ode_optimized()
      • NeuralODETrainer
        • NeuralODETrainer.__init__()
        • NeuralODETrainer._setup_optimizer()
        • NeuralODETrainer._setup_loss_function()
        • NeuralODETrainer.train_step()
        • NeuralODETrainer._validate()
        • NeuralODETrainer.train()
      • create_neural_ode()
      • create_neural_ode_trainer()
    • Neural fSDE
      • NeuralFSDEConfig
        • NeuralFSDEConfig.diffusion_dim
        • NeuralFSDEConfig.noise_type
        • NeuralFSDEConfig.drift_net
        • NeuralFSDEConfig.diffusion_net
        • NeuralFSDEConfig.use_sde_adjoint
        • NeuralFSDEConfig.learn_alpha
        • NeuralFSDEConfig.__init__()
      • NeuralFractionalSDE
        • NeuralFractionalSDE.__init__()
        • NeuralFractionalSDE._build_drift_network()
        • NeuralFractionalSDE._build_diffusion_network()
        • NeuralFractionalSDE.drift_function()
        • NeuralFractionalSDE.diffusion_function()
        • NeuralFractionalSDE.drift()
        • NeuralFractionalSDE.diffusion()
        • NeuralFractionalSDE.fractional_order()
        • NeuralFractionalSDE.forward()
        • NeuralFractionalSDE._solve_fractional_sde_torch()
        • NeuralFractionalSDE.get_fractional_order()
        • NeuralFractionalSDE.adjoint_forward()
      • create_neural_fsde()
    • SDE Solvers
      • _get_gamma_function()
      • _get_intelligent_selector()
      • _fft_convolution()
      • SDESolution
        • SDESolution.t
        • SDESolution.y
        • SDESolution.fractional_order
        • SDESolution.method
        • SDESolution.drift_func
        • SDESolution.diffusion_func
        • SDESolution.metadata
        • SDESolution.__init__()
      • FractionalSDESolver
        • FractionalSDESolver.__init__()
        • FractionalSDESolver.solve()
      • FastHistoryConvolution
        • FastHistoryConvolution.__init__()
        • FastHistoryConvolution.update()
        • FastHistoryConvolution.convolve()
      • FractionalEulerMaruyama
        • FractionalEulerMaruyama.__init__()
        • FractionalEulerMaruyama.solve()
      • FractionalMilstein
        • FractionalMilstein.__init__()
        • FractionalMilstein.solve()
      • solve_fractional_sde()
      • solve_fractional_sde_system()
    • Noise Models
      • NoiseModel
        • NoiseModel.generate_increment()
      • BrownianMotion
        • BrownianMotion.__init__()
        • BrownianMotion.generate_increment()
        • BrownianMotion.variance()
      • FractionalBrownianMotion
        • FractionalBrownianMotion.__init__()
        • FractionalBrownianMotion.generate_increment()
        • FractionalBrownianMotion.is_standard_bm
      • LevyNoise
        • LevyNoise.__init__()
        • LevyNoise.generate_increment()
      • ColouredNoise
        • ColouredNoise.__init__()
        • ColouredNoise.generate_increment()
        • ColouredNoise.reset()
      • NoiseConfig
        • NoiseConfig.noise_type
        • NoiseConfig.hurst
        • NoiseConfig.scale
        • NoiseConfig.alpha
        • NoiseConfig.beta
        • NoiseConfig.correlation_time
        • NoiseConfig.amplitude
        • NoiseConfig.__init__()
      • create_noise_model()
      • generate_noise_trajectory()
  • Special Methods API Reference
    • Special Methods
      • _factorial()
      • FractionalLaplacian
        • FractionalLaplacian.__init__()
        • FractionalLaplacian.compute()
        • FractionalLaplacian._spectral_method()
        • FractionalLaplacian._finite_difference_method()
        • FractionalLaplacian.compute_numerical()
        • FractionalLaplacian._integral_method()
        • FractionalLaplacian._grunwald_coefficients()
      • FractionalFourierTransform
        • FractionalFourierTransform.__init__()
        • FractionalFourierTransform.transform()
        • FractionalFourierTransform.compute()
        • FractionalFourierTransform._discrete_method()
        • FractionalFourierTransform._fft_based_method()
        • FractionalFourierTransform._chirp_based_method()
        • FractionalFourierTransform._spectral_method()
        • FractionalFourierTransform.compute_numerical()
        • FractionalFourierTransform._compute_transform_matrix()
        • FractionalFourierTransform._hermite_decomposition()
        • FractionalFourierTransform._hermite_function()
        • FractionalFourierTransform._fractional_hermite()
        • FractionalFourierTransform._fast_approximation()
      • FractionalZTransform
        • FractionalZTransform.__init__()
        • FractionalZTransform.transform()
        • FractionalZTransform._direct_method()
        • FractionalZTransform._fft_method()
        • FractionalZTransform.inverse_transform()
        • FractionalZTransform._contour_integration()
        • FractionalZTransform._residue_method()
      • FractionalMellinTransform
        • FractionalMellinTransform.__init__()
        • FractionalMellinTransform.transform()
        • FractionalMellinTransform._numerical_method()
        • FractionalMellinTransform._analytical_method()
        • FractionalMellinTransform._fft_method()
        • FractionalMellinTransform.inverse_transform()
        • FractionalMellinTransform._inverse_numerical()
        • FractionalMellinTransform._inverse_fft()
      • fractional_laplacian()
      • fractional_fourier_transform()
      • fractional_z_transform()
      • fractional_mellin_transform()
      • SpecialMethodsConfig
        • SpecialMethodsConfig.__init__()
      • SpecialOptimizedWeylDerivative
        • SpecialOptimizedWeylDerivative.__init__()
        • SpecialOptimizedWeylDerivative._determine_optimal_method()
        • SpecialOptimizedWeylDerivative.compute()
        • SpecialOptimizedWeylDerivative._compute_frft()
        • SpecialOptimizedWeylDerivative._compute_standard_fft()
        • SpecialOptimizedWeylDerivative._compute_hybrid()
        • SpecialOptimizedWeylDerivative._compute_weyl_kernel()
      • SpecialOptimizedMarchaudDerivative
        • SpecialOptimizedMarchaudDerivative.__init__()
        • SpecialOptimizedMarchaudDerivative.compute()
        • SpecialOptimizedMarchaudDerivative._compute_z_transform()
        • SpecialOptimizedMarchaudDerivative._compute_standard()
      • SpecialOptimizedReizFellerDerivative
        • SpecialOptimizedReizFellerDerivative.__init__()
        • SpecialOptimizedReizFellerDerivative.compute()
        • SpecialOptimizedReizFellerDerivative._compute_laplacian()
        • SpecialOptimizedReizFellerDerivative._compute_spectral()
      • UnifiedSpecialMethods
        • UnifiedSpecialMethods.__init__()
        • UnifiedSpecialMethods.compute_derivative()
        • UnifiedSpecialMethods._auto_select_method()
      • special_optimized_weyl_derivative()
      • special_optimized_marchaud_derivative()
      • special_optimized_reiz_feller_derivative()
      • unified_special_derivative()
    • Special Functions
      • gamma_function()
      • beta_function()
      • gamma()
      • beta()
      • log_gamma()
      • binomial_coefficient()
      • generalized_binomial()
      • mittag_leffler_function()
      • mittag_leffler_derivative()
      • mittag_leffler_fast()
      • mittag_leffler()

Additional Guides:

  • Installation
    • Basic Installation
    • Installation with GPU Support
    • Installation with Machine Learning Dependencies
    • Development Installation
    • Requirements
  • Quick Start
    • Intelligent Backend Selection (v2.2.0)
    • Spectral Autograd Framework
      • Learnable Fractional Orders
    • Basic Fractional Calculus Operations
      • Fractional Derivatives
      • Fractional Integrals
      • Advanced Fractional Operators
      • Special Functions
    • Backend Management
  • Core Features
    • Fractional Derivatives
    • Fractional Integrals
    • Special Functions
    • Mathematical Utilities
    • Fractional Neural Networks
    • Graph Neural Networks
  • Advanced Usage
    • Error Analysis and Validation
    • Performance Optimization
    • Signal Processing Applications
    • Image Processing Applications
  • Configuration and Settings
    • Precision Settings
    • Logging Configuration
  • Troubleshooting
    • Common Issues
  • Best Practices
  • Fractional Autograd Guide
    • Table of Contents
    • Overview
    • Spectral Autograd Engines (Unified by Default)
      • Basic Usage (Unified)
      • Model-Specific (Legacy) Mode
      • Backends
        • Mellin Engine
        • Laplacian Engine
    • Stochastic Memory Sampling
      • Basic Usage
      • Sampling Methods
        • Importance Sampling
        • Stratified Sampling
        • Control Variate Sampling
      • Choosing K (Number of Samples)
    • Probabilistic Fractional Orders
      • Basic Usage
      • Distribution Types
        • Normal Distribution
        • Uniform Distribution
        • Beta Distribution
      • Gradient Estimation Methods
        • Reparameterization Trick
        • Score Function Estimator
    • Variance-Aware Training
      • Basic Usage
      • Variance Monitoring
      • Adaptive Sampling
    • GPU Optimization
      • Automatic Mixed Precision (AMP)
      • Chunked FFT for Large Sequences
      • Performance Profiling
    • Complete Examples
      • End-to-End Training
      • Benchmarking Performance
    • Best Practices
      • 1. Choosing the Right Approach
      • 2. Performance Optimization
      • 3. Variance Control
      • 4. Memory Management
      • 5. Debugging Tips
    • Troubleshooting
      • Common Issues
      • Getting Help
    • Conclusion
  • Neural Fractional SDE Guide
    • Introduction to Neural Fractional SDEs
      • What are Neural Fractional SDEs?
      • Mathematical Foundation
      • When to Use Neural fSDEs
    • Quick Start
      • Installation
      • Basic Example
      • Training Example
    • Core Concepts
      • Fractional Orders in SDEs
      • Drift and Diffusion Functions
      • Stochastic Noise Modeling
      • Memory Effects
    • Building Neural fSDE Models
      • Model Architecture Design
      • Network Configuration
      • Learnable Parameters
      • Backend Selection
    • Training with Adjoint Methods
      • Why Adjoint Methods?
      • Basic Adjoint Training
      • Memory-Efficient Checkpointing
      • Mixed Precision Training
      • Gradient Accumulation
    • Graph-SDE Coupling
      • Spatio-Temporal Dynamics
      • Coupling Mechanisms
      • Multi-Scale Modeling
      • Operator Splitting
    • Uncertainty Quantification
      • Bayesian Neural fSDEs
      • NumPyro Integration
      • Posterior Predictive Distributions
      • Confidence Intervals
    • Performance Optimization
      • Intelligent Backend Selection
      • Memory Management
      • GPU Utilization
      • Batch Processing
    • Best Practices
      • Model Selection
      • Hyperparameter Tuning
      • Numerical Stability
      • Validation Strategies
      • Debugging Tips
    • Advanced Topics
      • Learnable Fractional Orders
      • Multi-Equation Systems
      • Custom Noise Processes
    • References
    • Getting Help
  • Neural fODE Framework Guide
    • Overview
    • 🚀 Quick Start
      • Installation
      • Basic Usage
    • 🏗️ Architecture
      • BaseNeuralODE
      • NeuralODE
      • NeuralFODE
      • NeuralODETrainer
    • 🔧 Configuration Options
      • Model Configuration
      • Training Configuration
    • 📚 Examples
      • Example 1: Simple Harmonic Oscillator
      • Example 2: Fractional Diffusion Equation
      • Example 3: Training a Neural ODE
    • 🏭 Factory Functions
      • Creating Models
      • Model Properties
    • 🔬 Research Applications
      • Physics-Informed Neural Networks (PINNs)
      • Time Series Prediction
    • ⚡ Performance Optimization
      • GPU Acceleration
      • Batch Processing
      • Memory Management
    • 🧪 Testing and Validation
      • Running Tests
      • Validation Examples
    • 🔮 Future Developments
      • Planned Features
      • Research Directions
    • 📖 References
    • 🤝 Contributing
    • 📞 Support
  • Spectral Autograd Framework
    • Overview
    • Key Features
      • Mathematical Foundation
      • Robust Error Handling
      • Production Features
    • Basic Usage
      • Import the Framework
      • Simple Fractional Derivative
      • Learnable Fractional Orders
      • Neural Network Integration
    • Advanced Usage
      • Backend Configuration
      • Multi-dimensional Derivatives
      • Performance Optimization
    • Mathematical Properties
      • Limit Behavior
      • Semigroup Property
      • Adjoint Property
    • Performance Benchmarks
      • Gradient Quality Improvements
    • Error Handling
      • MKL FFT Errors
      • Backend Fallbacks
    • Troubleshooting
      • Common Issues
      • Best Practices
    • API Reference
      • SpectralFractionalDerivative
        • SpectralFractionalDerivative
      • BoundedAlphaParameter
        • BoundedAlphaParameter
      • Configuration Functions
        • set_fft_backend()
        • get_fft_backend()
    • See Also
  • JAX GPU Setup for HPFRACC Library
    • Current Status
    • Installation
      • Recommended Installation for GPU Support
      • CuDNN Compatibility
    • How It Works
    • Usage
    • GPU Support Status
      • RTX 5070 (Current GPU)
      • CUDA Version Compatibility
      • Future GPU Support
    • Performance Impact
    • Troubleshooting
    • Technical Details
    • Troubleshooting CuDNN Issues
  • Researcher Quick Start Guide
    • 🎯 For Computational Physics and Biophysics Research
    • 🚀 Installation & Setup
      • 1. Install HPFRACC
      • 2. Verify Installation
    • 🔬 Research Applications
      • Computational Physics
        • Fractional PDEs
        • Viscoelastic Materials
      • Biophysics
        • Protein Folding Dynamics
        • Membrane Transport
    • 🤖 Machine Learning Integration
      • Fractional Neural Networks
      • GPU Optimization
      • Variance-Aware Training
    • 📊 Performance Optimization
      • Benchmarking Your Code
      • Memory Management
    • 🔬 Research Workflow Example
      • Complete Biophysics Research Pipeline
    • 📚 Next Steps
      • 1. Explore Examples
      • 2. Read Documentation
      • 3. Run Benchmarks
    • 🎯 Research Applications Ready
      • Computational Physics
      • Biophysics
      • Machine Learning
    • 📞 Support
  • HPFRACC Performance Optimization Guide (v3.0.0)
    • Overview
    • Intelligent Backend Selection
      • Automatic Optimization
      • Performance Learning
    • Performance Benchmarks
      • Computational Speedup
      • Memory Efficiency
    • Optimization Strategies
      • 1. Data Size Optimization
        • Small Data (< 1K elements)
        • Medium Data (1K-100K elements)
        • Large Data (> 100K elements)
      • 2. Operation Type Optimization
        • Fractional Derivatives
        • Matrix Operations
        • FFT Operations
      • 3. Memory Management
        • Dynamic Memory Thresholds
        • Memory-Efficient Operations
      • 4. GPU Optimization
        • Multi-GPU Support
        • GPU Memory Management
      • 5. Neural Network Optimization
        • Fractional Neural Networks
        • Batch Processing
    • Performance Monitoring
      • Real-Time Performance Tracking
      • Performance Analytics
      • Backend Performance Analysis
    • Environment Configuration
      • Environment Variables
      • Programmatic Configuration
    • Best Practices
      • 1. Use Intelligent Backend Selection
      • 2. Memory Management
      • 3. Data Size Optimization
      • 4. Operation-Specific Optimization
      • 5. Neural Network Optimization
    • Troubleshooting Performance Issues
      • Common Performance Problems
        • 1. Slow Performance
        • 2. Memory Issues
        • 3. GPU Issues
      • Performance Debugging
    • Advanced Optimization Techniques
      • 1. Custom Workload Characterization
      • 2. Performance Prediction
      • 3. Adaptive Optimization
    • Conclusion

Development:

  • Development
    • Assessment Reports
      • Assessment Reports
    • Coverage Reports
      • Coverage Reports
    • Design Documents
      • Design Documents
    • Development Guides
      • Development Guides
    • Test Reports
      • Test Reports
    • Project Reports
      • Project Reports
HPFRACC
  • Search

© Copyright 2025, Davian R. Chin.

Built with Sphinx using a theme provided by Read the Docs.