NVIDIA CuPy Numeric

https://docs.nvidia.com/cupynumeric/
Admin
CuPy Numeric implements the NumPy API on top of the Legate framework, providing transparent...
Tokens:11,371
Snippets:42
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Input and Output

Source: https://docs.nvidia.com/cupynumeric

Routines for handling input and output operations, such as loading arrays.

```APIDOC
## Input and Output

Functions for input and output operations.

### Routines
- `cupynumeric.load`
```

--------------------------------

### Array Creation Routines

Source: https://docs.nvidia.com/cupynumeric/26.06/index.html

Functions for creating new arrays, including initializing with specific values, copying, repeating, and generating sequences.

```APIDOC
## Array Creation Routines

Functions for creating new arrays.

### Functions
- `cupynumeric.empty`
- `cupynumeric.empty_like`
- `cupynumeric.eye`
- `cupynumeric.identity`
- `cupynumeric.ones`
- `cupynumeric.ones_like`
- `cupynumeric.zeros`
- `cupynumeric.zeros_like`
- `cupynumeric.full`
- `cupynumeric.full_like`
- `cupynumeric.array`
- `cupynumeric.asarray`
- `cupynumeric.copy`
- `cupynumeric.copyto`
- `cupynumeric.repeat`
- `cupynumeric.arange`
- `cupynumeric.logspace`
- `cupynumeric.linspace`
- `cupynumeric.meshgrid`
- `cupynumeric.diag`
- `cupynumeric.diagflat`
- `cupynumeric.tri`
- `cupynumeric.tril`
- `cupynumeric.triu`
```

--------------------------------

### Array Creation Routines

Source: https://docs.nvidia.com/cupynumeric

Routines for creating new arrays, including functions for initializing arrays with specific values or shapes.

```APIDOC
## Array Creation Routines

Functions to create new arrays.

### Routines
- `cupynumeric.empty`
- `cupynumeric.empty_like`
- `cupynumeric.eye`
- `cupynumeric.identity`
- `cupynumeric.ones`
- `cupynumeric.ones_like`
- `cupynumeric.zeros`
- `cupynumeric.zeros_like`
- `cupynumeric.full`
- `cupynumeric.full_like`
- `cupynumeric.array`
- `cupynumeric.asarray`
- `cupynumeric.copy`
- `cupynumeric.copyto`
- `cupynumeric.repeat`
- `cupynumeric.arange`
- `cupynumeric.logspace`
- `cupynumeric.linspace`
- `cupynumeric.meshgrid`
- `cupynumeric.diag`
- `cupynumeric.diagflat`
- `cupynumeric.tri`
- `cupynumeric.tril`
- `cupynumeric.triu`
```

--------------------------------

### cupynumeric.__array_namespace_info__

Source: https://docs.nvidia.com/cupynumeric

Provides information about the array namespace supported by cuPyNumeric.

```APIDOC
## cupynumeric.__array_namespace_info__

### Description
Returns information about the array namespace.

### Method
`cupynumeric.__array_namespace_info__()`

### Returns
A dictionary containing namespace information.
```

--------------------------------

### Random Sampling

Source: https://docs.nvidia.com/cupynumeric

Tools for generating random numbers and samples from various distributions.

```APIDOC
## Random sampling (`cupynumeric.random`)

### Description
Provides functionalities for generating random numbers and sampling from different probability distributions.

### Core Generator
- `cupynumeric.random.default_rng(seed=None)`: Creates a default Generator instance.
- `cupynumeric.random.Generator`: The main class for random number generation.
- `cupynumeric.random.BitGenerator`: Base class for bit generators.
- `cupynumeric.random.seed(seed=None)`: Seed the global random number generator.

### Basic Random Functions
- `cupynumeric.random.rand(d0, d1, ..., dn)`: Uniform random values in [0, 1).
- `cupynumeric.random.randn(d0, d1, ..., dn)`: Standard normal random values.
- `cupynumeric.random.randint(low, high=None, size=None, dtype=int)
`: Random integers from a discrete uniform distribution.
- `cupynumeric.random.random(size=None)`: Uniform random values in [0, 1).
- `cupynumeric.random.random_integers(low, high=None, size=None)`: Deprecated. Use `randint`.
- `cupynumeric.random.random_sample(size=None)`: Uniform random values in [0, 1).
- `cupynumeric.random.bytes(length)`: Random bytes.

### Distributional Sampling
- `cupynumeric.random.beta(a, b, size=None)`
- `cupynumeric.random.binomial(n, p, size=None)`
- `cupynumeric.random.chisquare(df, size=None)`
- `cupynumeric.random.exponential(scale=1.0, size=None)`
- `cupynumeric.random.f(dfnum, dfden, size=None)`
- `cupynumeric.random.gamma(shape, scale=1.0, size=None)`
- `cupynumeric.random.geometric(p, size=None)`
```

--------------------------------

