Derivatives and Integrals API Reference

All fractional derivative and integral classes and functions exposed through core and algorithms.

Layout

Derivatives (RL / Caputo / Grünwald–Letnikov)

Integrals

Canonical derivative engines

Unified fractional derivative engines (canonical implementation path).

RiemannLiouville, Caputo, and GrunwaldLetnikov here are the single dispatching implementations used across the library. Higher-level wrappers in hpfracc.core.fractional_implementations delegate to these classes; names such as OptimizedCaputo in hpfracc.algorithms.optimized_methods are backward-compatible aliases of the same types. ParallelOptimized* in that module are the same engine classes with a parallel-oriented name; compute_numerical is provided on UnifiedFractionalOperator so call sites match adapter-style APIs without duplicating kernels.

hpfracc.algorithms.derivatives._handle_backend_failure(method, backend, error)[source]

Apply fail-fast policy or explicit warning for backend failures.

Parameters:
Return type:

None

class hpfracc.algorithms.derivatives.UnifiedFractionalOperator(order, backend='auto')[source]

Bases: FractionalOperator

Base class for unified operators with backend dispatch.

Parameters:
__init__(order, backend='auto')[source]
Parameters:
compute_numerical(f_values, x_values, **kwargs)[source]

Array-in / array-out entry point; same backend path as compute().

Matches the BaseFractionalDerivative.compute_numerical surface so parallel and engine aliases can be used interchangeably in tests and factory wiring without a second implementation.

Parameters:
Return type:

ndarray

_dispatch(f_arr, h)[source]

Dispatches computation to the appropriate backend implementation.

class hpfracc.algorithms.derivatives.RiemannLiouville(order, backend='auto')[source]

Bases: UnifiedFractionalOperator

Riemann-Liouville fractional derivative. D^α f(t) = (d/dt)^n I^(n-α) f(t)

Parameters:
__init__(order, backend='auto')[source]
Parameters:
compute(f, t, h=None)[source]
Parameters:
Return type:

ndarray

class hpfracc.algorithms.derivatives.Caputo(order, backend='auto')[source]

Bases: UnifiedFractionalOperator

Caputo fractional derivative. D^α f(t) = I^(n-α) f^(n)(t)

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

ndarray

class hpfracc.algorithms.derivatives.GrunwaldLetnikov(order, backend='auto')[source]

Bases: UnifiedFractionalOperator

Grünwald-Letnikov fractional derivative.

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

ndarray

Core Derivatives (factory and base classes)

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:

  • order (float | FractionalOrder) – Fractional order

  • definition (FractionalDefinition | None) – Mathematical definition

  • use_jax (bool) – Whether to use JAX optimizations

  • use_numba (bool) – Whether to use NUMBA optimizations

_validate_parameters()[source]

Validate input parameters.

abstractmethod 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

abstractmethod 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 (canonical Caputo engine).

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

Convenience function for Riemann-Liouville derivative (canonical engine).

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

Convenience function for Grünwald-Letnikov derivative (canonical engine).

Optimized Methods (aliases)

Backward-compatibility shim for legacy Optimized* names (RL / Caputo / GL engines).

The only RL / Caputo / Grünwald–Letnikov implementations are RiemannLiouville, Caputo, and GrunwaldLetnikov. Optimized* and ParallelOptimized* here are thin aliases of those classes.

Deprecated GPU-prefixed wrappers and GPUConfig also live here. Import them from this module only.

Prefer: from hpfracc.algorithms.derivatives import Caputo.

Numerical integrity: symbols that are not implemented do not silently succeed. They raise NotImplementedError with guidance. Reserved APIs may be implemented later.

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

Reserved unified facade; not implemented — use per-method classes in derivatives.

compute(*args, **kwargs)[source]
Parameters:
Return type:

Any

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

Bases: object

Configuration for optional parallel paths in advanced_methods (e.g. Weyl).

Accepts n_jobs / enabled and common aliases num_workers, chunk_size.

Parameters:

  • n_jobs (int)

  • enabled (bool)

  • num_workers (int | None)

  • chunk_size (int | None)

  • kwargs (Any)

