Derivatives and Integrals API Reference

All fractional derivative and integral classes and functions.

Core Derivatives

Base classes for fractional derivatives.

This module provides abstract base classes and common interfaces for implementing different fractional derivative definitions.

class hpfracc.core.derivatives.BaseFractionalDerivative(order, definition=None, use_jax=False, use_numba=True)[source]

Bases: ABC

Abstract base class for fractional derivatives.

This class defines the common interface that all fractional derivative implementations must follow.

Parameters:
__init__(order, definition=None, use_jax=False, use_numba=True)[source]

Initialize fractional derivative.

Parameters:
_validate_parameters()[source]

Validate input parameters.

abstract compute(f, x, **kwargs)[source]

Compute the fractional derivative of function f at point(s) x.

Parameters:

  • f (Callable) – Function to differentiate

  • x (float | ndarray | jax.numpy.ndarray) – Point(s) at which to compute the derivative

  • **kwargs – Additional parameters

Returns:

Fractional derivative value(s)

Return type:

float | ndarray | jax.numpy.ndarray

abstract compute_numerical(f_values, x_values, **kwargs)[source]

Compute the fractional derivative numerically from function values.

Parameters:

  • f_values (ndarray | jax.numpy.ndarray) – Function values at x_values

  • x_values (ndarray | jax.numpy.ndarray) – Points where function is evaluated

  • **kwargs – Additional parameters

Returns:

Fractional derivative values

Return type:

ndarray | jax.numpy.ndarray

get_definition_info()[source]

Get information about the mathematical definition.

Return type:

Dict[str, Any]

class hpfracc.core.derivatives.FractionalDerivativeOperator(alpha, definition_type=DefinitionType.CAPUTO, use_jax=False, use_numba=True)[source]

Bases: object

High-level operator for fractional derivatives.

This class provides a unified interface for different fractional derivative definitions and implementations.

Parameters:
__init__(alpha, definition_type=DefinitionType.CAPUTO, use_jax=False, use_numba=True)[source]

Initialize fractional derivative operator.

Parameters:

  • alpha (float | FractionalOrder) – Fractional order

  • definition_type (str | DefinitionType) – Type of fractional definition

  • use_jax (bool) – Whether to use JAX optimizations

  • use_numba (bool) – Whether to use NUMBA optimizations

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the fractional derivative numerically.

Parameters:

  • f_values (ndarray | jax.numpy.ndarray) – Function values at x_values

  • x_values (ndarray | jax.numpy.ndarray) – Points where function is evaluated

  • **kwargs – Additional parameters

Returns:

Fractional derivative values

Return type:

ndarray | jax.numpy.ndarray

set_implementation(implementation)[source]

Set the implementation for this operator.

Parameters:

implementation (BaseFractionalDerivative)

get_info()[source]

Get comprehensive information about this operator.

Return type:

Dict[str, Any]

class hpfracc.core.derivatives.FractionalDerivativeFactory[source]

Bases: object

Factory class for creating fractional derivative implementations.

This class provides a convenient way to create different types of fractional derivative implementations.

__init__()[source]

Initialize the factory.

register_implementation(definition_type, implementation_class)[source]

Register an implementation for a specific definition type.

Parameters:

  • definition_type (DefinitionType) – Type of fractional definition

  • implementation_class (type) – Implementation class

create(definition_type, alpha, use_jax=False, use_numba=True, **kwargs)[source]

Create a fractional derivative implementation.

Parameters:

  • definition_type (str | DefinitionType) – Type of fractional definition

  • alpha (float | FractionalOrder) – Fractional order

  • use_jax (bool) – Whether to use JAX optimizations

  • use_numba (bool) – Whether to use NUMBA optimizations

  • **kwargs – Additional parameters for the implementation

Returns:

Fractional derivative implementation

Return type:

BaseFractionalDerivative

get_available_implementations()[source]

Get list of available implementation types.

Return type:

List[str]

class hpfracc.core.derivatives.FractionalDerivativeChain(derivatives)[source]

Bases: object

Chain of fractional derivatives for composition.

This class allows composing multiple fractional derivatives to create higher-order or mixed-order derivatives.

Parameters:

derivatives (List[BaseFractionalDerivative])

__init__(derivatives)[source]

Initialize derivative chain.

Parameters:

derivatives (List[BaseFractionalDerivative]) – List of fractional derivatives to chain

_validate_chain()[source]

Validate the derivative chain.

compute(f, x, **kwargs)[source]

Compute the chained fractional derivative.

Parameters:

  • f (Callable) – Function to differentiate

  • x (float | ndarray | jax.numpy.ndarray) – Point(s) at which to compute the derivative

  • **kwargs – Additional parameters

Returns:

Chained fractional derivative value(s)

Return type:

float | ndarray | jax.numpy.ndarray

get_total_order()[source]

Get the total fractional order of the chain.

Return type:

float

get_chain_info()[source]

Get information about each derivative in the chain.

Return type:

List[Dict[str, Any]]

class hpfracc.core.derivatives.FractionalDerivativeProperties[source]

Bases: object

Properties and utilities for fractional derivatives.

static check_linearity(derivative, f, g, x, a=1.0, b=1.0, tolerance=1e-10)[source]

Check if a fractional derivative satisfies linearity.

Parameters:
Returns:

True if linearity is satisfied

Return type:

bool

static check_semigroup_property(derivative_class, alpha, beta, f, x, tolerance=1e-10)[source]

Check if a fractional derivative satisfies the semigroup property.

Parameters:

  • derivative_class (type) – Class of fractional derivative

  • alpha (float) – Fractional orders

  • beta (float) – Fractional orders

  • f (Callable) – Function to test

  • x (float | ndarray) – Point(s) to test at

  • tolerance (float) – Numerical tolerance

Returns:

True if semigroup property is satisfied

Return type:

bool

static get_analytical_solutions()[source]

Get analytical solutions for common functions.

Returns:

Dictionary of analytical solutions

Return type:

Dict[str, Callable]

hpfracc.core.derivatives.create_fractional_derivative(definition_type, alpha, use_jax=False, use_numba=True, **kwargs)[source]

Create a fractional derivative implementation.

Parameters:

  • definition_type (str | DefinitionType) – Type of fractional definition

  • alpha (float | FractionalOrder) – Fractional order

  • use_jax (bool) – Whether to use JAX optimizations

  • use_numba (bool) – Whether to use NUMBA optimizations

  • **kwargs – Additional parameters

Returns:

Fractional derivative implementation

Return type:

BaseFractionalDerivative

hpfracc.core.derivatives.create_derivative_operator(definition_type, alpha, use_jax=False, use_numba=True)[source]

Create a fractional derivative operator.

Parameters:

  • definition_type (str | DefinitionType) – Type of fractional definition

  • alpha (float | FractionalOrder) – Fractional order

  • use_jax (bool) – Whether to use JAX optimizations

  • use_numba (bool) – Whether to use NUMBA optimizations

Returns:

Fractional derivative operator

Return type:

FractionalDerivativeOperator

hpfracc.core.derivatives.caputo(f, alpha, **kwargs)[source]