### Discrete Fourier Transform (FFT)

Source: https://docs.nvidia.com/cupynumeric

Provides functions for computing Discrete Fourier Transforms.

```APIDOC
## Discrete Fourier Transform (`cupynumeric.fft`)

### Description
Functions for computing various forms of the Discrete Fourier Transform.

### Functions
- `cupynumeric.fft.fft(a, n=None, axis=-1, norm=None)`
- `cupynumeric.fft.ifft(a, n=None, axis=-1, norm=None)`
- `cupynumeric.fft.fft2(a, s=None, axes=(-2, -1), norm=None)`
- `cupynumeric.fft.ifft2(a, s=None, axes=(-2, -1), norm=None)`
- `cupynumeric.fft.fftn(a, s=None, axes=None, norm=None)`
- `cupynumeric.fft.ifftn(a, s=None, axes=None, norm=None)`
- `cupynumeric.fft.rfft(a, n=None, axis=-1, norm=None)`
- `cupynumeric.fft.irfft(a, n=None, axis=-1, norm=None)`
- `cupynumeric.fft.rfft2(a, s=None, axes=(-2, -1), norm=None)`
- `cupynumeric.fft.irfft2(a, s=None, axes=(-2, -1), norm=None)`
- `cupynumeric.fft.rfftn(a, s=None, axes=None, norm=None)`
- `cupynumeric.fft.irfftn(a, s=None, axes=None, norm=None)`
- `cupynumeric.fft.hfft(a, n=None, axis=-1, norm=None)`
- `cupynumeric.fft.ihfft(a, n=None, axis=-1, norm=None)`
- `cupynumeric.fft.fftshift(x, axes=None)`
- `cupynumeric.fft.ifftshift(x, axes=None)`
```

--------------------------------

### CuPy ndarray Methods

Source: https://docs.nvidia.com/cupynumeric/26.06/index.html

This section lists the available methods for CuPy ndarray objects, including special methods for operations, copying, indexing, and representation.

```APIDOC
## CuPy ndarray Methods

This section lists the available methods for CuPy ndarray objects.

### Methods
- `__ixor__`
- `__matmul__`
- `__imatmul__`
- `__rmatmul__`
- `__copy__`
- `__deepcopy__`
- `__index__`
- `__reduce__`
- `__setstate__`
- `__new__`
- `__array__`
- `__array_namespace__`
- `__len__`
- `__getitem__`
- `__setitem__`
- `__contains__`
- `__int__`
- `__float__`
- `__complex__`
- `__str__`
- `__repr__`
- `stencil_hint`
```

--------------------------------

### Window Functions

Source: https://docs.nvidia.com/cupynumeric

Functions for generating various types of window functions used in signal processing.

```APIDOC
## Window Functions

This section lists the available window functions.

### Functions
* `cupynumeric.bartlett`
* `cupynumeric.blackman`
* `cupynumeric.hamming`
* `cupynumeric.hanning`
* `cupynumeric.kaiser`
```

--------------------------------

### Indexing Routines

Source: https://docs.nvidia.com/cupynumeric

Routines for indexing and selecting elements within arrays, including advanced indexing techniques.

```APIDOC
## Indexing Routines

Functions for indexing and selecting array elements.

### Routines
- `cupynumeric.unravel_index`
- `cupynumeric.diag_indices`
- `cupynumeric.diag_indices_from`
- `cupynumeric.mask_indices`
- `cupynumeric.tril_indices`
- `cupynumeric.tril_indices_from`
- `cupynumeric.triu_indices`
- `cupynumeric.triu_indices_from`
- `cupynumeric.indices`
- `cupynumeric.ix_`
- `cupynumeric.nonzero`
- `cupynumeric.flatnonzero`
- `cupynumeric.where`
- `cupynumeric.ravel_multi_index`
- `cupynumeric.choose`
- `cupynumeric.compress`
- `cupynumeric.diag`
- `cupynumeric.diagonal`
- `cupynumeric.select`
- `cupynumeric.take`
- `cupynumeric.take_along_axis`
- `cupynumeric.fill_diagonal`
- `cupynumeric.put`
- `cupynumeric.putmask`
- `cupynumeric.put_along_axis`
- `cupynumeric.place`
```

--------------------------------

### Binary Operations

Source: https://docs.nvidia.com/cupynumeric

Routines for performing binary operations on arrays, including bitwise operations.

```APIDOC
## Binary Operations

Functions for binary operations on arrays.

### Routines
- `cupynumeric.bitwise_and`
- `cupynumeric.bitwise_or`
- `cupynumeric.bitwise_xor`
- `cupynumeric.invert`
- `cupynumeric.left_shift`
- `cupynumeric.right_shift`
- `cupynumeric.packbits`
- `cupynumeric.unpackbits`
```

--------------------------------

### Sorting, Searching, and Counting

Source: https://docs.nvidia.com/cupynumeric