__init__(n_jobs=1, enabled=False, *, num_workers=None, chunk_size=None, **kwargs)[source]
Parameters:

  • n_jobs (int)

  • enabled (bool)

  • num_workers (int | None)

  • chunk_size (int | None)

  • kwargs (Any)

get_optimal_workers()[source]

Return a sensible worker count (minimal implementation for callers/tests).

Return type:

int

class hpfracc.algorithms.optimized_methods.AdvancedFFTMethods(method='spectral', *args, **kwargs)[source]

Bases: object

Reserved for future FFT-focused helpers; not implemented.

Parameters:
__init__(method='spectral', *args, **kwargs)[source]
Parameters:
class hpfracc.algorithms.optimized_methods.L1L2Schemes(scheme='l1', *args, **kwargs)[source]

Bases: object

Reserved for L1/L2 temporal discretization helpers; not implemented.

Parameters:
__init__(scheme='l1', *args, **kwargs)[source]
Parameters:
class hpfracc.algorithms.optimized_methods.ParallelLoadBalancer[source]

Bases: object

Reserved for future parallel chunking; no balancing logic yet.

balance_load(data, num_workers=1)[source]
Parameters:

  • data (Any)

  • num_workers (int)

Return type:

Any

get_chunk_sizes(total, num_workers)[source]
Parameters:

  • total (int)

  • num_workers (int)

Return type:

list

class hpfracc.algorithms.optimized_methods.ParallelOptimizedRiemannLiouville(order, backend='auto')[source]

Bases: RiemannLiouville

Alias for RiemannLiouville.

Parameters:
class hpfracc.algorithms.optimized_methods.ParallelOptimizedCaputo(order, backend='auto')[source]

Bases: Caputo

Alias for Caputo.

Parameters:
class hpfracc.algorithms.optimized_methods.ParallelOptimizedGrunwaldLetnikov(order, backend='auto')[source]

Bases: GrunwaldLetnikov

Alias for GrunwaldLetnikov.

Parameters:
class hpfracc.algorithms.optimized_methods.NumbaOptimizer(*args, **kwargs)[source]

Bases: object

Parameters:
__init__(*args, **kwargs)[source]
Parameters:
class hpfracc.algorithms.optimized_methods.NumbaFractionalKernels(*args, **kwargs)[source]

Bases: object

Parameters:
__init__(*args, **kwargs)[source]
Parameters:
class hpfracc.algorithms.optimized_methods.NumbaParallelManager(*args, **kwargs)[source]

Bases: object

Parameters:
__init__(*args, **kwargs)[source]
Parameters:
hpfracc.algorithms.optimized_methods.benchmark_parallel_vs_serial(*args, **kwargs)[source]
Parameters:
Return type:

Any

hpfracc.algorithms.optimized_methods.optimize_parallel_parameters(*args, **kwargs)[source]
Parameters:
Return type:

Any

hpfracc.algorithms.optimized_methods.memory_efficient_caputo(*args, **kwargs)[source]
Parameters:
Return type:

Any

hpfracc.algorithms.optimized_methods.block_processing_kernel(*args, **kwargs)[source]
Parameters:
Return type:

Any

class hpfracc.algorithms.optimized_methods.GPUConfig(backend='auto', memory_limit=0.8, batch_size=None, multi_gpu=False, monitor_performance=True, fallback_to_cpu=True, device_id=None, use_intelligent_selection=True)[source]

Bases: object

[DEPRECATED] Legacy GPU dispatch config; use backend= on unified engines.

Parameters:

  • backend (str)

  • memory_limit (float)

  • batch_size (int | None)

  • multi_gpu (bool)

  • monitor_performance (bool)

  • fallback_to_cpu (bool)

  • device_id (int | None)

  • use_intelligent_selection (bool)

__init__(backend='auto', memory_limit=0.8, batch_size=None, multi_gpu=False, monitor_performance=True, fallback_to_cpu=True, device_id=None, use_intelligent_selection=True)[source]
Parameters:

  • backend (str)

  • memory_limit (float)

  • batch_size (int | None)

  • multi_gpu (bool)

  • monitor_performance (bool)

  • fallback_to_cpu (bool)

  • device_id (int | None)

  • use_intelligent_selection (bool)