Convenience function for Caputo derivative.

hpfracc.core.derivatives.riemann_liouville(f, alpha, **kwargs)[source]

Convenience function for Riemann-Liouville derivative.

hpfracc.core.derivatives.grunwald_letnikov(f, alpha, **kwargs)[source]

Convenience function for Grünwald-Letnikov derivative.

Optimized Methods

Optimized Fractional Calculus Methods This module provides unified, high-performance implementations of fractional calculus methods, leveraging JAX for GPU acceleration with NumPy as a fallback.

hpfracc.algorithms.optimized_methods._jnp_gradient_edge_order_2(f, h)[source]

JAX implementation of numpy.gradient with edge_order=2.

hpfracc.algorithms.optimized_methods._fast_binomial_coefficients_numpy(alpha, max_k)[source]

Compute binomial coefficients (alpha choose k) efficiently.

Parameters:
Return type:

ndarray

hpfracc.algorithms.optimized_methods._grunwald_letnikov_numpy(f, alpha, h)[source]

Compute Grünwald-Letnikov derivative using FFT convolution.

Parameters:
Return type:

ndarray

hpfracc.algorithms.optimized_methods._riemann_liouville_numpy(f, alpha, n, h)[source]

Compute Riemann-Liouville derivative using Grünwald-Letnikov approximation which is equivalent for small h, or using RL definition directly. Here we use the RL definition: D^alpha f = d^n/dt^n I^(n-alpha) f

Parameters:
Return type:

ndarray

hpfracc.algorithms.optimized_methods._caputo_numpy(f, alpha, h)[source]

Compute Caputo derivative using the L1 scheme (for 0 < alpha < 1) or L2 scheme (for 1 < alpha < 2).

Parameters:
Return type:

ndarray

class hpfracc.algorithms.optimized_methods.FractionalOperator(order)[source]

Bases: object

Parameters:

order (float | FractionalOrder)

__init__(order)[source]
Parameters:

order (float | FractionalOrder)

compute(f, t, h=None)[source]
Parameters:
Return type:

ndarray

class hpfracc.algorithms.optimized_methods.OptimizedGrunwaldLetnikov(order)[source]

Bases: FractionalOperator

Optimized implementation of the Grünwald-Letnikov fractional derivative.

Parameters:

order (float | FractionalOrder)

compute(f, t, h=None)[source]
Parameters:
Return type:

ndarray

class hpfracc.algorithms.optimized_methods.OptimizedRiemannLiouville(order)[source]

Bases: FractionalOperator

Optimized implementation of the Riemann-Liouville fractional derivative.

Parameters:

order (float | FractionalOrder)

__init__(order)[source]
Parameters:

order (float | FractionalOrder)

compute(f, t, h=None)[source]
Parameters:
Return type:

ndarray

class hpfracc.algorithms.optimized_methods.OptimizedCaputo(order)[source]

Bases: FractionalOperator

Optimized implementation of the Caputo fractional derivative.

Note: Caputo derivative is defined for all alpha > 0. The implementation uses the standard formulation: D^α f(t) = I^(n-α) f^(n)(t) where n = ceil(α)

Parameters:

order (float | FractionalOrder)

__init__(order)[source]
Parameters:

order (float | FractionalOrder)

compute(f, t, h=None)[source]
Parameters:
Return type:

ndarray

class hpfracc.algorithms.optimized_methods.ParallelOptimizedRiemannLiouville(order)[source]

Bases: OptimizedRiemannLiouville

Parallel version of OptimizedRiemannLiouville.

Currently inherits all functionality from OptimizedRiemannLiouville. Future enhancements will include: - Multi-threaded computation for large datasets - Distributed computing support - Load balancing across multiple cores

Parameters:

order (float | FractionalOrder)

class hpfracc.algorithms.optimized_methods.ParallelOptimizedCaputo(order)[source]

Bases: OptimizedCaputo

Parallel version of OptimizedCaputo.

Currently inherits all functionality from OptimizedCaputo. Future enhancements will include: - Multi-threaded computation for large datasets - Distributed computing support - Load balancing across multiple cores

Parameters:

order (float | FractionalOrder)

class hpfracc.algorithms.optimized_methods.ParallelOptimizedGrunwaldLetnikov(order)[source]

Bases: OptimizedGrunwaldLetnikov

Parallel version of OptimizedGrunwaldLetnikov.

Currently inherits all functionality from OptimizedGrunwaldLetnikov. Future enhancements will include: - Multi-threaded computation for large datasets - Distributed computing support - Load balancing across multiple cores

Parameters:

order (float | FractionalOrder)

class hpfracc.algorithms.optimized_methods.ParallelPerformanceMonitor[source]

Bases: object

Performance monitoring for parallel fractional calculus operations.

This is a placeholder class for future implementation. Will include: - Per-thread performance metrics - Load balancing statistics - Memory usage tracking across threads - Bottleneck identification

class hpfracc.algorithms.optimized_methods.NumbaOptimizer[source]

Bases: object

Numba JIT optimization utilities for fractional calculus.

This is a placeholder class for future implementation. Will include: - Automatic kernel generation - JIT compilation configuration - Cache management - Performance profiling

class hpfracc.algorithms.optimized_methods.NumbaFractionalKernels[source]

Bases: object

Pre-compiled Numba kernels for fractional calculus operations.

This is a placeholder class for future implementation. Will include: - Optimized convolution kernels - FFT-based fractional derivative kernels - Memory-efficient history accumulation

hpfracc.algorithms.optimized_methods.optimized_riemann_liouville(f, t, alpha, h=None)[source]
hpfracc.algorithms.optimized_methods.optimized_caputo(f, t, alpha, h=None)[source]
hpfracc.algorithms.optimized_methods.optimized_grunwald_letnikov(f, t, alpha, h=None)[source]
class hpfracc.algorithms.optimized_methods.OptimizedFractionalMethods[source]

Bases: object

Collection of optimized fractional calculus methods.

This is a placeholder class for future implementation. Will provide a unified interface for: - Method selection and recommendation - Automatic optimization based on problem characteristics - Performance benchmarking

class hpfracc.algorithms.optimized_methods.ParallelConfig(n_jobs=1, enabled=False, **kwargs)[source]

Bases: object

Configuration for parallel fractional calculus computations.

Variables:

  • n_jobs – Number of parallel jobs (threads/processes)

  • enabled – Whether parallel computation is enabled

__init__(n_jobs=1, enabled=False, **kwargs)[source]
class hpfracc.algorithms.optimized_methods.AdvancedFFTMethods(method='spectral', *args, **kwargs)[source]

Bases: object

Advanced FFT-based methods for fractional derivatives.

Supports multiple FFT-based approaches: - Spectral methods - Fractional Fourier transforms - Wavelet-based methods

Parameters:

method – FFT method to use (‘spectral’, ‘fractional_fourier’, ‘wavelet’)

__init__(method='spectral', *args, **kwargs)[source]
compute_derivative(f, t, alpha, h)[source]

Compute fractional derivative using FFT-based method.