Provides functions for sorting arrays, finding indices of elements, and counting occurrences.

```APIDOC
## Sorting, Searching, and Counting

This section details functions for ordering elements, locating specific values, and tallying elements within arrays.

### Functions
* `cupynumeric.argpartition`
* `cupynumeric.argsort`
* `cupynumeric.partition`
* `cupynumeric.sort`
* `cupynumeric.sort_complex`
* `cupynumeric.argmax`
* `cupynumeric.argmin`
* `cupynumeric.argwhere`
* `cupynumeric.flatnonzero`
* `cupynumeric.nanargmax`
* `cupynumeric.nanargmin`
* `cupynumeric.nonzero`
* `cupynumeric.searchsorted`
* `cupynumeric.extract`
* `cupynumeric.where`
* `cupynumeric.count_nonzero`
```

--------------------------------

### Array Manipulation Routines

Source: https://docs.nvidia.com/cupynumeric

Routines for manipulating existing arrays, including reshaping, splitting, joining, and flipping arrays.

```APIDOC
## Array Manipulation Routines

Functions to manipulate existing arrays.

### Routines
- `cupynumeric.ndim`
- `cupynumeric.shape`
- `cupynumeric.reshape`
- `cupynumeric.ravel`
- `cupynumeric.moveaxis`
- `cupynumeric.swapaxes`
- `cupynumeric.transpose`
- `cupynumeric.permute_dims`
- `cupynumeric.atleast_1d`
- `cupynumeric.atleast_2d`
- `cupynumeric.atleast_3d`
- `cupynumeric.broadcast_arrays`
- `cupynumeric.broadcast_shapes`
- `cupynumeric.broadcast_to`
- `cupynumeric.expand_dims`
- `cupynumeric.squeeze`
- `cupynumeric.asarray`
- `cupynumeric.append`
- `cupynumeric.concat`
- `cupynumeric.concatenate`
- `cupynumeric.insert`
- `cupynumeric.stack`
- `cupynumeric.block`
- `cupynumeric.vstack`
- `cupynumeric.hstack`
- `cupynumeric.dstack`
- `cupynumeric.column_stack`
- `cupynumeric.row_stack`
- `cupynumeric.split`
- `cupynumeric.array_split`
- `cupynumeric.dsplit`
- `cupynumeric.hsplit`
- `cupynumeric.vsplit`
- `cupynumeric.tile`
- `cupynumeric.flip`
- `cupynumeric.fliplr`
- `cupynumeric.flipud`
- `cupynumeric.roll`
- `cupynumeric.rot90`
- `cupynumeric.delete`
```

--------------------------------

### Array Checking and Manipulation

Source: https://docs.nvidia.com/cupynumeric/26.06/index.html

Functions for checking array properties and performing basic manipulations.

```APIDOC
## Array Checking Functions

### Description
Provides functions to check properties of CuPy arrays.

### Functions
- `cupynumeric.all(a, axis=None, out=None, keepdims=False)`: Test whether all elements of the array along a given axis evaluate to True.
- `cupynumeric.any(a, axis=None, out=None, keepdims=False)`: Test whether any element of the array along a given axis evaluates to True.
- `cupynumeric.isfinite(x)`: Test element-wise for finiteness (not infinity and not NaN).
- `cupynumeric.isinf(x)`: Test element-wise for positive or negative infinity.
- `cupynumeric.isnan(x)`: Test element-wise for NaN (Not a Number).
- `cupynumeric.isneginf(x)`: Test element-wise for negative infinity.
- `cupynumeric.isposinf(x)`: Test element-wise for positive infinity.
- `cupynumeric.iscomplex(x)`: True if the input's element type is complex.
- `cupynumeric.iscomplexobj(x)`: Check whether the object is a complex number or an array of complex numbers.
- `cupynumeric.isreal(x)`: True if the input's element type is real.
- `cupynumeric.isrealobj(x)`: Check whether the object is a real number or an array of real numbers.
- `cupynumeric.isscalar(x)`: True if `x` is a scalar.

## Logical Operations

### Description
Functions for performing element-wise logical operations.

### Functions
- `cupynumeric.logical_and(x1, x2, ...)`: Compute the element-wise logical AND of the input arrays.
- `cupynumeric.logical_or(x1, x2, ...)`: Compute the element-wise logical OR of the input arrays.
- `cupynumeric.logical_not(x, ...)`: Compute the element-wise logical NOT of the input array.
- `cupynumeric.logical_xor(x1, x2, ...)`: Compute the element-wise logical XOR of the input arrays.

## Comparison Functions

### Description
Functions for element-wise comparison of arrays.

### Functions
- `cupynumeric.allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)`: Returns True if two arrays are element-wise equal within a given tolerance.
- `cupynumeric.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)`: Returns True if two arrays are element-wise equal within a given tolerance.
- `cupynumeric.array_equal(a1, a2)`: True if two arrays have the same shape and elements.
- `cupynumeric.greater(x1, x2, ...)`: Return element-wise `greater` of two arrays.
- `cupynumeric.greater_equal(x1, x2, ...)`: Return element-wise `greater_equal` of two arrays.
- `cupynumeric.less(x1, x2, ...)`: Return element-wise `less` of two arrays.
- `cupynumeric.less_equal(x1, x2, ...)`: Return element-wise `less_equal` of two arrays.
- `cupynumeric.equal(x1, x2, ...)`: Return element-wise `equal` of two arrays.
- `cupynumeric.not_equal(x1, x2, ...)`: Return element-wise `not_equal` of two arrays.
```

