### 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=, append=)`: 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=, initial=, where=)` - `cupynumeric.prod(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.cumsum(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.cumprod(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.diff(a, n=1, axis=-1, prepend=, append=)` - `cupynumeric.nansum(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.nanprod(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.nancumsum(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.nancumprod(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.amax(a, axis=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.nanmax(a, axis=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.amin(a, axis=None, out=None, keepdims=, initial=, where=)` - `cupynumeric.nanmin(a, axis=None, out=None, keepdims=, initial=, where=)` ### 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=, posinf=, neginf=, 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` ```