tessl/pypi-pycuda

Python wrapper for Nvidia CUDA parallel computation API with object cleanup, automatic error checking, and convenient abstractions.

0.93x

Overview

Eval results

Files

Math Functions

Name: tessl/pypi-pycuda
Rating: 0.62 (1 reviews)
Author: tessl

CUDA math function wrappers providing GPU-accelerated mathematical operations for arrays including trigonometric, exponential, and logarithmic functions. These functions operate element-wise on GPU arrays with automatic type handling.

Capabilities

Trigonometric Functions

Element-wise trigonometric functions for GPU arrays.

def sin(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise sine function.
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: sine of input elements
    """

def cos(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise cosine function."""

def tan(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise tangent function."""

def asin(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise arcsine function."""

def acos(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise arccosine function."""

def atan(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise arctangent function."""

def atan2(y: GPUArray, x: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise arctangent of y/x with correct quadrant.
    
    Parameters:
    - y: GPUArray, y coordinates
    - x: GPUArray, x coordinates
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: arctangent of y/x in correct quadrant
    """

Hyperbolic Functions

Element-wise hyperbolic functions for GPU arrays.

def sinh(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise hyperbolic sine function.
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: hyperbolic sine of input elements
    """

def cosh(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise hyperbolic cosine function."""

def tanh(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise hyperbolic tangent function."""

def asinh(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise inverse hyperbolic sine function."""

def acosh(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise inverse hyperbolic cosine function."""

def atanh(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise inverse hyperbolic tangent function."""

Exponential and Logarithmic Functions

Element-wise exponential and logarithmic functions.

def exp(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise exponential function (e^x).
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: exponential of input elements
    """

def exp2(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise base-2 exponential function (2^x)."""

def exp10(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise base-10 exponential function (10^x)."""

def expm1(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise exp(x) - 1 function (accurate for small x)."""

def log(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise natural logarithm function.
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: natural logarithm of input elements
    """

def log2(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise base-2 logarithm function."""

def log10(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise base-10 logarithm function."""

def log1p(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise log(1 + x) function (accurate for small x)."""

Power and Root Functions

Element-wise power and root functions.

def pow(base: GPUArray, exponent: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise power function (base^exponent).
    
    Parameters:
    - base: GPUArray, base values
    - exponent: GPUArray, exponent values
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: base raised to exponent power
    """

def sqrt(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise square root function.
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: square root of input elements
    """

def rsqrt(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise reciprocal square root function (1/sqrt(x))."""

def cbrt(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise cube root function."""

def rcbrt(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise reciprocal cube root function (1/cbrt(x))."""

Rounding and Absolute Value Functions

Element-wise rounding and absolute value functions.

def fabs(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise absolute value function.
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: absolute value of input elements
    """

def ceil(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise ceiling function (round up to nearest integer)."""

def floor(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise floor function (round down to nearest integer)."""

def trunc(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise truncation function (round toward zero)."""

def round(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise round function (round to nearest integer)."""

def rint(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise round to nearest integer function."""

Special Functions

Element-wise special mathematical functions.

def erf(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise error function.
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: error function of input elements
    """

def erfc(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise complementary error function."""

def gamma(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise gamma function."""

def lgamma(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise log gamma function."""

def j0(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise Bessel function of the first kind of order 0."""

def j1(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise Bessel function of the first kind of order 1."""

def y0(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise Bessel function of the second kind of order 0."""

def y1(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise Bessel function of the second kind of order 1."""

Floating-Point Manipulation

Functions for manipulating floating-point representations.

def fmod(x: GPUArray, y: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise floating-point remainder of x/y.
    
    Parameters:
    - x: GPUArray, dividend
    - y: GPUArray, divisor
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: floating-point remainder
    """

def modf(array: GPUArray, int_part: GPUArray = None, stream: Stream = None) -> tuple[GPUArray, GPUArray]:
    """
    Element-wise split into fractional and integer parts.
    
    Parameters:
    - array: GPUArray, input array
    - int_part: GPUArray, output for integer parts (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    tuple: (fractional_part, integer_part) as GPUArrays
    """

def frexp(array: GPUArray, exp_array: GPUArray = None, stream: Stream = None) -> tuple[GPUArray, GPUArray]:
    """
    Element-wise extract mantissa and exponent.
    
    Parameters:
    - array: GPUArray, input array
    - exp_array: GPUArray, output for exponents (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    tuple: (mantissa, exponent) as GPUArrays
    """

def ldexp(mantissa: GPUArray, exponent: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise load exponent (mantissa * 2^exponent).
    
    Parameters:
    - mantissa: GPUArray, mantissa values
    - exponent: GPUArray, exponent values
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: mantissa * 2^exponent
    """

Comparison Functions

Element-wise comparison and selection functions.

def fmax(x: GPUArray, y: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise maximum (handles NaN correctly).
    
    Parameters:
    - x: GPUArray, first array
    - y: GPUArray, second array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: element-wise maximum
    """

def fmin(x: GPUArray, y: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Element-wise minimum (handles NaN correctly)."""

def copysign(magnitude: GPUArray, sign: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise copy sign from one array to magnitude of another.
    
    Parameters:
    - magnitude: GPUArray, magnitude values
    - sign: GPUArray, sign values
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: magnitude with sign from sign array
    """

def signbit(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Element-wise test for sign bit.
    
    Parameters:
    - array: GPUArray, input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: non-zero where sign bit is set
    """

Complex Number Functions

Functions for complex number operations on GPU arrays.

def real(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Extract real part of complex array.
    
    Parameters:
    - array: GPUArray, complex input array
    - out: GPUArray, output array (optional)
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: real part of input elements
    """

def imag(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Extract imaginary part of complex array."""

def conj(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Complex conjugate of array elements."""

def abs(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """
    Absolute value (magnitude) of array elements.
    
    Parameters:
    - array: GPUArray, input array (real or complex)
    - out: GPUArray, output array (optional)  
    - stream: Stream, CUDA stream (optional)
    
    Returns:
    GPUArray: absolute value of input elements
    """

def arg(array: GPUArray, out: GPUArray = None, stream: Stream = None) -> GPUArray:
    """Phase angle of complex array elements."""

Usage Examples

Basic Math Operations

import pycuda.gpuarray as gpuarray
import pycuda.cumath as cumath
import numpy as np

# Create test array
x = gpuarray.to_gpu(np.linspace(0, np.pi, 100).astype(np.float32))

# Trigonometric functions
sin_x = cumath.sin(x)
cos_x = cumath.cos(x)
tan_x = cumath.tan(x)

# Exponential and logarithmic
exp_x = cumath.exp(x)
log_x = cumath.log(x + 1)  # Add 1 to avoid log(0)

# Power functions
sqrt_x = cumath.sqrt(x)
pow_x = cumath.pow(x, 2.0)

Complex Number Operations

# Complex array operations
complex_array = gpuarray.to_gpu(np.array([1+2j, 3+4j, 5+6j], dtype=np.complex64))

# Extract components
real_part = cumath.real(complex_array)
imag_part = cumath.imag(complex_array)

# Complex operations
magnitude = cumath.abs(complex_array)
phase = cumath.arg(complex_array)
conjugate = cumath.conj(complex_array)

In-Place Operations

# In-place operations (when out parameter equals input)
x = gpuarray.to_gpu(np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32))

# Square root in-place
cumath.sqrt(x, out=x)  # x is now [1.0, 1.414, 1.732, 2.0]

# Exponential in-place  
cumath.exp(x, out=x)   # x is now exp of previous values

Install with Tessl CLI

npx tessl i tessl/pypi-pycuda