select_backend_for_data(*args, **kwargs)[source]
Parameters:
Return type:

str

class hpfracc.algorithms.optimized_methods._LegacyGPUShim[source]

Bases: object

Map legacy GPUConfig backend strings to unified backend.

class hpfracc.algorithms.optimized_methods.GPUOptimizedRiemannLiouville(alpha, gpu_config=None, *, config=None, batch_size=None)[source]

Bases: RiemannLiouville, _LegacyGPUShim

[DEPRECATED] Use RiemannLiouville(..., backend='jax'|'cuda'|'numpy').

Parameters:
__init__(alpha, gpu_config=None, *, config=None, batch_size=None)[source]
Parameters:
enable_monitoring()[source]
Return type:

None

class hpfracc.algorithms.optimized_methods.GPUOptimizedCaputo(alpha, gpu_config=None, *, config=None, memory_efficient=None)[source]

Bases: Caputo, _LegacyGPUShim

[DEPRECATED] Use Caputo(..., backend='jax'|'cuda'|'numpy').

Parameters:
__init__(alpha, gpu_config=None, *, config=None, memory_efficient=None)[source]
Parameters:
compute(f, t, h=None, method='l1')[source]
Parameters:
Return type:

Any

class hpfracc.algorithms.optimized_methods.GPUOptimizedGrunwaldLetnikov(alpha, gpu_config=None, *, config=None, use_shared_memory=None)[source]

Bases: GrunwaldLetnikov, _LegacyGPUShim

[DEPRECATED] Use GrunwaldLetnikov(..., backend='jax'|'cuda'|'numpy').

Parameters:
__init__(alpha, gpu_config=None, *, config=None, use_shared_memory=None)[source]
Parameters:
class hpfracc.algorithms.optimized_methods.MultiGPUManager(*args, **kwargs)[source]

Bases: object

[DEPRECATED] Stub; not used by unified engines.

Parameters:
__init__(*args, **kwargs)[source]
Parameters:
Return type:

None

class hpfracc.algorithms.optimized_methods.GPUOptimizedMethods(*args, **kwargs)[source]

Bases: object

Legacy placeholder; never implemented. Use engines from derivatives.

Parameters:
__init__(*args, **kwargs)[source]
Parameters:
Return type:

None

hpfracc.algorithms.optimized_methods.gpu_optimized_riemann_liouville(f, alpha, t, h=None, *args, **kwargs)[source]
Parameters:
Return type:

Any

hpfracc.algorithms.optimized_methods.gpu_optimized_caputo(f, alpha, t, h=None, *args, **kwargs)[source]
Parameters:
Return type:

Any

hpfracc.algorithms.optimized_methods.gpu_optimized_grunwald_letnikov(f, alpha, t, h=None, *args, **kwargs)[source]
Parameters:
Return type:

Any

hpfracc.algorithms.optimized_methods.benchmark_gpu_vs_cpu(*args, **kwargs)[source]
Parameters:
Return type:

dict

Integral methods (algorithms)

Fractional Integral Methods

Legacy / alternate API: FFT- and method-switching integral classes used by existing tests and examples. For the canonical integral hierarchy tied to FractionalOrder and core (quad-based __call__ / compute), use hpfracc.core.integrals (RiemannLiouvilleIntegral, CaputoIntegral, …). The direct RL path in this module calls that canonical implementation for α ≥ 1e-4; for smaller α a legacy discrete sum avoids quad blow-up on short grids. WeylIntegral here follows the same rule: core quad Weyl for normal α, legacy discrete window for α < 1e-4.

``method`` and ``fft_threshold`` (RL / Caputo): With method="auto", arrays shorter than fft_threshold (default 1000 on RiemannLiouvilleIntegral) use the direct path; longer grids use FFT. For α ≥ 1e-4, direct mode calls hpfracc.core.integrals (quad on each prefix of t). If FFT accumulation looks unstable for your grid length or α, pass method="direct" or use core.integrals directly.