--------------------------------

### ndarray Methods

Source: https://docs.nvidia.com/cupynumeric

This section lists the available methods for the cupynumeric.ndarray object, including special methods for operations, copying, and representation.

```APIDOC
## cupynumeric.ndarray Methods

This section lists the available methods for the cupynumeric.ndarray object.

### Methods
- `__ixor__`
- `__matmul__`
- `__imatmul__`
- `__rmatmul__`
- `__copy__`
- `__deepcopy__`
- `__index__`
- `__reduce__`
- `__setstate__`
- `__new__`
- `__array__`
- `__array_namespace__`
- `__len__`
- `__getitem__`
- `__setitem__`
- `__contains__`
- `__int__`
- `__float__`
- `__complex__`
- `__str__`
- `__repr__`
- `stencil_hint`
```

--------------------------------

### Random Number Generation

Source: https://docs.nvidia.com/cupynumeric

Provides a comprehensive set of functions for generating random numbers from various probability distributions.

```APIDOC
## Random Number Generation

This section lists the available functions for generating random numbers from different distributions.

### Functions
* `cupynumeric.random.gumbel`
* `cupynumeric.random.hypergeometric`
* `cupynumeric.random.laplace`
* `cupynumeric.random.logistic`
* `cupynumeric.random.lognormal`
* `cupynumeric.random.logseries`
* `cupynumeric.random.negative_binomial`
* `cupynumeric.random.noncentral_chisquare`
* `cupynumeric.random.noncentral_f`
* `cupynumeric.random.normal`
* `cupynumeric.random.pareto`
* `cupynumeric.random.poisson`
* `cupynumeric.random.power`
* `cupynumeric.random.ranf`
* `cupynumeric.random.rayleigh`
* `cupynumeric.random.sample`
* `cupynumeric.random.standard_cauchy`
* `cupynumeric.random.standard_exponential`
* `cupynumeric.random.standard_gamma`
* `cupynumeric.random.standard_t`
* `cupynumeric.random.triangular`
* `cupynumeric.random.uniform`
* `cupynumeric.random.vonmises`
* `cupynumeric.random.wald`
* `cupynumeric.random.weibull`
* `cupynumeric.random.zipf`
```

--------------------------------

### cupynumeric.broadcast

Source: https://docs.nvidia.com/cupynumeric

Details about broadcasting capabilities in cuPyNumeric.

```APIDOC
## cupynumeric.broadcast

### Description
Information regarding broadcasting rules and application within cuPyNumeric.

### Usage
This is typically used implicitly when performing operations between arrays of different shapes.
```

--------------------------------

### Mathematical Functions

Source: https://docs.nvidia.com/cupynumeric/26.06/index.html

A comprehensive set of mathematical functions for element-wise operations on arrays.