Parameters:

  • f – Function values (array)

  • t – Time points (array)

  • alpha – Fractional order

  • h – Step size

Returns:

Fractional derivative approximation

class hpfracc.algorithms.optimized_methods.L1L2Schemes[source]

Bases: object

L1 and L2 finite difference schemes for fractional derivatives.

This is a placeholder class for future implementation. Will include: - L1 scheme for Caputo derivatives (first-order accuracy) - L2 scheme for Caputo derivatives (second-order accuracy) - L1-2 hybrid schemes

class hpfracc.algorithms.optimized_methods.ParallelLoadBalancer[source]

Bases: object

Load balancer for parallel fractional calculus computations.

This is a placeholder class for future implementation. Will include: - Dynamic work distribution - Thread pool management - Resource allocation optimization

hpfracc.algorithms.optimized_methods.parallel_optimized_riemann_liouville(f, t, alpha, h=None)[source]
hpfracc.algorithms.optimized_methods.parallel_optimized_caputo(f, t, alpha, h=None)[source]
hpfracc.algorithms.optimized_methods.parallel_optimized_grunwald_letnikov(f, t, alpha, h=None)[source]

Advanced Methods

Advanced Fractional Calculus Methods

This module implements advanced fractional calculus methods with optimizations: - Weyl derivative via FFT Convolution with parallelization - Marchaud derivative with Difference Quotient convolution and memory optimization - Hadamard derivative - Reiz/Reiz-Feller derivative via spectral method - Adomian Decomposition method

All methods include parallel processing and memory optimizations.

class hpfracc.algorithms.advanced_methods.WeylDerivative(alpha, parallel_config=None, optimized=True, **kwargs)[source]

Bases: object

Weyl fractional derivative via FFT Convolution with parallelization.

The Weyl derivative is defined as: D^α f(x) = (1/Γ(n-α)) (d/dx)^n ∫_x^∞ (τ-x)^(n-α-1) f(τ) dτ

This implementation uses FFT convolution for efficiency and parallel processing.

Parameters:
__init__(alpha, parallel_config=None, optimized=True, **kwargs)[source]

Initialize Weyl derivative calculator.

Parameters:
compute(f, x, h=None, use_parallel=True)[source]

Compute Weyl derivative using optimized FFT convolution.

Parameters:
Return type:

float | ndarray

_compute_serial(f, x, h)[source]

Serial computation using optimized FFT convolution.

Parameters:
Return type:

ndarray

_compute_parallel(f, x, h)[source]

Parallel computation using chunked processing.

Parameters:
Return type:

ndarray

_process_chunk(chunk_data)[source]

Process a chunk of data for parallel computation.

Parameters:

chunk_data (Tuple[ndarray, ndarray, float])

Return type:

ndarray

class hpfracc.algorithms.advanced_methods.MarchaudDerivative(alpha, parallel_config=None, **kwargs)[source]

Bases: object

Marchaud fractional derivative with Difference Quotient convolution and memory optimization.

The Marchaud derivative is defined as: D^α f(x) = α/Γ(1-α) ∫_0^∞ [f(x) - f(x-τ)] / τ^(α+1) dτ

This implementation uses difference quotient convolution with memory optimization.

Parameters:
__init__(alpha, parallel_config=None, **kwargs)[source]

Initialize Marchaud derivative calculator.

Parameters:
compute(f, x, h=None, use_parallel=True, memory_optimized=True)[source]

Compute Marchaud derivative with memory optimization.

Parameters:
Return type:

float | ndarray

_compute_memory_optimized(f, x, h, use_parallel)[source]

Memory-optimized computation using streaming approach.

Parameters:
Return type:

ndarray

_process_marchaud_chunk(chunk_data)[source]

Process a chunk for Marchaud derivative.

Parameters:

chunk_data (Tuple[ndarray, ndarray, float, int, int])

Return type:

ndarray

_compute_marchaud_segment(f, x, h, start_idx, end_idx)[source]

Compute Marchaud derivative for a segment.

Parameters:
Return type:

ndarray

_compute_standard(f, x, h, use_parallel)[source]

Standard computation without memory optimization.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.advanced_methods.HadamardDerivative(alpha=None, order=None, **kwargs)[source]

Bases: object

Hadamard fractional derivative.

The Hadamard derivative is defined as: D^α f(x) = (1/Γ(n-α)) (x d/dx)^n ∫_1^x (log(x/t))^(n-α-1) f(t) dt/t

This implementation uses logarithmic transformation and efficient quadrature.

Parameters:
__init__(alpha=None, order=None, **kwargs)[source]

Initialize Hadamard derivative calculator.

Accepts both alpha and order for backward compatibility.

Parameters:
compute(f, x, h=None)[source]

Compute Hadamard derivative using logarithmic transformation.

Parameters:
Return type:

float | ndarray

_compute_hadamard(f, x, h)[source]

Compute Hadamard derivative using logarithmic transformation.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.advanced_methods.ReizFellerDerivative(alpha, parallel_config=None, **kwargs)[source]

Bases: object

Reiz-Feller fractional derivative via spectral method.

The Reiz-Feller derivative is defined as: D^α f(x) = (1/2π) ∫_{-∞}^∞ |ξ|^α F[f](ξ) e^(iξx) dξ

This implementation uses FFT for spectral computation.

Parameters:
__init__(alpha, parallel_config=None, **kwargs)[source]

Initialize Reiz-Feller derivative calculator.

Parameters:
compute(f, x, h=None, use_parallel=True)[source]

Compute Reiz-Feller derivative using spectral method.

Parameters:
Return type:

float | ndarray

_compute_spectral(f, x, h, use_parallel)[source]

Compute using spectral method with FFT.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.advanced_methods.AdomianDecomposition(alpha, parallel_config=None, **kwargs)[source]

Bases: object

Adomian Decomposition Method for solving fractional differential equations.

This method decomposes the solution into a series and computes each term using the Adomian polynomials.

Parameters:
__init__(alpha, parallel_config=None, **kwargs)[source]

Initialize Adomian Decomposition solver.

Parameters:
solve(equation, initial_conditions, t_span, n_steps=1000, n_terms=10, use_parallel=True)[source]

Solve fractional differential equation using Adomian decomposition.

Parameters:

  • equation (Callable) – Function representing the FDE

  • initial_conditions (Dict) – Dictionary of initial conditions

  • t_span (Tuple[float, float]) – Time span (t0, tf)

  • n_steps (int) – Number of time steps

  • n_terms (int) – Number of terms in the decomposition

  • use_parallel (bool) – Whether to use parallel processing

Returns:

Tuple of (time_points, solution)

Return type:

Tuple[ndarray, ndarray]

_compute_terms_serial(equation, t, h, n_terms)[source]

Compute decomposition terms serially.

Parameters:
Return type:

List[ndarray]

_compute_terms_parallel(equation, t, h, n_terms)[source]

Compute decomposition terms in parallel.

Parameters:
Return type:

List[ndarray]

_compute_adomian_polynomial(equation, previous_terms, n, t)[source]

Compute the nth Adomian polynomial.

