tessl/pypi-cupy

NumPy & SciPy-compatible array library for GPU-accelerated computing with Python

—

Pending

Overview

Eval results

Files

SciPy Extensions

Name: tessl/pypi-cupy
Author: tessl

Extended scientific computing functions from cupyx.scipy for advanced mathematical operations beyond NumPy compatibility. These GPU-accelerated implementations provide SciPy-equivalent functionality for scientific computing workflows.

Capabilities

Signal Processing

Digital signal processing functions from cupyx.scipy.signal.

def convolve(in1, in2, mode='full', method='auto'):
    """
    Convolution of two arrays.
    
    Parameters:
    - in1, in2: array-like, input arrays
    - mode: {'full', 'valid', 'same'}, output size
    - method: {'auto', 'direct', 'fft'}, computation method
    
    Returns:
    cupy.ndarray: Convolution result
    """

def correlate(in1, in2, mode='full', method='auto'):
    """Cross-correlation of two arrays."""

def fftconvolve(in1, in2, mode='full', axes=None):
    """FFT-based convolution."""

def convolve2d(in1, in2, mode='full', boundary='fill', fillvalue=0):
    """2D convolution."""

def correlate2d(in1, in2, mode='full', boundary='fill', fillvalue=0):
    """2D cross-correlation."""

Image Processing

Image processing functions from cupyx.scipy.ndimage.

def gaussian_filter(input, sigma, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0):
    """
    Gaussian filter.
    
    Parameters:
    - input: array-like, input image
    - sigma: scalar or sequence, standard deviation
    - order: int or sequence, derivative order
    - output: array, output array
    - mode: str, boundary condition
    - cval: scalar, fill value for constant mode
    - truncate: scalar, filter truncation
    
    Returns:
    cupy.ndarray: Filtered image
    """

def sobel(input, axis=-1, output=None, mode='reflect', cval=0.0):
    """Sobel edge detection filter."""

def gaussian_filter1d(input, sigma, axis=-1, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0):
    """1D Gaussian filter."""

def uniform_filter(input, size=3, output=None, mode='reflect', cval=0.0, origin=0):
    """Uniform filter (box filter)."""

def median_filter(input, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0):
    """Median filter."""

Sparse Linear Algebra

Sparse matrix linear algebra from cupyx.scipy.sparse.linalg.

def spsolve(A, b, permc_spec=None, use_umfpack=True):
    """
    Solve sparse linear system Ax = b.
    
    Parameters:
    - A: sparse matrix, coefficient matrix
    - b: array-like, right-hand side
    - permc_spec: str, permutation strategy
    - use_umfpack: bool, use UMFPACK solver
    
    Returns:
    cupy.ndarray: Solution vector
    """

def norm(x, ord=None, axis=None):
    """Sparse matrix or vector norm."""

def inv(A):
    """Sparse matrix inverse."""

Optimization

Optimization functions from cupyx.scipy.optimize.

def minimize(fun, x0, args=(), method=None, jac=None, bounds=None, constraints=()):
    """
    Minimize scalar function.
    
    Parameters:
    - fun: callable, objective function
    - x0: array-like, initial guess
    - args: tuple, extra arguments to fun
    - method: str, optimization method
    - jac: callable, gradient function
    - bounds: sequence, variable bounds
    - constraints: dict or sequence, constraints
    
    Returns:
    OptimizeResult: Optimization result
    """

def minimize_scalar(fun, bounds=None, args=(), method='brent'):
    """Minimize scalar function of one variable."""

Special Functions

Mathematical special functions from cupyx.scipy.special.

def erf(x):
    """Error function."""

def erfc(x):
    """Complementary error function."""

def gamma(x):
    """Gamma function."""

def gammaln(x):
    """Log of gamma function."""

def beta(a, b):
    """Beta function."""

def j0(x):
    """Bessel function of first kind, order 0."""

def j1(x):
    """Bessel function of first kind, order 1."""

def y0(x):
    """Bessel function of second kind, order 0."""

Utilities

Additional scientific computing utilities.

def get_runtime_info(full=False):
    """
    Get CuPy runtime information.
    
    Parameters:
    - full: bool, include detailed information
    
    Returns:
    str: Runtime information string
    """

def scatter_add(a, indices, b, axis=None):
    """
    Scatter add operation.
    
    Parameters:
    - a: array-like, target array
    - indices: array-like, indices to scatter to
    - b: array-like, values to add
    - axis: int, axis to scatter along
    
    Returns:
    cupy.ndarray: Result of scatter add
    """

def scatter_max(a, indices, b, axis=None):
    """Scatter max operation."""

def scatter_min(a, indices, b, axis=None):
    """Scatter min operation."""

Usage Examples

Signal Processing

import cupy as cp
import cupyx.scipy.signal as signal

# Create test signals
t = cp.linspace(0, 1, 1000)
sig1 = cp.sin(2 * cp.pi * 5 * t)
sig2 = cp.exp(-t) * cp.sin(2 * cp.pi * 10 * t)

# Convolution
convolved = signal.convolve(sig1, sig2, mode='same')

# Cross-correlation
correlated = signal.correlate(sig1, sig2, mode='same')

Image Processing

import cupyx.scipy.ndimage as ndimage

# Create test image
image = cp.random.random((512, 512))

# Gaussian blur
blurred = ndimage.gaussian_filter(image, sigma=2.0)

# Edge detection
edges = ndimage.sobel(image)

# Median filtering for noise reduction
denoised = ndimage.median_filter(image, size=3)

Optimization

import cupyx.scipy.optimize as optimize

# Define objective function
def objective(x):
    return (x[0] - 1)**2 + (x[1] - 2)**2

# Minimize function
result = optimize.minimize(objective, x0=[0, 0], method='BFGS')
print(f"Minimum at: {result.x}")

Install with Tessl CLI