```APIDOC
## Trigonometric Functions

### Description
Element-wise trigonometric functions.

### Functions
- `cupynumeric.sin(x, out=None)`: Compute the sine of the input array element-wise.
- `cupynumeric.cos(x, out=None)`: Compute the cosine of the input array element-wise.
- `cupynumeric.tan(x, out=None)`: Compute the tangent of the input array element-wise.
- `cupynumeric.asin(x, out=None)`: Compute the arcsine of the input array element-wise.
- `cupynumeric.acos(x, out=None)`: Compute the arccosine of the input array element-wise.
- `cupynumeric.atan(x, out=None)`: Compute the arctangent of the input array element-wise.
- `cupynumeric.arcsin(x, out=None)`: Alias for `cupynumeric.asin`.
- `cupynumeric.arccos(x, out=None)`: Alias for `cupynumeric.acos`.
- `cupynumeric.arctan(x, out=None)`: Alias for `cupynumeric.atan`.
- `cupynumeric.hypot(x1, x2, out=None)`: Given two arrays of the same shape, return element-wise `hypot(x1, x2)`.
- `cupynumeric.arctan2(x1, x2, out=None)`: Element-wise arc tangent of `x1/x2`, using the signs of the two to determine the quadrant.
- `cupynumeric.degrees(x, out=None)`: Convert angles from radians to degrees.
- `cupynumeric.radians(x, out=None)`: Convert angles from degrees to radians.
- `cupynumeric.deg2rad(x, out=None)`: Alias for `cupynumeric.radians`.
- `cupynumeric.rad2deg(x, out=None)`: Alias for `cupynumeric.degrees`.

## Hyperbolic Functions

### Description
Element-wise hyperbolic functions.

### Functions
- `cupynumeric.sinh(x, out=None)`: Compute the hyperbolic sine of the input array element-wise.
- `cupynumeric.cosh(x, out=None)`: Compute the hyperbolic cosine of the input array element-wise.
- `cupynumeric.tanh(x, out=None)`: Compute the hyperbolic tangent of the input array element-wise.
- `cupynumeric.asinh(x, out=None)`: Compute the hyperbolic arcsine of the input array element-wise.
- `cupynumeric.acosh(x, out=None)`: Compute the hyperbolic arccosine of the input array element-wise.
- `cupynumeric.atanh(x, out=None)`: Compute the hyperbolic arctangent of the input array element-wise.
- `cupynumeric.arcsinh(x, out=None)`: Alias for `cupynumeric.asinh`.
- `cupynumeric.arccosh(x, out=None)`: Alias for `cupynumeric.acosh`.
- `cupynumeric.arctanh(x, out=None)`: Alias for `cupynumeric.atanh`.

## Rounding, Finiteness, and Other Floating Point Functions

### Description
Functions for rounding, checking finiteness, and other floating-point operations.

### Functions
- `cupynumeric.round(x, decimals=0, out=None)`: Round a new array into the given number of decimal elements.
- `cupynumeric.rint(x, out=None)`: Round input to nearest integer, preserving sign.
- `cupynumeric.floor(x, out=None)`: Return the floor of the input array, element-wise.
- `cupynumeric.ceil(x, out=None)`: Return the ceiling of the input array, element-wise.
- `cupynumeric.trunc(x, out=None)`: Return the truncated integer value of the input array, element-wise.

## Reduction Functions

### Description
Functions that reduce an array along a given axis.

### Functions
- `cupynumeric.prod(a, axis=None, dtype=None, out=None, keepdims=False)`: Return the product of array elements over the given axis.
- `cupynumeric.sum(a, axis=None, dtype=None, out=None, keepdims=False)`: Return the sum of array elements over the given axis.
- `cupynumeric.cumprod(a, axis=None, dtype=None, out=None)`: Return the cumulative product of array elements over the given axis.
- `cupynumeric.cumsum(a, axis=None, dtype=None, out=None)`: Return the cumulative sum of array elements over the given axis.
- `cupynumeric.diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>)`: Calculate the n-th discrete difference along the given axis.
- `cupynumeric.nancumprod(a, axis=None, dtype=None, out=None)`: Return the cumulative product of array elements over the given axis, treating NaNs as ones.
- `cupynumeric.nancumsum(a, axis=None, dtype=None, out=None)`: Return the cumulative sum of array elements over the given axis, treating NaNs as zeros.
- `cupynumeric.nanprod(a, axis=None, dtype=None, out=None, keepdims=False)`: Return the product of array elements over the given axis, treating NaNs as ones.
- `cupynumeric.nansum(a, axis=None, dtype=None, out=None, keepdims=False)`: Return the sum of array elements over the given axis, treating NaNs as zeros.

## Other Mathematical Functions

### Description
Miscellaneous mathematical functions.

### Functions
- `cupynumeric.gradient(f, *varargs, **kwargs)`: Return the gradient of an N-dimensional array.
- `cupynumeric.cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)`: Return the cross product of two (arrays of) vectors.
- `cupynumeric.exp(x, out=None)`: Compute the exponential of the input array element-wise.
- `cupynumeric.expm1(x, out=None)`: Compute `exp(x) - 1` element-wise.
- `cupynumeric.exp2(x, out=None)`: Compute `2**x` element-wise.
- `cupynumeric.log(x, out=None)`: Natural logarithm, element-wise.
- `cupynumeric.log10(x, out=None)`: Common logarithm, element-wise.
- `cupynumeric.log2(x, out=None)`: Base-2 logarithm, element-wise.
- `cupynumeric.log1p(x, out=None)`: Natural logarithm of one plus the input array, element-wise.
- `cupynumeric.logaddexp(a, b, out=None)`: Logarithm of the sum of the exponentiations of the two arrays, element-wise.
- `cupynumeric.logaddexp2(a, b, out=None)`: Logarithm of the sum of the exponentiations of the two arrays in base 2, element-wise.
- `cupynumeric.signbit(x, out=None)`: Return element-wise indication of the sign bit of the input.
- `cupynumeric.copysign(x1, x2, out=None)`: Return element-wise choices, conditionally taken from x1 or x2.
- `cupynumeric.frexp(x, out=None)`: Split the mantissa and exponent of the input array.
- `cupynumeric.ldexp(x1, x2, out=None)`: Unpacks the mantissa and exponent into the original number.
- `cupynumeric.nextafter(x1, x2, out=None)`: Return the next representable floating-point value after x1 towards x2.
- `cupynumeric.lcm(x1, x2, ...)`: Return the least common multiple of the input arrays.
- `cupynumeric.gcd(x1, x2, ...)`: Return the greatest common divisor of the input arrays.

## Arithmetic Operators

### Description
Element-wise arithmetic operations.

### Functions
- `cupynumeric.add(x1, x2, ...)`: Add arguments element-wise.
- `cupynumeric.reciprocal(x, out=None)`: Return element-wise `1/x`.
- `cupynumeric.positive(x, ...)`: Returns `x` element-wise.
- `cupynumeric.negative(x, ...)`: Returns `-x` element-wise.
- `cupynumeric.multiply(x1, x2, ...)`: Multiply arguments element-wise.
- `cupynumeric.divide(x1, x2, ...)`: Divide arguments element-wise.
- `cupynumeric.power(x1, x2, ...)`: First array elements raised to the power second array elements.
- `cupynumeric.subtract(x1, x2, ...)`: Subtract arguments element-wise.
- `cupynumeric.true_divide(x1, x2, ...)`: Returns `x1/x2` element-wise.
- `cupynumeric.floor_divide(x1, x2, ...)`: Return the floor of the division of x1 by x2 element-wise.
- `cupynumeric.float_power(x1, x2, out=None)`: First array elements raised to the power second array elements.
- `cupynumeric.fmod(x1, x2, ...)`: Return element-wise remainder of division.
- `cupynumeric.mod(x1, x2, ...)`: Return element-wise remainder of division.
- `cupynumeric.modf(x, out=None)`: Returns separate fractional and integer parts of the input array, element-wise.
- `cupynumeric.remainder(x1, x2, ...)`: Return element-wise remainder of division.

## Complex Number Functions

### Description
Functions for operating on complex numbers.

### Functions
- `cupynumeric.real(x)`: Returns the real part of the input array.
- `cupynumeric.real_if_close(a, tol=100)`: Returns a view of `a` with complex dtype but real values, if `a` is complex and all values are close to real.
- `cupynumeric.imag(x)`: Returns the imaginary part of the input array.
- `cupynumeric.angle(z, deg=False, out=None)`: Return the angle of the complex input along argument axis.
- `cupynumeric.conj(x, out=None)`: Return the complex conjugate, element-wise.
- `cupynumeric.conjugate(x, out=None)`: Return the complex conjugate, element-wise.

## Extrema Functions

### Description
Functions to find the maximum or minimum of an array or pairs of values.

### Functions
- `cupynumeric.maximum(x1, x2, out=None)`: Element-wise maximum of two arrays.
- `cupynumeric.fmax(x1, x2, out=None)`: Element-wise maximum of two arrays, ignoring NaNs.
- `cupynumeric.amax(a, axis=None, out=None, keepdims=False)`: Return the maximum of an array or maximum element along an axis.
- `cupynumeric.minimum(x1, x2, out=None)`: Element-wise minimum of two arrays.
- `cupynumeric.fmin(x1, x2, out=None)`: Element-wise minimum of two arrays, ignoring NaNs.
- `cupynumeric.amin(a, axis=None, out=None, keepdims=False)`: Return the minimum of an array or minimum element along an axis.
- `cupynumeric.nanmin(a, axis=None, out=None, keepdims=False)`: Return the minimum of an array or minimum element along an axis, ignoring NaNs.
- `cupynumeric.nanmax(a, axis=None, out=None, keepdims=False)`: Return the maximum of an array or maximum element along an axis, ignoring NaNs.

## Other Mathematical Functions (Continued)

### Description
Additional mathematical utility functions.

### Functions
- `cupynumeric.convolve(a, v, axis=-1)`: Returns the discrete, linear convolution of two one-dimensional vectors.
- `cupynumeric.clip(a, a_min, a_max, out=None)`: Clip (limit) the values in an array.
- `cupynumeric.nan_to_num(x, nan=0.0, posinf=inf, neginf=-inf, out=None)`: Replace nan, inf, -inf in array with appropriate values.
- `cupynumeric.sqrt(x, out=None)`: Return the element-wise square root of the input array.
- `cupynumeric.cbrt(x, out=None)`: Return the element-wise cube root of the input array.
- `cupynumeric.square(x, out=None)`: Compute `x**2` element-wise.
- `cupynumeric.roots(p, out=None)`: Return the roots of a polynomial whose coefficients are given in `p`.
- `cupynumeric.absolute(x, out=None)`: Calculate the absolute value element-wise.
- `cupynumeric.fabs(x, out=None)`: Compute the absolute values element-wise.
- `cupynumeric.sign(x, out=None)`: Compute the sign of an array element-wise.

## Linear Algebra Functions

### Description
Functions for basic linear algebra operations.

### Functions
- `cupynumeric.inner(a, b, out=None)`: Inner product of two arrays.
- `cupynumeric.outer(a, b, out=None)`: Compute the outer product of two vectors.
- `cupynumeric.vdot(a, b, out=None)`: Computes the vector dot product of `a` and `b`.
```