Parameters:
Return type:

ndarray

_compute_integral_term(adomian, t, h)[source]

Compute integral term using fractional integration.

Parameters:
Return type:

ndarray

_compute_single_term(equation, t, h, n)[source]

Compute a single decomposition term.

Parameters:
Return type:

ndarray

hpfracc.algorithms.advanced_methods.weyl_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for Weyl derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.marchaud_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for Marchaud derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.hadamard_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for Hadamard derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.reiz_feller_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for Reiz-Feller derivative.

Parameters:
Return type:

float | ndarray

class hpfracc.algorithms.advanced_methods.OptimizedWeylDerivative(order, **kwargs)[source]

Bases: WeylDerivative

Alias for backward compatibility with optimized Weyl derivative.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize optimized Weyl derivative calculator.

Parameters:

order (float | FractionalOrder)

class hpfracc.algorithms.advanced_methods.OptimizedMarchaudDerivative(order, **kwargs)[source]

Bases: MarchaudDerivative

Alias for backward compatibility with optimized Marchaud derivative.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize optimized Marchaud derivative calculator.

Parameters:

order (float | FractionalOrder)

class hpfracc.algorithms.advanced_methods.OptimizedHadamardDerivative(order, **kwargs)[source]

Bases: HadamardDerivative

Alias for backward compatibility with optimized Hadamard derivative.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize optimized Hadamard derivative calculator.

Parameters:

order (float | FractionalOrder)

class hpfracc.algorithms.advanced_methods.OptimizedReizFellerDerivative(order, **kwargs)[source]

Bases: ReizFellerDerivative

Alias for backward compatibility with optimized Reiz-Feller derivative.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize optimized Reiz-Feller derivative calculator.

Parameters:

order (float | FractionalOrder)

class hpfracc.algorithms.advanced_methods.OptimizedAdomianDecomposition(order, **kwargs)[source]

Bases: AdomianDecomposition

Alias for backward compatibility with optimized Adomian decomposition.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize optimized Adomian decomposition calculator.

Parameters:

order (float | FractionalOrder)

hpfracc.algorithms.advanced_methods.optimized_weyl_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for optimized Weyl derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.optimized_marchaud_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for optimized Marchaud derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.optimized_hadamard_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for optimized Hadamard derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.optimized_reiz_feller_derivative(f, x, alpha, h=None, **kwargs)[source]

Convenience function for optimized Reiz-Feller derivative.

Parameters:
Return type:

float | ndarray

Special Methods

Special Fractional Calculus Methods

This module implements specialized fractional calculus methods that are fundamental for advanced applications:

  • Fractional Laplacian: Essential for PDEs and diffusion processes

  • Fractional Fourier Transform: Powerful for signal processing and spectral analysis

  • Fractional Z-Transform: Useful for discrete-time systems and digital signal processing

These methods provide the foundation for more complex fractional calculus applications.

hpfracc.algorithms.special_methods._factorial(n)

Simple factorial function for NUMBA compatibility.

Parameters:

n (int)

Return type:

int

class hpfracc.algorithms.special_methods.FractionalLaplacian(alpha, *, dimension=1, boundary_conditions=None)[source]

Bases: object

Fractional Laplacian operator implementation.

The fractional Laplacian is defined as: (-Δ)^(α/2) f(x) = F^(-1)[|ξ|^α F[f](ξ)]

This is a fundamental operator in fractional PDEs, diffusion processes, and many physical applications.

Parameters:
__init__(alpha, *, dimension=1, boundary_conditions=None)[source]

Initialize fractional Laplacian calculator.

Parameters:

  • order – Fractional order (0 < α < 2)

  • dimension (int) – Spatial dimension

  • boundary_conditions (str | None) – Boundary condition type

  • alpha (float | FractionalOrder)

compute(f, x, h=None, method='spectral')[source]

Compute fractional Laplacian.

Parameters:

  • f (Callable | ndarray) – Function or array of function values

  • x (float | ndarray) – Domain points

  • h (float | None) – Step size (if not provided, inferred from x)

  • method (str) – Computation method (“spectral”, “finite_difference”, “integral”)

Returns:

Fractional Laplacian values

Return type:

float | ndarray

_spectral_method(f, x, h)[source]

Spectral method using FFT.

Parameters:
Return type:

ndarray

_finite_difference_method(f, x, h)[source]

Finite difference approximation.

Parameters:
Return type:

ndarray

compute_numerical(f, x, h=None)[source]

Numerical convenience API used by tests.

Uses finite-difference approximation under the hood.

Parameters:
Return type:

ndarray

_integral_method(f, x, h)[source]

Integral representation method.

Parameters:
Return type:

ndarray

_grunwald_coefficients(N)[source]

Compute Grünwald-Letnikov coefficients.

Parameters:

N (int)

Return type:

ndarray

class hpfracc.algorithms.special_methods.FractionalFourierTransform(alpha, *, method='spectral')[source]

Bases: object

Fractional Fourier Transform (FrFT) implementation.

The fractional Fourier transform is a generalization of the Fourier transform that depends on a parameter α. For α = π/2, it reduces to the standard Fourier transform.

FrFT[f](u) = ∫_{-∞}^∞ K_α(x, u) f(x) dx

where K_α is the fractional Fourier kernel.

Parameters:
__init__(alpha, *, method='spectral')[source]

Initialize fractional Fourier transform calculator.

Parameters:
transform(f, x, h=None, method='auto')[source]

Compute fractional Fourier transform.

Parameters:

  • f (Callable | ndarray) – Function or array of function values

  • x (float | ndarray) – Domain points

  • h (float | None) – Step size

  • method (str) – Computation method (“auto”, “discrete”, “spectral”, “fast”)

Returns:

Tuple of (u_domain, transformed_values)

Return type:

Tuple[ndarray, ndarray]

compute(f, x, h=None, method='auto')[source]

Compatibility wrapper returning only transformed values.

Some call sites expect a compute(…) API that returns the transformed values array directly. This method delegates to transform(…) and returns only the values component.

Parameters:
Return type:

ndarray

_discrete_method(f, x, h)[source]

Discrete fractional Fourier transform using optimized FFT-based approach.

Parameters:
Return type:

Tuple[ndarray, ndarray]

_fft_based_method(f, x, u, h)[source]

Fast FFT-based fractional Fourier transform.

Parameters:
Return type:

Tuple[ndarray, ndarray]

_chirp_based_method(f, x, u, h)[source]

Chirp-based algorithm for fractional Fourier transform.

Parameters:
Return type:

Tuple[ndarray, ndarray]

_spectral_method(f, x, h)[source]

Spectral method using decomposition.

Parameters:
Return type:

Tuple[ndarray, ndarray]

compute_numerical(f, x, h=None)[source]

Numerical convenience API returning only values.

Maps to the discrete method for accuracy.

Parameters:
Return type:

ndarray

_compute_transform_matrix(x, u, h)[source]

Compute the discrete fractional Fourier transform matrix.

Parameters:
Return type:

ndarray

_hermite_decomposition(f, x, h)[source]

