tessl/pypi-cupy-cuda112
NumPy & SciPy-compatible GPU-accelerated computing library for CUDA 11.2 environments
—
Pending
math-operations.mddocs/
Mathematical Operations
Comprehensive collection of mathematical functions providing GPU-accelerated computation for trigonometric, hyperbolic, exponential, logarithmic, arithmetic, and statistical operations with full NumPy compatibility.
Capabilities
Trigonometric Functions
GPU-accelerated trigonometric functions for angles in radians.
def sin(x, out=None, **kwargs):
"""
Trigonometric sine, element-wise.
Parameters:
- x: array-like, input angles in radians
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def cos(x, out=None, **kwargs):
"""
Trigonometric cosine, element-wise.
Parameters:
- x: array-like, input angles in radians
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def tan(x, out=None, **kwargs):
"""
Trigonometric tangent, element-wise.
Parameters:
- x: array-like, input angles in radians
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def arcsin(x, out=None, **kwargs):
"""
Inverse sine, element-wise.
Parameters:
- x: array-like, input values in [-1, 1]
- out: ndarray, optional output array
Returns:
cupy.ndarray, angles in radians in [-pi/2, pi/2]
"""
def arccos(x, out=None, **kwargs):
"""
Inverse cosine, element-wise.
Parameters:
- x: array-like, input values in [-1, 1]
- out: ndarray, optional output array
Returns:
cupy.ndarray, angles in radians in [0, pi]
"""
def arctan(x, out=None, **kwargs):
"""
Inverse tangent, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, angles in radians in [-pi/2, pi/2]
"""
def arctan2(y, x, out=None, **kwargs):
"""
Element-wise arc tangent of y/x choosing quadrant correctly.
Parameters:
- y: array-like, y-coordinates
- x: array-like, x-coordinates
- out: ndarray, optional output array
Returns:
cupy.ndarray, angles in radians in [-pi, pi]
"""
def degrees(x, out=None, **kwargs):
"""
Convert angles from radians to degrees.
Parameters:
- x: array-like, angles in radians
- out: ndarray, optional output array
Returns:
cupy.ndarray, angles in degrees
"""
def radians(x, out=None, **kwargs):
"""
Convert angles from degrees to radians.
Parameters:
- x: array-like, angles in degrees
- out: ndarray, optional output array
Returns:
cupy.ndarray, angles in radians
"""
def hypot(x1, x2, out=None, **kwargs):
"""
Given two sides of right triangle, return hypotenuse.
Parameters:
- x1, x2: array-like, sides of triangle
- out: ndarray, optional output array
Returns:
cupy.ndarray, hypotenuse sqrt(x1**2 + x2**2)
"""Hyperbolic Functions
Hyperbolic functions for mathematical computations.
def sinh(x, out=None, **kwargs):
"""
Hyperbolic sine, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def cosh(x, out=None, **kwargs):
"""
Hyperbolic cosine, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def tanh(x, out=None, **kwargs):
"""
Hyperbolic tangent, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def arcsinh(x, out=None, **kwargs):
"""
Inverse hyperbolic sine, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def arccosh(x, out=None, **kwargs):
"""
Inverse hyperbolic cosine, element-wise.
Parameters:
- x: array-like, values >= 1
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def arctanh(x, out=None, **kwargs):
"""
Inverse hyperbolic tangent, element-wise.
Parameters:
- x: array-like, values in (-1, 1)
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""Exponential and Logarithmic Functions
Functions for exponential and logarithmic operations.
def exp(x, out=None, **kwargs):
"""
Calculate exponential of all elements.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, e**x
"""
def exp2(x, out=None, **kwargs):
"""
Calculate 2**x for all elements.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, 2**x
"""
def expm1(x, out=None, **kwargs):
"""
Calculate exp(x) - 1 for all elements.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, exp(x) - 1
"""
def log(x, out=None, **kwargs):
"""
Natural logarithm, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, ln(x)
"""
def log10(x, out=None, **kwargs):
"""
Base-10 logarithm, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, log10(x)
"""
def log2(x, out=None, **kwargs):
"""
Base-2 logarithm, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, log2(x)
"""
def log1p(x, out=None, **kwargs):
"""
Calculate log(1 + x) for all elements.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, log(1 + x)
"""
def logaddexp(x1, x2, out=None, **kwargs):
"""
Logarithm of sum of exponentials of inputs.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, log(exp(x1) + exp(x2))
"""Arithmetic Operations
Basic arithmetic operations for element-wise computation.
def add(x1, x2, out=None, **kwargs):
"""
Add arguments element-wise.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, x1 + x2
"""
def subtract(x1, x2, out=None, **kwargs):
"""
Subtract arguments element-wise.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, x1 - x2
"""
def multiply(x1, x2, out=None, **kwargs):
"""
Multiply arguments element-wise.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, x1 * x2
"""
def divide(x1, x2, out=None, **kwargs):
"""
Divide arguments element-wise.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, x1 / x2
"""
def true_divide(x1, x2, out=None, **kwargs):
"""
True division element-wise.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, x1 / x2 with true division
"""
def floor_divide(x1, x2, out=None, **kwargs):
"""
Floor division element-wise.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, floor(x1 / x2)
"""
def power(x1, x2, out=None, **kwargs):
"""
First array elements raised to powers from second array.
Parameters:
- x1: array-like, base
- x2: array-like, exponent
- out: ndarray, optional output array
Returns:
cupy.ndarray, x1**x2
"""
def sqrt(x, out=None, **kwargs):
"""
Return non-negative square root element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, sqrt(x)
"""
def square(x, out=None, **kwargs):
"""
Return element-wise square of input.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, x**2
"""
def absolute(x, out=None, **kwargs):
"""
Calculate absolute value element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, |x|
"""
def sign(x, out=None, **kwargs):
"""
Returns element-wise indication of sign of number.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, -1, 0, or 1 indicating sign
"""Rounding Functions
Functions for rounding and truncating values.
def around(a, decimals=0, out=None):
"""
Round array to given number of decimals.
Parameters:
- a: array-like
- decimals: int, number of decimal places
- out: ndarray, optional output array
Returns:
cupy.ndarray
"""
def ceil(x, out=None, **kwargs):
"""
Return ceiling of input, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, ceiling values
"""
def floor(x, out=None, **kwargs):
"""
Return floor of input, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, floor values
"""
def trunc(x, out=None, **kwargs):
"""
Return truncated value of input, element-wise.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, truncated values
"""
def rint(x, out=None, **kwargs):
"""
Round elements to nearest integers.
Parameters:
- x: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, rounded integers
"""Reduction Operations
Operations that reduce arrays along specified axes.
def sum(a, axis=None, dtype=None, out=None, keepdims=False):
"""
Sum of array elements over given axis.
Parameters:
- a: array-like
- axis: int or tuple of ints, axis to sum along
- dtype: data type of output
- out: ndarray, optional output array
- keepdims: bool, keep reduced dimensions
Returns:
cupy.ndarray, sum along axis
"""
def prod(a, axis=None, dtype=None, out=None, keepdims=False):
"""
Product of array elements over given axis.
Parameters:
- a: array-like
- axis: int or tuple of ints, axis to multiply along
- dtype: data type of output
- out: ndarray, optional output array
- keepdims: bool, keep reduced dimensions
Returns:
cupy.ndarray, product along axis
"""
def mean(a, axis=None, dtype=None, out=None, keepdims=False):
"""
Arithmetic mean along specified axis.
Parameters:
- a: array-like
- axis: int or tuple of ints, axis to average along
- dtype: data type of output
- out: ndarray, optional output array
- keepdims: bool, keep reduced dimensions
Returns:
cupy.ndarray, mean along axis
"""
def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
"""
Variance along specified axis.
Parameters:
- a: array-like
- axis: int or tuple of ints, axis to compute variance along
- dtype: data type of output
- out: ndarray, optional output array
- ddof: int, delta degrees of freedom
- keepdims: bool, keep reduced dimensions
Returns:
cupy.ndarray, variance along axis
"""
def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
"""
Standard deviation along specified axis.
Parameters:
- a: array-like
- axis: int or tuple of ints, axis to compute std along
- dtype: data type of output
- out: ndarray, optional output array
- ddof: int, delta degrees of freedom
- keepdims: bool, keep reduced dimensions
Returns:
cupy.ndarray, standard deviation along axis
"""
def cumsum(a, axis=None, dtype=None, out=None):
"""
Cumulative sum along given axis.
Parameters:
- a: array-like
- axis: int, axis to compute cumsum along
- dtype: data type of output
- out: ndarray, optional output array
Returns:
cupy.ndarray, cumulative sum
"""
def cumprod(a, axis=None, dtype=None, out=None):
"""
Cumulative product along given axis.
Parameters:
- a: array-like
- axis: int, axis to compute cumulative product along
- dtype: data type of output
- out: ndarray, optional output array
Returns:
cupy.ndarray, cumulative product
"""Extrema Finding
Functions for finding minimum and maximum values.
def amax(a, axis=None, out=None, keepdims=False, initial=None, where=None):
"""
Maximum of array elements along given axis.
Parameters:
- a: array-like
- axis: int or tuple of ints, axis to find max along
- out: ndarray, optional output array
- keepdims: bool, keep reduced dimensions
- initial: scalar, initial value for comparison
- where: array of bool, elements to include
Returns:
cupy.ndarray, maximum values
"""
def amin(a, axis=None, out=None, keepdims=False, initial=None, where=None):
"""
Minimum of array elements along given axis.
Parameters:
- a: array-like
- axis: int or tuple of ints, axis to find min along
- out: ndarray, optional output array
- keepdims: bool, keep reduced dimensions
- initial: scalar, initial value for comparison
- where: array of bool, elements to include
Returns:
cupy.ndarray, minimum values
"""
def maximum(x1, x2, out=None, **kwargs):
"""
Element-wise maximum of array elements.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, element-wise maximum
"""
def minimum(x1, x2, out=None, **kwargs):
"""
Element-wise minimum of array elements.
Parameters:
- x1, x2: array-like
- out: ndarray, optional output array
Returns:
cupy.ndarray, element-wise minimum
"""
def clip(a, a_min, a_max, out=None, **kwargs):
"""
Clip values in array to given range.
Parameters:
- a: array-like
- a_min: scalar or array, minimum value
- a_max: scalar or array, maximum value
- out: ndarray, optional output array
Returns:
cupy.ndarray, clipped values
"""Usage Examples
Basic Mathematical Operations
import cupy as cp
# Create test data
x = cp.linspace(0, 2 * cp.pi, 100)
y = cp.array([1, 2, 3, 4, 5])
# Trigonometric functions
sin_values = cp.sin(x)
cos_values = cp.cos(x)
tan_values = cp.tan(x)
# Exponential and logarithmic
exp_values = cp.exp(y)
log_values = cp.log(y)
# Element-wise arithmetic
z = cp.add(y, 10)
product = cp.multiply(y, y)
power_values = cp.power(y, 2)Statistical Operations
import cupy as cp
# Create sample data
data = cp.random.random((1000, 100))
# Statistical measures
mean_val = cp.mean(data, axis=0)
std_val = cp.std(data, axis=0)
var_val = cp.var(data, axis=1)
# Extrema
max_vals = cp.amax(data, axis=1)
min_vals = cp.amin(data, axis=1)
# Cumulative operations
cumulative_sum = cp.cumsum(data, axis=0)
running_product = cp.cumprod(data[:10, 0])Advanced Mathematical Operations
import cupy as cp
# Complex mathematical operations
angles = cp.linspace(0, 2*cp.pi, 1000)
complex_signal = cp.exp(1j * angles)
# Real and imaginary parts
real_part = cp.real(complex_signal)
imag_part = cp.imag(complex_signal)
magnitude = cp.absolute(complex_signal)
# Hyperbolic functions
x = cp.linspace(-2, 2, 100)
sinh_vals = cp.sinh(x)
tanh_vals = cp.tanh(x)
# Special operations
clipped = cp.clip(x, -1, 1)
rounded = cp.around(x, decimals=2)Install with Tessl CLI
npx tessl i tessl/pypi-cupy-cuda112