--------------------------------

### Logic Functions

Source: https://docs.nvidia.com/cupynumeric

Routines for logical operations on arrays.

```APIDOC
## Logic Functions

Functions for logical operations on arrays.

### Routines
(No specific routines listed in the source for this section.)
```

--------------------------------

### Linear Algebra

Source: https://docs.nvidia.com/cupynumeric

Routines for linear algebra operations, including matrix operations, decompositions, and solving linear systems.

```APIDOC
## Linear Algebra (`cupynumeric.linalg`)

Functions for linear algebra operations.

### Routines
- `cupynumeric.dot`
- `cupynumeric.vdot`
- `cupynumeric.inner`
- `cupynumeric.outer`
- `cupynumeric.matmul`
- `cupynumeric.tensordot`
- `cupynumeric.einsum`
- `cupynumeric.einsum_path`
- `cupynumeric.linalg.matrix_power`
- `cupynumeric.linalg.multi_dot`
- `cupynumeric.linalg.cholesky`
- `cupynumeric.linalg.eig`
- `cupynumeric.linalg.eigh`
- `cupynumeric.linalg.eigvals`
- `cupynumeric.linalg.eigvalsh`
- `cupynumeric.linalg.qr`
- `cupynumeric.linalg.svd`
- `cupynumeric.linalg.norm`
- `cupynumeric.trace`
- `cupynumeric.linalg.solve`
- `cupynumeric.linalg.pinv`
- `cupynumeric.linalg.expm`
```