Decompose function into Hermite-Gaussian basis.

Parameters:
Return type:

ndarray

_hermite_function(n, x)[source]

Compute Hermite-Gaussian function of order n.

Parameters:
Return type:

ndarray

_fractional_hermite(n, u, alpha)[source]

Compute fractional Fourier transform of Hermite function.

Parameters:
Return type:

ndarray

_fast_approximation(f, x, h)[source]

Fast approximation using interpolation between standard FFT and identity.

Parameters:
Return type:

Tuple[ndarray, ndarray]

class hpfracc.algorithms.special_methods.FractionalZTransform(alpha, *, method='spectral')[source]

Bases: object

Fractional Z-Transform implementation.

The fractional Z-transform is a generalization of the Z-transform that depends on a fractional parameter α. It’s useful for discrete-time systems and digital signal processing.

Z^α[f](z) = Σ_{n=0}^∞ f[n] z^(-αn)

Parameters:
__init__(alpha, *, method='spectral')[source]

Initialize fractional Z-transform calculator.

Parameters:
transform(f, z, method='direct')[source]

Compute fractional Z-transform.

Parameters:

  • f (ndarray) – Discrete signal array

  • z (complex | ndarray) – Complex variable(s) for evaluation

  • method (str) – Computation method (“direct”, “fft”)

Returns:

Transform values

Return type:

complex | ndarray

_direct_method(f, z)[source]

Direct computation of fractional Z-transform.

Parameters:
Return type:

complex | ndarray

_fft_method(f, z)[source]

FFT-based computation for unit circle evaluation.

Parameters:
Return type:

complex | ndarray

inverse_transform(F, z, N, method='contour')[source]

Compute inverse fractional Z-transform.

Parameters:

  • F (complex | ndarray) – Transform values

  • z (complex | ndarray) – Complex variable(s)

  • N (int) – Length of output signal

  • method (str) – Inversion method (“contour”, “residue”)

Returns:

Original signal

Return type:

ndarray

_contour_integration(F, z, N)[source]

Contour integration method for inverse transform.

Parameters:
Return type:

ndarray

_residue_method(F, z, N)[source]

Residue method for inverse transform.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.special_methods.FractionalMellinTransform(alpha)[source]

Bases: object

Fractional Mellin Transform implementation.

The fractional Mellin transform is defined as: M_α[f](s) = ∫₀^∞ f(x) x^(s-1+α) dx

This transform is useful for: - Scale-invariant signal processing - Fractional differential equations - Image processing and pattern recognition - Quantum mechanics applications

Parameters:

alpha (float | FractionalOrder)

__init__(alpha)[source]

Initialize fractional Mellin transform calculator.

Parameters:

alpha (float | FractionalOrder)

transform(f, x, s, method='numerical')[source]

Compute fractional Mellin transform.

Parameters:

  • f (Callable | ndarray) – Function or array of function values

  • x (float | ndarray) – Domain points (must be positive)

  • s (complex | ndarray) – Complex variable(s) for transform

  • method (str) – Computation method (“numerical”, “analytical”, “fft”)

Returns:

Transform values

Return type:

complex | ndarray

_numerical_method(f, x, s)[source]

Numerical integration method.

Parameters:
Return type:

complex | ndarray

_analytical_method(f, x, s)[source]

Analytical method for special functions.

Parameters:
Return type:

complex | ndarray

_fft_method(f, x, s)[source]

FFT-based method for efficient computation.

Parameters:
Return type:

complex | ndarray

inverse_transform(F, s, x, method='numerical')[source]

Compute inverse fractional Mellin transform.

Parameters:
Returns:

Original function values

Return type:

ndarray

_inverse_numerical(F, s, x)[source]

Numerical inverse transform.

Parameters:
Return type:

ndarray

_inverse_fft(F, s, x)[source]

FFT-based inverse transform.

Parameters:
Return type:

ndarray

hpfracc.algorithms.special_methods.fractional_laplacian(f, x, alpha, h=None, method='spectral')[source]

Convenience function for fractional Laplacian.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.special_methods.fractional_fourier_transform(f, x, alpha, h=None, method='auto')[source]

Convenience function for fractional Fourier transform.

Parameters:
Return type:

Tuple[ndarray, ndarray]

hpfracc.algorithms.special_methods.fractional_z_transform(f, z, alpha, method='direct')[source]

Convenience function for fractional Z-transform.

Parameters:
Return type:

complex | ndarray

hpfracc.algorithms.special_methods.fractional_mellin_transform(f, x, s, alpha, method='numerical')[source]

Convenience function for fractional Mellin transform.

Parameters:
Return type:

complex | ndarray

class hpfracc.algorithms.special_methods.SpecialMethodsConfig(optimized=True, parallel=False)[source]

Bases: object

Configuration for special methods optimization.

Parameters:
__init__(optimized=True, parallel=False)[source]

Initialize special methods configuration.

Parameters:

  • optimized (bool) – Enable optimized implementations

  • parallel (bool) – Enable parallel processing (if available)

class hpfracc.algorithms.special_methods.SpecialOptimizedWeylDerivative(alpha, config=None)[source]

Bases: object

Weyl derivative optimized using Fractional Fourier Transform.

This implementation replaces the standard FFT convolution approach with Fractional Fourier Transform for better performance, especially for large arrays and specific alpha values.

Parameters:
__init__(alpha, config=None)[source]

Initialize special optimized Weyl derivative calculator.

Parameters:
_determine_optimal_method()[source]

Determine the optimal computation method based on alpha value.

compute(f, x, h=None, method=None)[source]

Compute Weyl derivative using optimized method.

Parameters:
Return type:

float | ndarray

_compute_frft(f, x, h)[source]

Compute using Fractional Fourier Transform.

Parameters:
Return type:

ndarray

_compute_standard_fft(f, x, h)[source]

Compute using standard FFT approach.

Parameters:
Return type:

ndarray

_compute_hybrid(f, x, h)[source]

Compute using hybrid approach combining FRFT and standard FFT.

Parameters:
Return type:

ndarray

_compute_weyl_kernel(u, h)[source]

Compute Weyl derivative kernel.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.special_methods.SpecialOptimizedMarchaudDerivative(alpha, config=None)[source]

Bases: object

Marchaud derivative optimized using Fractional Z-Transform.

This implementation replaces the difference quotient convolution with Fractional Z-Transform for better performance on discrete signals.

Parameters:
__init__(alpha, config=None)[source]

Initialize special optimized Marchaud derivative calculator.

Parameters:
compute(f, x, h=None, method='z_transform')[source]

Compute Marchaud derivative using optimized method.

Parameters:
Return type:

float | ndarray

_compute_z_transform(f, x, h)[source]

Compute using Fractional Z-Transform.

Parameters:
Return type:

ndarray

_compute_standard(f, x, h)[source]

Compute using standard difference quotient approach.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.special_methods.SpecialOptimizedReizFellerDerivative(alpha, config=None)[source]

Bases: object

Reiz-Feller derivative optimized using Fractional Laplacian.