``method=”adaptive”``: FFT and direct paths are different discretizations; cross-check uses a scale-aware relative L2 residual. UserWarning signals moderate disagreement (direct is returned); RuntimeWarning is reserved for non-finite FFT output or severe disagreement—see module constants _ADAPTIVE_AGREE_RTOL and _ADAPTIVE_SEVERE_RTOL.

This module provides high-performance implementations of fractional integrals including Riemann-Liouville and Caputo integrals with optimized algorithms.

hpfracc.algorithms.integral_methods._adaptive_fft_direct_relative_l2(a, b)[source]

||a-b||_2 / max(||b||_2, eps) for scale-aware comparison.

Parameters:
Return type:

float

class hpfracc.algorithms.integral_methods.RiemannLiouvilleIntegral(alpha, method='auto', optimize_memory=True, use_jax=False)[source]

Bases: object

Riemann-Liouville fractional integral of order α.

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

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

where Γ(α) is the gamma function.

Features: - Optimized FFT-based computation for large arrays - Direct method for small arrays with high accuracy - Memory-efficient algorithms - Support for both callable and array inputs - Error estimation and convergence analysis

Thresholds: method="auto" chooses FFT when len(t) >= fft_threshold (default 1000); otherwise the direct path is used. For α ≥ 1e-4, direct computation is delegated to hpfracc.core.integrals.RiemannLiouvilleIntegral.

Parameters:
__init__(alpha, method='auto', optimize_memory=True, use_jax=False)[source]

Initialize Riemann-Liouville integral calculator.

Parameters:

  • alpha (float | FractionalOrder) – Fractional order (must be > 0)

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

  • optimize_memory (bool) – Use memory optimization techniques

  • use_jax (bool) – Use JAX acceleration if available

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

Compute the Riemann-Liouville fractional integral.

Parameters:

  • f (Callable | ndarray) – Function to integrate (callable) or function values (array)

  • t (ndarray) – Time points where integral is evaluated

  • h (float | None) – Step size (if None, computed from t)

  • method (str | None) – Override the default method

Returns:

Array of integral values at each time point

Return type:

ndarray

_select_optimal_method(n_points)[source]

Select optimal computation method based on array size.

Parameters:

n_points (int)

Return type:

str

_compute_fft(f, t, h)[source]

RL fractional integral via linear convolution on the uniform grid.

Matches the legacy discrete sum in _compute_direct_discrete_legacy() (kernel weight ((i-j)h)^{\alpha-1} / \Gamma(\alpha), then \times h). Uses scipy.signal.fftconvolve so the operation is causal (first n samples of the full convolution), not periodic length-n FFT convolution (which was incorrect and disagreed strongly with quadrature).

Parameters:
Return type:

ndarray

_compute_direct_discrete_legacy(f, t, h)[source]

Original O(N²) uniform-grid RL sum (used only for tiny α where quad is ill-conditioned).

Parameters:
Return type:

ndarray

_compute_direct(f, t, h)[source]

RL integral on the sample grid via the canonical quad-based implementation in hpfracc.core.integrals (same definition as the rest of the library), except for extremely small α where the kernel is near-singular on a short grid.

Parameters:
Return type:

ndarray

_compute_adaptive(f, t, h)[source]

Compare FFT to the direct reference on short grids (len(t) < fft_threshold).

FFT and quad/discrete direct are not required to match to tight allclose tolerances; a scale-aware L2 relative residual is used. RuntimeWarning is used only for non-finite FFT output or severe disagreement; moderate mismatch emits UserWarning and still returns the direct result.

Parameters:
Return type:

ndarray

class hpfracc.algorithms.integral_methods.CaputoIntegral(alpha, method='auto', optimize_memory=True, use_jax=False)[source]

Bases: object

Caputo fractional integral of order α.

For α > 0, the Caputo fractional integral equals the Riemann-Liouville integral:

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

This class provides a consistent interface while reusing the RL implementation. method and fft_threshold behaviour match RiemannLiouvilleIntegral.

Parameters:
__init__(alpha, method='auto', optimize_memory=True, use_jax=False)[source]