--------------------------------

### Mathematical Functions

Source: https://docs.nvidia.com/cupynumeric

A comprehensive set of mathematical functions for numerical computations.

```APIDOC
## Mathematical Functions

### Description
Provides a wide range of mathematical functions for array manipulation and computation.

### Trigonometric Functions
- `cupynumeric.sin(x, /)`
- `cupynumeric.cos(x, /)`
- `cupynumeric.tan(x, /)`
- `cupynumeric.asin(x, /)`
- `cupynumeric.acos(x, /)`
- `cupynumeric.atan(x, /)`
- `cupynumeric.hypot(x1, x2, /)`
- `cupynumeric.arctan2(x1, x2, /)`
- `cupynumeric.degrees(x, /)`
- `cupynumeric.radians(x, /)`
- `cupynumeric.deg2rad(x, /)`
- `cupynumeric.rad2deg(x, /)`

### Hyperbolic Functions
- `cupynumeric.sinh(x, /)`
- `cupynumeric.cosh(x, /)`
- `cupynumeric.tanh(x, /)`
- `cupynumeric.asinh(x, /)`
- `cupynumeric.acosh(x, /)`
- `cupynumeric.atanh(x, /)`

### Rounding, Finiteness, and Comparisons
- `cupynumeric.isfinite(x, /)`
- `cupynumeric.isinf(x, /)`
- `cupynumeric.isnan(x, /)`
- `cupynumeric.isneginf(x, /)`
- `cupynumeric.isposinf(x, /)`
- `cupynumeric.round(x, obj=None, /)`
- `cupynumeric.rint(x, /)`
- `cupynumeric.floor(x, /)`
- `cupynumeric.ceil(x, /)`
- `cupynumeric.trunc(x, /)`

### Exponents and Logarithms
- `cupynumeric.exp(x, /)`
- `cupynumeric.expm1(x, /)`
- `cupynumeric.exp2(x, /)`
- `cupynumeric.log(x, /)`
- `cupynumeric.log10(x, /)`
- `cupynumeric.log2(x, /)`
- `cupynumeric.log1p(x, /)`
- `cupynumeric.logaddexp(x1, x2, /)`
- `cupynumeric.logaddexp2(x1, x2, /)`

### Special Functions
- `cupynumeric.signbit(x, /)`
- `cupynumeric.copysign(x1, x2, /)`
- `cupynumeric.frexp(x, /)`
- `cupynumeric.ldexp(x1, x2, /)`
- `cupynumeric.nextafter(x1, x2, /)`

### Sums, Products, Differences, and Extrema
- `cupynumeric.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.prod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.cumsum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.cumprod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>)`
- `cupynumeric.nansum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.nanprod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.nancumsum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.nancumprod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.nanmax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`
- `cupynumeric.nanmin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`

### Other Mathematical Operations
- `cupynumeric.gcd(x1, x2, /)`
- `cupynumeric.lcm(x1, x2, /)`
- `cupynumeric.add(x1, x2, /)`
- `cupynumeric.reciprocal(x, /)`
- `cupynumeric.positive(x, /)`
- `cupynumeric.negative(x, /)`
- `cupynumeric.multiply(x1, x2, /)`
- `cupynumeric.divide(x1, x2, /)`
- `cupynumeric.true_divide(x1, x2, /)`
- `cupynumeric.floor_divide(x1, x2, /)`
- `cupynumeric.power(x1, x2, /)`
- `cupynumeric.subtract(x1, x2, /)`
- `cupynumeric.float_power(x1, x2, /)`
- `cupynumeric.fmod(x1, x2, /)`
- `cupynumeric.mod(x1, x2, /)`
- `cupynumeric.remainder(x1, x2, /)`
- `cupynumeric.modf(x, /)`
- `cupynumeric.sqrt(x, /)`
- `cupynumeric.cbrt(x, /)`
- `cupynumeric.square(x, /)`
- `cupynumeric.roots(p, /)`
- `cupynumeric.absolute(x, /)`
- `cupynumeric.fabs(x, /)`
- `cupynumeric.sign(x, /)`
- `cupynumeric.clip(a, a_min, a_max, out=None)`
- `cupynumeric.nan_to_num(x, nan=<no value>, posinf=<no value>, neginf=<no value>, out=None)`
- `cupynumeric.convolve(a, v, mode='full', /)`
- `cupynumeric.gradient(f, *varargs, axis=None)`
- `cupynumeric.cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)`
- `cupynumeric.inner(a, b, out=None)`
- `cupynumeric.outer(a, b, out=None)`
- `cupynumeric.vdot(a, b, inline=False)`
```