This implementation uses the Fractional Laplacian for efficient computation of the Reiz-Feller derivative, especially for spectral methods and large-scale problems.

Parameters:
__init__(alpha, config=None)[source]

Initialize special optimized Reiz-Feller derivative calculator.

Parameters:
compute(f, x, h=None, method='laplacian')[source]

Compute Reiz-Feller derivative using optimized method.

Parameters:
Return type:

float | ndarray

_compute_laplacian(f, x, h)[source]

Compute using Fractional Laplacian.

Parameters:
Return type:

ndarray

_compute_spectral(f, x, h)[source]

Compute using spectral method.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.special_methods.UnifiedSpecialMethods(config=None)[source]

Bases: object

Unified interface for all special methods with automatic method selection.

This class provides a unified API that automatically selects the best special method based on the problem characteristics.

Parameters:

config (SpecialMethodsConfig | None)

__init__(config=None)[source]

Initialize unified special methods interface.

Parameters:

config (SpecialMethodsConfig | None)

compute_derivative(f, x, alpha, h, method=None, problem_type='general')[source]

Compute fractional derivative using optimal special method.

Parameters:

  • f (Callable | ndarray) – Function or function values

  • x (ndarray) – Domain points

  • alpha (float | FractionalOrder) – Fractional order

  • h (float) – Step size

  • method (str | None) – Specific method to use (if None, auto-select)

  • problem_type (str) – Type of problem (“periodic”, “discrete”, “spectral”, “general”)

Returns:

Derivative values

Return type:

ndarray

_auto_select_method(problem_type, size, alpha)[source]

Automatically select the best method based on problem characteristics.

Parameters:
Return type:

str

hpfracc.algorithms.special_methods.special_optimized_weyl_derivative(f, x, alpha, h=None, method=None)[source]

Convenience function for special optimized Weyl derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.special_methods.special_optimized_marchaud_derivative(f, x, alpha, h=None, method='z_transform')[source]

Convenience function for special optimized Marchaud derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.special_methods.special_optimized_reiz_feller_derivative(f, x, alpha, h=None, method='laplacian')[source]

Convenience function for special optimized Reiz-Feller derivative.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.special_methods.unified_special_derivative(f, x, alpha, h, method=None, problem_type='general')[source]

Convenience function for unified special derivative computation.

Parameters:
Return type:

ndarray

Fractional Implementations

Fractional derivative and integral implementations.

This module provides concrete implementations of fractional derivatives and integrals that can be registered with the factory.

Performance Note (v2.1.0): - All implementations automatically benefit from intelligent backend selection - Backend selection happens in the underlying optimized algorithms - Small data (< 1K elements): Uses NumPy/Numba for minimal overhead - Large data (> 100K elements): Uses GPU when available for acceleration - Zero code changes required - optimization is automatic

class hpfracc.core.fractional_implementations._AlphaCompatibilityWrapper(fractional_order)[source]

Bases: object

Wrapper that makes alpha behave like both a float and FractionalOrder.

Parameters:

fractional_order (FractionalOrder)

__init__(fractional_order)[source]
Parameters:

fractional_order (FractionalOrder)

class hpfracc.core.fractional_implementations.RiemannLiouvilleDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Riemann-Liouville fractional derivative implementation.

Uses the optimized implementation from algorithms.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, h=None, **kwargs)[source]

Compute the Riemann-Liouville fractional derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the derivative numerically from function values.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.CaputoDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Caputo fractional derivative implementation.

Uses the optimized implementation from algorithms.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, h=None, **kwargs)[source]

Compute the Caputo fractional derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the derivative numerically from function values.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.GrunwaldLetnikovDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Grunwald-Letnikov fractional derivative implementation.

Uses the optimized implementation from algorithms.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, h=None, **kwargs)[source]

Compute the Grunwald-Letnikov fractional derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the derivative numerically from function values.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.CaputoFabrizioDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Caputo-Fabrizio fractional derivative implementation.

Uses the novel implementation from algorithms.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the Caputo-Fabrizio fractional derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the derivative numerically from function values.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.AtanganaBaleanuDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Atangana-Baleanu fractional derivative implementation.