Initialize Caputo integral calculator.

Parameters:

  • alpha (float | FractionalOrder) – Fractional order (must be > 0)

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

  • optimize_memory (bool) – Use memory optimization techniques

  • use_jax (bool) – Use JAX acceleration if available

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

Compute the Caputo fractional integral.

Parameters:

  • f (Callable | ndarray) – Function to integrate (callable) or function values (array)

  • t (ndarray) – Time points where integral is evaluated

  • h (float | None) – Step size (if None, computed from t)

  • method (str | None) – Override the default method

Returns:

Array of integral values at each time point

Return type:

ndarray

class hpfracc.algorithms.integral_methods.WeylIntegral(alpha, method='auto')[source]

Bases: object

Weyl fractional integral of order α (grid API).

For α ≥ 1e-4, delegates to the canonical quad-based hpfracc.core.integrals.WeylIntegral. For smaller α (near-identity kernel), keeps a legacy discrete RL-style sum on the sample grid for stability.

Parameters:
__init__(alpha, method='auto')[source]
Parameters:
_compute_weyl_discrete_legacy(f, t, h)[source]

Original windowed RL-style sum on t (used only for tiny α).

Parameters:
Return type:

ndarray

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

ndarray

hpfracc.algorithms.integral_methods.riemann_liouville_integral(f, t, alpha, h=None, method='auto')[source]

Compute Riemann-Liouville fractional integral.

Parameters:
Returns:

Integral values

Return type:

ndarray

hpfracc.algorithms.integral_methods.caputo_integral(f, t, alpha, h=None, method='auto')[source]

Compute Caputo fractional integral.

Parameters:
Returns:

Integral values

Return type:

ndarray

hpfracc.algorithms.integral_methods.optimized_riemann_liouville_integral(f, t, alpha, h=None)[source]

Optimized Riemann-Liouville integral with automatic method selection.

Parameters:
Returns:

Integral values

Return type:

ndarray

hpfracc.algorithms.integral_methods.optimized_caputo_integral(f, t, alpha, h=None)[source]

Optimized Caputo integral with automatic method selection.

Parameters:
Returns:

Integral values

Return type:

ndarray

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.

Naming: parallel-enhanced variants of Weyl / Marchaud / … are exposed as Parallel* classes. The legacy names OptimizedWeylDerivative, etc., remain as aliases of those classes (they are unrelated to OptimizedCaputo in hpfracc.algorithms.optimized_methods, which aliases the unified RL/Caputo/GL engines).

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^{\alpha} f(x) = \frac{1}{2\pi} \int_{-\infty}^{\infty} |\xi|^{\alpha} \, \mathcal{F}[f](\xi) \, e^{i\xi x} \, d\xi\)

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.ParallelWeylDerivative(order, **kwargs)[source]

Bases: WeylDerivative

Weyl derivative with optimized=True defaults (parallel / FFT path).

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize Weyl derivative calculator.

Parameters:

order (float | FractionalOrder)

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

Bases: MarchaudDerivative

Marchaud derivative exposed under the parallel-enhanced naming scheme.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize Marchaud derivative calculator.

Parameters:

order (float | FractionalOrder)

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

Bases: HadamardDerivative

Hadamard derivative under the parallel-enhanced naming scheme.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize Hadamard derivative calculator.

Accepts both alpha and order for backward compatibility.

Parameters:

order (float | FractionalOrder)

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

Bases: ReizFellerDerivative

Reiz–Feller derivative under the parallel-enhanced naming scheme.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize Reiz-Feller derivative calculator.

Parameters:

order (float | FractionalOrder)

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

Bases: AdomianDecomposition

Adomian decomposition under the parallel-enhanced naming scheme.

Parameters:

order (float | FractionalOrder)

__init__(order, **kwargs)[source]

Initialize Adomian Decomposition solver.

Parameters:

order (float | FractionalOrder)

hpfracc.algorithms.advanced_methods.OptimizedWeylDerivative

alias of ParallelWeylDerivative

hpfracc.algorithms.advanced_methods.OptimizedMarchaudDerivative

alias of ParallelMarchaudDerivative