--------------------------------

### Statistics

Source: https://docs.nvidia.com/cupynumeric

Functions for calculating various statistical measures on array data, including mean, median, variance, and quantiles.

```APIDOC
## Statistics

This section provides functions for computing statistical properties of arrays.

### Functions
* `cupynumeric.quantile`
* `cupynumeric.percentile`
* `cupynumeric.nanquantile`
* `cupynumeric.nanpercentile`
* `cupynumeric.average`
* `cupynumeric.mean`
* `cupynumeric.nanmean`
* `cupynumeric.var`
* `cupynumeric.median`
* `cupynumeric.nanmedian`
* `cupynumeric.cov`
* `cupynumeric.bincount`
* `cupynumeric.histogram`
* `cupynumeric.histogram2d`
* `cupynumeric.histogramdd`
* `cupynumeric.digitize`
```

--------------------------------

### Logical Operations

Source: https://docs.nvidia.com/cupynumeric

Provides functions for performing element-wise logical operations on arrays.

```APIDOC
## Logical Operations

### Description
Functions for element-wise logical operations.

### Functions
- `cupynumeric.logical_and(x1, x2, /)`
- `cupynumeric.logical_or(x1, x2, /)`
- `cupynumeric.logical_not(x, /)`
- `cupynumeric.logical_xor(x1, x2, /)`
```

--------------------------------

### Complex Number Functions

Source: https://docs.nvidia.com/cupynumeric

Functions for handling complex numbers and their properties.

```APIDOC
## Complex Number Functions

### Description
Functions related to complex number properties and operations.

### Functions
- `cupynumeric.iscomplex(x, /)`
- `cupynumeric.iscomplexobj(x, /)`
- `cupynumeric.isreal(x, /)`
- `cupynumeric.isrealobj(x, /)`
- `cupynumeric.real(x1, /)`
- `cupynumeric.real_if_close(a, tol=1e-08, /)`
- `cupynumeric.imag(x1, /)`
- `cupynumeric.angle(z, deg=False, out=None)`
- `cupynumeric.conj(x, /)`
- `cupynumeric.conjugate(x, /)`
```

--------------------------------

### Comparison Operations

Source: https://docs.nvidia.com/cupynumeric

Enables element-wise comparison between arrays.

```APIDOC
## Comparison Operations

### Description
Functions for element-wise comparison of arrays.

### Functions
- `cupynumeric.greater(x1, x2, /)`
- `cupynumeric.greater_equal(x1, x2, /)`
- `cupynumeric.less(x1, x2, /)`
- `cupynumeric.less_equal(x1, x2, /)`
- `cupynumeric.equal(x1, x2, /)`
- `cupynumeric.not_equal(x1, x2, /)`
```

--------------------------------

### Set Routines

Source: https://docs.nvidia.com/cupynumeric

Functions for performing set operations on arrays, such as finding unique elements and checking for membership.

```APIDOC
## Set Routines

This section covers functions for array manipulation related to set theory.

### Functions
* `cupynumeric.unique`
* `cupynumeric.in1d`
* `cupynumeric.isin`
```

--------------------------------

### Data Type Routines

Source: https://docs.nvidia.com/cupynumeric

Routines related to data types, such as finding common types between arrays.

```APIDOC
## Data Type Routines

Functions related to data types.

### Routines
- `cupynumeric.find_common_type`
```
Tokens:
Raw