Uses the novel implementation from algorithms.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the Atangana-Baleanu fractional derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the derivative numerically from function values.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.FractionalLaplacian(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Fractional Laplacian operator implementation.

Uses the special implementation from algorithms.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the fractional Laplacian.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the fractional Laplacian numerically from function values.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.FractionalFourierTransform(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Fractional Fourier Transform implementation.

Uses the special implementation from algorithms.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the fractional Fourier transform.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the fractional Fourier transform numerically from function values.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.MillerRossDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Miller-Ross fractional derivative implementation.

This is a generalization of the Riemann-Liouville derivative.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the Miller-Ross fractional derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the Miller-Ross fractional derivative numerically.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.WeylDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Weyl fractional derivative implementation.

Uses the advanced implementation from algorithms with FFT convolution and parallel processing optimizations.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the Weyl fractional derivative using advanced methods.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the Weyl fractional derivative numerically using advanced methods.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.MarchaudDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Marchaud fractional derivative implementation.

Uses the advanced implementation from algorithms with difference quotient convolution and memory optimization.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the Marchaud fractional derivative using advanced methods.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the Marchaud fractional derivative numerically using advanced methods.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.HadamardDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Hadamard fractional derivative implementation.

Uses the advanced implementation from algorithms with logarithmic kernels.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the Hadamard fractional derivative using advanced methods.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the Hadamard fractional derivative numerically using advanced methods.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.ReizFellerDerivative(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Reiz-Feller fractional derivative implementation.

Uses the advanced implementation from algorithms with spectral methods.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the Reiz-Feller fractional derivative using advanced methods.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the Reiz-Feller fractional derivative numerically using advanced methods.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.ParallelOptimizedRiemannLiouville(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Parallel-optimized Riemann-Liouville fractional derivative.

Uses parallel processing and load balancing for high-performance computation.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the parallel-optimized Riemann-Liouville derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the parallel-optimized Riemann-Liouville derivative numerically.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.ParallelOptimizedCaputo(order, **kwargs)[source]

Bases: BaseFractionalDerivative

Parallel-optimized Caputo fractional derivative.

Uses parallel processing and load balancing for high-performance computation.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

compute(f, x, **kwargs)[source]

Compute the parallel-optimized Caputo derivative.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the parallel-optimized Caputo derivative numerically.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.RieszFisherOperator(alpha, **kwargs)[source]

Bases: BaseFractionalDerivative

Riesz-Fisher fractional operator implementation.

The Riesz-Fisher operator is a combination of left and right fractional derivatives/integrals that is particularly useful in signal processing and image analysis. It’s defined as:

R^α f(x) = (1/2) * [D^α_+ f(x) + D^α_- f(x)]

where D^α_+ is the left-sided and D^α_- is the right-sided operator.

For α > 0: acts as a derivative For α < 0: acts as an integral For α = 0: acts as identity

Parameters:

alpha (float | FractionalOrder)

__init__(alpha, **kwargs)[source]

Initialize fractional derivative.

Parameters:

  • order – Fractional order

  • definition – Mathematical definition

  • use_jax – Whether to use JAX optimizations

  • use_numba – Whether to use NUMBA optimizations

  • alpha (float | FractionalOrder)

compute(f, x, **kwargs)[source]

Compute the Riesz-Fisher fractional operator.

Parameters:
Return type:

float | ndarray

compute_numerical(f_values, x_values, **kwargs)[source]

Compute the Riesz-Fisher fractional operator numerically.

Parameters:
Return type:

ndarray

class hpfracc.core.fractional_implementations.AdomianDecompositionMethod(max_terms=10, tolerance=1e-06)[source]

Bases: object

Adomian Decomposition Method for solving fractional differential equations.

This is an analytical method that decomposes the solution into a series of components that can be computed iteratively.

Parameters:
__init__(max_terms=10, tolerance=1e-06)[source]

Initialize the Adomian Decomposition Method.

Parameters:

  • max_terms (int) – Maximum number of terms to compute

  • tolerance (float) – Convergence tolerance

solve(equation, initial_condition, domain, **kwargs)[source]

Solve a fractional differential equation using Adomian decomposition.

Parameters:

  • equation (Callable) – The fractional differential equation

  • initial_condition (Callable) – Initial condition function

  • domain (Tuple[float, float] | ndarray) – Solution domain or array of points

  • **kwargs – Additional parameters

Returns:

Solution dictionary with components and convergence info

Return type:

Dict[str, Any]

compute_adomian_polynomials(nonlinear_term, u_series, order)[source]

Compute Adomian polynomials for nonlinear terms.

Parameters:

  • nonlinear_term (Callable) – The nonlinear term in the equation

  • u_series (List[Callable]) – Series of solution components

  • order (int) – Order of the polynomial to compute

Returns:

List of Adomian polynomial functions

Return type:

List[Callable]

decompose_function(func, x_vals)[source]

Decompose a function using Adomian decomposition.

Parameters:

  • func (Callable) – Function to decompose

  • x_vals (ndarray) – Array of x values

Returns:

Decomposed function values

Return type:

ndarray

solve_equation(func, x_vals)[source]

Solve an equation using Adomian decomposition.

Parameters:

  • func (Callable) – Equation function

  • x_vals (ndarray) – Array of x values

Returns:

Solution values

Return type:

ndarray

hpfracc.core.fractional_implementations.create_fractional_integral(method, alpha, **kwargs)[source]

Create a fractional integral implementation.

Parameters:

  • method (str) – Integration method (“RL” for Riemann-Liouville)

  • alpha (float | FractionalOrder) – Fractional order

  • **kwargs – Additional parameters

Returns:

Fractional integral implementation

hpfracc.core.fractional_implementations.create_riesz_fisher_operator(alpha, **kwargs)[source]

Create a Riesz-Fisher fractional operator.

Parameters:

  • alpha (float | FractionalOrder) – Fractional order - α > 0: acts as a derivative - α < 0: acts as an integral - α = 0: acts as identity

  • **kwargs – Additional parameters

Returns:

RieszFisherOperator instance

hpfracc.core.fractional_implementations.register_fractional_implementations()[source]

Register all fractional derivative implementations with the factory.

This function should be called during package initialization.

Core Integrals

Fractional Integrals Module

This module provides comprehensive implementations of fractional integrals including: - Riemann-Liouville fractional integrals - Caputo fractional integrals - Weyl fractional integrals - Hadamard fractional integrals - Numerical methods for fractional integration - Special cases and analytical solutions

class hpfracc.core.integrals.FractionalIntegral(order, method='RL')[source]

Bases: object

Base class for fractional integral implementations.

This class provides the foundation for different types of fractional integrals and their numerical implementations.

Parameters:
__init__(order, method='RL')[source]

Initialize fractional integral.

Parameters:

  • order (float | FractionalOrder) – Fractional order (0 < α < 1 for most methods)

  • method (str) – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

_validate_parameters()[source]

Validate fractional order and method parameters.

compute(f, x, h=None)[source]

Alias for __call__; accepts an optional step size h for compatibility.

Parameters:
Return type:

float | ndarray | torch.Tensor

class hpfracc.core.integrals.RiemannLiouvilleIntegral(order)[source]

Bases: FractionalIntegral

Riemann-Liouville fractional integral.

The Riemann-Liouville fractional integral of order α is defined as:

I^α f(t) = (1/Γ(α)) ∫₀ᵗ (t-τ)^(α-1) f(τ) dτ

where Γ(α) is the gamma function.

Parameters:

order (float | FractionalOrder)

__init__(order)[source]

Initialize fractional integral.

Parameters:

  • order (float | FractionalOrder) – Fractional order (0 < α < 1 for most methods)

  • method – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

compute(f, x, h=None)[source]

Compute Riemann-Liouville fractional integral (alias for __call__).

Parameters:

  • f (Callable) – Function to integrate

  • x (float | ndarray | torch.Tensor) – Point(s) at which to evaluate the integral

  • h (float | None)

Returns:

Fractional integral value(s)

Return type:

float | ndarray | torch.Tensor

_coerce_function(f, x_arg)[source]

If f is an array, create an interpolating callable over x grid.

Parameters:
Return type:

Callable

_compute_scalar(f, x)[source]

Compute fractional integral at a scalar point.

Parameters:
Return type:

float

_compute_array_numpy(f, x)[source]

Compute fractional integral for numpy array.

Parameters:
Return type:

ndarray

_compute_array_torch(f, x)[source]

Compute fractional integral for torch tensor.

Parameters:
Return type:

torch.Tensor

class hpfracc.core.integrals.CaputoIntegral(order)[source]

Bases: FractionalIntegral

Caputo fractional integral.

The Caputo fractional integral is related to the Riemann-Liouville integral and is often more suitable for initial value problems.

Supports all fractional orders α ≥ 0: - For 0 < α < 1: Equals Riemann-Liouville integral - For α ≥ 1: Uses decomposition I^α = I^n * I^β where α = n + β

Examples

>>> from hpfracc.core.integrals import CaputoIntegral
>>> def f(x): return x**2
>>> # For 0 < α < 1
>>> integral_05 = CaputoIntegral(0.5)
>>> result = integral_05(f, 1.0)
>>> # For α ≥ 1
>>> integral_15 = CaputoIntegral(1.5)
>>> result = integral_15(f, 1.0)
Parameters:

order (float | FractionalOrder)

__init__(order)[source]

Initialize fractional integral.

Parameters:

  • order (float | FractionalOrder) – Fractional order (0 < α < 1 for most methods)

  • method – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

_coerce_function(f, x_arg)[source]

If f is an array, create an interpolating callable over x grid.

Parameters:
Return type:

Callable

compute(f, x, h=None)[source]

Alias for __call__; accepts an optional step size h for compatibility.

Parameters:
Return type:

float | ndarray | torch.Tensor

class hpfracc.core.integrals.WeylIntegral(order)[source]

Bases: FractionalIntegral

Weyl fractional integral.

The Weyl fractional integral is suitable for functions defined on the entire real line and is particularly useful for periodic functions.

Parameters:

order (float | FractionalOrder)

__init__(order)[source]

Initialize fractional integral.

Parameters:

  • order (float | FractionalOrder) – Fractional order (0 < α < 1 for most methods)

  • method – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

_compute_scalar(f, x)[source]

Compute Weyl fractional integral at a scalar point.

Parameters:
Return type:

float

_compute_array_numpy(f, x)[source]

Compute Weyl fractional integral for numpy array.

Parameters:
Return type:

ndarray

compute(f, x, h=None)[source]

Compute Weyl integral; h parameter is accepted for compatibility but not used.

Parameters:
Return type:

float | ndarray | torch.Tensor

_compute_array_torch(f, x)[source]

Compute Weyl fractional integral for torch tensor.

Parameters:
Return type:

torch.Tensor

class hpfracc.core.integrals.HadamardIntegral(order)[source]

Bases: FractionalIntegral

Hadamard fractional integral.

The Hadamard fractional integral uses logarithmic kernels and is defined as: I^α_H f(t) = (1/Γ(α)) ∫₁ᵗ (ln(t/τ))^(α-1) f(τ) dτ/τ

Parameters:

order (float | FractionalOrder)

__init__(order)[source]

Initialize fractional integral.

Parameters:

  • order (float | FractionalOrder) – Fractional order (0 < α < 1 for most methods)

  • method – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

_compute_scalar(f, x)[source]

Compute Hadamard fractional integral at a scalar point.

Parameters:
Return type:

float

_compute_array_numpy(f, x)[source]

Compute Hadamard fractional integral for numpy array.

Parameters:
Return type:

ndarray

_compute_array_torch(f, x)[source]

Compute Hadamard fractional integral for torch tensor.

Parameters:
Return type:

torch.Tensor

hpfracc.core.integrals.create_fractional_integral(order, method='RL')[source]

Factory function to create fractional integral objects.

Parameters:

  • order (float | FractionalOrder) – Fractional order

  • method (str) – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

Returns:

Appropriate fractional integral object

Return type:

FractionalIntegral

hpfracc.core.integrals.analytical_fractional_integral(f_type, alpha, x)[source]

Compute analytical fractional integrals for common functions.

Parameters:

  • f_type (str) – Type of function (“power”, “exponential”, “trigonometric”)

  • alpha (float) – Fractional order

  • x (float | ndarray) – Point(s) at which to evaluate

Returns:

Analytical fractional integral value(s)

Return type:

float | ndarray

hpfracc.core.integrals.trapezoidal_fractional_integral(f, x, alpha, method='RL')[source]

Compute fractional integral using trapezoidal rule.

Parameters:

  • f (Callable) – Function to integrate

  • x (ndarray) – Points at which to evaluate

  • alpha (float) – Fractional order

  • method (str) – Integration method

Returns:

Fractional integral values

Return type:

ndarray

hpfracc.core.integrals.simpson_fractional_integral(f, x, alpha, method='RL')[source]

Compute fractional integral using Simpson’s rule.

Parameters:

  • f (Callable) – Function to integrate

  • x (ndarray) – Points at which to evaluate

  • alpha (float) – Fractional order

  • method (str) – Integration method

Returns:

Fractional integral values

Return type:

ndarray

hpfracc.core.integrals.fractional_integral_properties(alpha)[source]

Return mathematical properties of fractional integrals.

Parameters:

alpha (float) – Fractional order

Returns:

Dictionary containing properties

Return type:

dict

hpfracc.core.integrals.validate_fractional_integral(f, integral_result, x, alpha, method='RL')[source]

Validate fractional integral computation.

Parameters:

  • f (Callable) – Original function

  • integral_result (ndarray) – Computed fractional integral

  • x (ndarray) – Points at which integral was computed

  • alpha (float) – Fractional order

  • method (str) – Integration method

Returns:

Validation results

Return type:

dict

class hpfracc.core.integrals.MillerRossIntegral(order)[source]

Bases: FractionalIntegral

Miller-Ross fractional integral.

The Miller-Ross fractional integral is defined as: I^α_MR f(t) = (1/Γ(α)) ∫₀ᵗ (t-τ)^(α-1) f(τ) dτ

This is similar to Riemann-Liouville but with different normalization.

Parameters:

order (float | FractionalOrder)

__init__(order)[source]

Initialize fractional integral.

Parameters:

  • order (float | FractionalOrder) – Fractional order (0 < α < 1 for most methods)

  • method – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

_compute_scalar(f, x)[source]

Compute Miller-Ross fractional integral at a scalar point.

Parameters:
Return type:

float

_compute_array_numpy(f, x)[source]

Compute Miller-Ross fractional integral for numpy array.

Parameters:
Return type:

ndarray

_compute_array_torch(f, x)[source]

Compute Miller-Ross fractional integral for torch tensor.

Parameters:
Return type:

torch.Tensor

class hpfracc.core.integrals.MarchaudIntegral(order)[source]

Bases: FractionalIntegral

Marchaud fractional integral.

The Marchaud fractional integral is defined as: I^α_M f(t) = (1/Γ(α)) ∫₀ᵗ (t-τ)^(α-1) f(τ) dτ

This is a generalization that can handle more general kernels.

Parameters:

order (float | FractionalOrder)

__init__(order)[source]

Initialize fractional integral.

Parameters:

  • order (float | FractionalOrder) – Fractional order (0 < α < 1 for most methods)

  • method – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

_compute_scalar(f, x)[source]

Compute Marchaud fractional integral at a scalar point.

Parameters:
Return type:

float

_compute_array_numpy(f, x)[source]

Compute Marchaud fractional integral for numpy array.

Parameters:
Return type:

ndarray

_compute_array_torch(f, x)[source]

Compute Marchaud fractional integral for torch tensor.

Parameters:
Return type:

torch.Tensor

class hpfracc.core.integrals.FractionalIntegralFactory[source]

Bases: object

Factory class for creating fractional integral implementations.

This class provides a convenient way to create different types of fractional integral implementations.

__init__()[source]

Initialize the factory.

register_implementation(method, implementation_class)[source]

Register an implementation for a specific method.

Parameters:

  • method (str) – Integration method (e.g., “RL”, “Caputo”, “Weyl”, “Hadamard”)

  • implementation_class (type) – Implementation class

create(method, alpha, **kwargs)[source]

Create a fractional integral implementation.

Parameters:

  • method (str) – Integration method

  • alpha (float | FractionalOrder) – Fractional order

  • **kwargs – Additional parameters for the implementation

Returns:

Fractional integral implementation

Return type:

FractionalIntegral

get_available_methods()[source]

Get list of available integration methods.

Return type:

List[str]

hpfracc.core.integrals.create_fractional_integral_factory(method, order, **kwargs)[source]

Create a fractional integral implementation using the factory.

Parameters:

  • method (str) – Integration method (“RL”, “Caputo”, “Weyl”, “Hadamard”)

  • alpha – Fractional order

  • **kwargs – Additional parameters

  • order (float | FractionalOrder)

Returns:

Fractional integral implementation

Return type:

FractionalIntegral