hpfracc.algorithms.advanced_methods.OptimizedHadamardDerivative

alias of ParallelHadamardDerivative

hpfracc.algorithms.advanced_methods.OptimizedReizFellerDerivative

alias of ParallelReizFellerDerivative

hpfracc.algorithms.advanced_methods.OptimizedAdomianDecomposition

alias of ParallelAdomianDecomposition

hpfracc.algorithms.advanced_methods.parallel_weyl_derivative(f, x, alpha, h=None, **kwargs)[source]
Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.parallel_marchaud_derivative(f, x, alpha, h=None, **kwargs)[source]
Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.parallel_hadamard_derivative(f, x, alpha, h=None, **kwargs)[source]
Parameters:
Return type:

float | ndarray

hpfracc.algorithms.advanced_methods.parallel_reiz_feller_derivative(f, x, alpha, h=None, **kwargs)[source]
Parameters:
Return type:

float | ndarray

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

float | ndarray

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

float | ndarray

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

float | ndarray

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

float | ndarray

Special Methods

Fractional operator extensions (Laplacian, FrFT, Z/Mellin transforms).

This is the algorithms-layer complement to hpfracc.special (Γ, β, binomial, Mittag–Leffler). It implements operators used in PDEs and signal processing:

  • Fractional Laplacian

  • Fractional Fourier / Z / Mellin transforms

Canonical import: from hpfracc.algorithms.fractional_operator_methods import .... The legacy path hpfracc.algorithms.special_methods remains a thin re-export shim.

hpfracc.algorithms.fractional_operator_methods._numpy_trapezoid(y, x)[source]

Trapezoidal rule; prefers numpy.trapezoid (NumPy 2+) over deprecated trapz.

hpfracc.algorithms.fractional_operator_methods._factorial(n)

Simple factorial function for NUMBA compatibility.

Parameters:

n (int)

Return type:

int

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

Bases: object

Fractional Laplacian operator implementation.

The fractional Laplacian is defined as: \((-\Delta)^{\alpha/2} f(x) = \mathcal{F}^{-1}\left(|\xi|^{\alpha}\, \mathcal{F}[f](\xi)\right)\)

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.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_methods.fractional_laplacian(f, x, alpha, h=None, method='spectral')[source]

Convenience function for fractional Laplacian.

Parameters:
Return type:

float | ndarray

hpfracc.algorithms.fractional_operator_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.fractional_operator_methods.fractional_z_transform(f, z, alpha, method='direct')[source]

Convenience function for fractional Z-transform.

Parameters:
Return type:

complex | ndarray

hpfracc.algorithms.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_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.fractional_operator_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

Engine path (RL / Caputo / Grünwald–Letnikov):

  • Canonical numerical engines live in hpfracc.algorithms.derivatives.

  • Classes in this module (for example CaputoDerivative) are thin BaseFractionalDerivative adapters that delegate to those engines via _engine; there is no second implementation.

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 — adapter over the canonical engine hpfracc.algorithms.derivatives.RiemannLiouville.

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 — adapter over the canonical engine hpfracc.algorithms.derivatives.Caputo (single implementation path).

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

Grünwald–Letnikov fractional derivative — adapter over the canonical engine hpfracc.algorithms.derivatives.GrunwaldLetnikov.

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.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

Canonical integral path for the library: subclasses of FractionalIntegral here are what hpfracc re-exports and what core workflows should use. For an FFT-focused API with a different surface (method="fft", alpha= kwargs), see hpfracc.algorithms.integral_methods — that module is legacy/alternate, not a second copy of these quadrature-based classes. The hpfracc.core package loads this submodule lazily (see core/__init__.py); prefer import hpfracc.core.integrals when you only need integrals.

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

hpfracc.core.integrals._handle_integration_failure(method, x, error)[source]

Handle numerical integration failures without fabricating valid-looking values.

Returning NaN makes downstream quality checks catch failures instead of silently treating failures as valid zeros.

Parameters:
Return type:

float

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)

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

_coerce_function(f, x_arg)[source]

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

Parameters:
Return type:

Callable

_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”)

_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 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