abs |
me.abs |
np.abs |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise absolute value; alias for absolute. |
absolute |
me.absolute |
np.absolute |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise absolute value. |
acos |
me.acos |
np.acos |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for arccos (NumPy 2.x). |
acosh |
me.acosh |
np.acosh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for arccosh (NumPy 2.x). |
add |
me.add |
np.add |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise addition. |
all |
me.all |
np.all |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Test whether all array elements are true. |
allclose |
me.allclose |
np.allclose |
counted_custom |
varies |
🟠 supported |
Element-wise tolerance check; cost = numel(a). |
amax |
me.amax |
np.amax |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Maximum value of array (alias for max/numpy.amax). |
amin |
me.amin |
np.amin |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Minimum value of array (alias for min/numpy.amin). |
angle |
me.angle |
np.angle |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return angle of complex argument element-wise. |
any |
me.any |
np.any |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Test whether any array element is true. |
append |
me.append |
np.append |
free |
\(0\) |
🟢 supported |
Append values to end of array. |
apply_along_axis |
— |
np.apply_along_axis |
blacklisted |
N/A |
🔴 blocked |
Apply function along axis. Not supported. |
apply_over_axes |
— |
np.apply_over_axes |
blacklisted |
N/A |
🔴 blocked |
Apply function over multiple axes. Not supported. |
arange |
me.arange |
np.arange |
free |
\(0\) |
🟢 supported |
Return evenly spaced values in given interval. |
arccos |
me.arccos |
np.arccos |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise inverse cosine. |
arccosh |
me.arccosh |
np.arccosh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise inverse hyperbolic cosine. |
arcsin |
me.arcsin |
np.arcsin |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise inverse sine. |
arcsinh |
me.arcsinh |
np.arcsinh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise inverse hyperbolic sine. |
arctan |
me.arctan |
np.arctan |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise inverse tangent. |
arctan2 |
me.arctan2 |
np.arctan2 |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise arctan(y/x) considering quadrant. |
arctanh |
me.arctanh |
np.arctanh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise inverse hyperbolic tangent. |
argmax |
me.argmax |
np.argmax |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Index of maximum value. |
argmin |
me.argmin |
np.argmin |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Index of minimum value. |
argpartition |
me.argpartition |
np.argpartition |
counted_custom |
varies |
🟠 supported |
Indirect partition; cost = n per slice. |
argsort |
me.argsort |
np.argsort |
counted_custom |
varies |
🟠 supported |
Indirect sort; cost = n*ceil(log2(n)) per slice. |
argwhere |
me.argwhere |
np.argwhere |
free |
\(0\) |
🟢 supported |
Find indices of non-zero elements. |
around |
me.around |
np.around |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for round. |
array |
me.array |
np.array |
free |
\(0\) |
🟢 supported |
Create array from data. |
array2string |
— |
np.array2string |
blacklisted |
N/A |
🔴 blocked |
Return string representation of array. Not supported. |
array_equal |
me.array_equal |
np.array_equal |
counted_custom |
varies |
🟠 supported |
Element-wise equality; cost = numel(a). |
array_equiv |
me.array_equiv |
np.array_equiv |
counted_custom |
varies |
🟠 supported |
Element-wise equivalence; cost = numel(a). |
array_repr |
— |
np.array_repr |
blacklisted |
N/A |
🔴 blocked |
Return string representation of array. Not supported. |
array_split |
me.array_split |
np.array_split |
free |
\(0\) |
🟢 supported |
Split array into sub-arrays (possibly unequal). |
array_str |
— |
np.array_str |
blacklisted |
N/A |
🔴 blocked |
Return string representation of data in array. Not supported. |
asarray |
me.asarray |
np.asarray |
free |
\(0\) |
🟢 supported |
Convert input to array. |
asarray_chkfinite |
me.asarray_chkfinite |
np.asarray_chkfinite |
free |
\(0\) |
🟢 supported |
Convert to array, raising if NaN or inf. |
asin |
me.asin |
np.asin |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for arcsin (NumPy 2.x). |
asinh |
me.asinh |
np.asinh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for arcsinh (NumPy 2.x). |
asmatrix |
— |
np.asmatrix |
blacklisted |
N/A |
🔴 blocked |
Interpret input as matrix (deprecated). Not supported. |
astype |
me.astype |
np.astype |
free |
\(0\) |
🟢 supported |
Cast array to specified type. |
atan |
me.atan |
np.atan |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for arctan (NumPy 2.x). |
atan2 |
me.atan2 |
np.atan2 |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for arctan2 (NumPy 2.x). |
atanh |
me.atanh |
np.atanh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for arctanh (NumPy 2.x). |
atleast_1d |
me.atleast_1d |
np.atleast_1d |
free |
\(0\) |
🟢 supported |
View inputs as arrays with at least one dimension. |
atleast_2d |
me.atleast_2d |
np.atleast_2d |
free |
\(0\) |
🟢 supported |
View inputs as arrays with at least two dimensions. |
atleast_3d |
me.atleast_3d |
np.atleast_3d |
free |
\(0\) |
🟢 supported |
View inputs as arrays with at least three dimensions. |
average |
me.average |
np.average |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Weighted average of array elements. |
bartlett |
me.bartlett |
np.bartlett |
counted_custom |
\(n\) |
🟠 supported |
Bartlett window. Cost: n (one linear eval per sample). |
base_repr |
me.base_repr |
np.base_repr |
free |
\(0\) |
🟢 supported |
Return string representation of number in given base. |
binary_repr |
me.binary_repr |
np.binary_repr |
free |
\(0\) |
🟢 supported |
Return binary string representation of the input number. |
bincount |
me.bincount |
np.bincount |
counted_custom |
varies |
🟠 supported |
Integer counting; cost = numel(x). |
bitwise_and |
me.bitwise_and |
np.bitwise_and |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise bitwise AND. |
bitwise_count |
me.bitwise_count |
np.bitwise_count |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Count set bits element-wise (popcount). |
bitwise_invert |
me.bitwise_invert |
np.bitwise_invert |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise bitwise invert (alias for bitwise_not). |
bitwise_left_shift |
me.bitwise_left_shift |
np.bitwise_left_shift |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise left bit shift. |
bitwise_not |
me.bitwise_not |
np.bitwise_not |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise bitwise NOT. |
bitwise_or |
me.bitwise_or |
np.bitwise_or |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise bitwise OR. |
bitwise_right_shift |
me.bitwise_right_shift |
np.bitwise_right_shift |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise right bit shift. |
bitwise_xor |
me.bitwise_xor |
np.bitwise_xor |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise bitwise XOR. |
blackman |
me.blackman |
np.blackman |
counted_custom |
\(3n\) |
🟠 supported |
Blackman window. Cost: 3*n (three cosine terms per sample). |
block |
me.block |
np.block |
free |
\(0\) |
🟢 supported |
Assemble ndarray from nested list of blocks. |
bmat |
me.bmat |
np.bmat |
free |
\(0\) |
🟢 supported |
Build matrix from nested list of matrices. |
broadcast_arrays |
me.broadcast_arrays |
np.broadcast_arrays |
free |
\(0\) |
🟢 supported |
Broadcast arrays against each other. |
broadcast_shapes |
me.broadcast_shapes |
np.broadcast_shapes |
free |
\(0\) |
🟢 supported |
Compute broadcast shape from input shapes. |
broadcast_to |
me.broadcast_to |
np.broadcast_to |
free |
\(0\) |
🟢 supported |
Broadcast array to new shape. |
busday_count |
— |
np.busday_count |
blacklisted |
N/A |
🔴 blocked |
Count valid days between begindate and enddate. Not supported. |
busday_offset |
— |
np.busday_offset |
blacklisted |
N/A |
🔴 blocked |
Apply offset to dates subject to valid day rules. Not supported. |
can_cast |
me.can_cast |
np.can_cast |
free |
\(0\) |
🟢 supported |
Returns True if cast is safe. |
cbrt |
me.cbrt |
np.cbrt |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise cube root. |
ceil |
me.ceil |
np.ceil |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise ceiling. |
choose |
me.choose |
np.choose |
free |
\(0\) |
🟢 supported |
Construct array from index array and choices. |
clip |
me.clip |
np.clip |
counted_custom |
\(\text{numel}(\text{input})\) |
🟠 supported |
Clip array to [a_min, a_max] element-wise. |
column_stack |
me.column_stack |
np.column_stack |
free |
\(0\) |
🟢 supported |
Stack 1-D arrays as columns into 2-D array. |
common_type |
me.common_type |
np.common_type |
free |
\(0\) |
🟢 supported |
Return scalar type common to all input arrays. |
compress |
me.compress |
np.compress |
free |
\(0\) |
🟢 supported |
Return selected slices along axis. |
concat |
me.concat |
np.concat |
free |
\(0\) |
🟢 supported |
Join arrays along axis (NumPy 2.x array API alias for concatenate). |
concatenate |
me.concatenate |
np.concatenate |
free |
\(0\) |
🟢 supported |
Join arrays along axis. |
conj |
me.conj |
np.conj |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Complex conjugate element-wise. |
conjugate |
me.conjugate |
np.conjugate |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Complex conjugate element-wise. |
convolve |
me.convolve |
np.convolve |
counted_custom |
\(n \cdot m\) |
🟠 supported |
1-D discrete convolution. |
copy |
me.copy |
np.copy |
free |
\(0\) |
🟢 supported |
Return array copy. |
copysign |
me.copysign |
np.copysign |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Copy sign of x2 to magnitude of x1 element-wise. |
copyto |
me.copyto |
np.copyto |
free |
\(0\) |
🟢 supported |
Copy values from src to dst array. |
corrcoef |
me.corrcoef |
np.corrcoef |
counted_custom |
\(n^2 \cdot m\) |
🟠 supported |
Pearson correlation coefficients. |
correlate |
me.correlate |
np.correlate |
counted_custom |
\(n \cdot m\) |
🟠 supported |
1-D cross-correlation. |
cos |
me.cos |
np.cos |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise cosine. |
cosh |
me.cosh |
np.cosh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise hyperbolic cosine. |
count_nonzero |
me.count_nonzero |
np.count_nonzero |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Count non-zero elements. |
cov |
me.cov |
np.cov |
counted_custom |
\(n^2 \cdot m\) |
🟠 supported |
Covariance matrix. |
cross |
me.cross |
np.cross |
counted_custom |
\(\text{numel}(\text{output})\) |
🟠 supported |
Cross product of two 3-D vectors. |
cumprod |
me.cumprod |
np.cumprod |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Cumulative product of array elements. |
cumsum |
me.cumsum |
np.cumsum |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Cumulative sum of array elements. |
cumulative_prod |
me.cumulative_prod |
np.cumulative_prod |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Cumulative product (NumPy 2.x array API). |
cumulative_sum |
me.cumulative_sum |
np.cumulative_sum |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Cumulative sum (NumPy 2.x array API). |
datetime_as_string |
— |
np.datetime_as_string |
blacklisted |
N/A |
🔴 blocked |
Convert datetime array to string representation. Not supported. |
datetime_data |
— |
np.datetime_data |
blacklisted |
N/A |
🔴 blocked |
Get information about the step size of datetime dtype. Not supported. |
deg2rad |
me.deg2rad |
np.deg2rad |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for radians. |
degrees |
me.degrees |
np.degrees |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Convert radians to degrees element-wise. |
delete |
me.delete |
np.delete |
free |
\(0\) |
🟢 supported |
Return array with sub-arrays deleted along axis. |
diag |
me.diag |
np.diag |
free |
\(0\) |
🟢 supported |
Extract diagonal or construct diagonal array. |
diag_indices |
me.diag_indices |
np.diag_indices |
free |
\(0\) |
🟢 supported |
Return indices to access main diagonal of n-D array. |
diag_indices_from |
me.diag_indices_from |
np.diag_indices_from |
free |
\(0\) |
🟢 supported |
Return indices to access main diagonal of given array. |
diagflat |
me.diagflat |
np.diagflat |
free |
\(0\) |
🟢 supported |
Create diagonal array from flattened input. |
diagonal |
me.diagonal |
np.diagonal |
free |
\(0\) |
🟢 supported |
Return specified diagonals. |
diff |
me.diff |
np.diff |
counted_custom |
\(\text{numel}(\text{input})\) |
🟠 supported |
n-th discrete difference along axis. |
digitize |
me.digitize |
np.digitize |
counted_custom |
varies |
🟠 supported |
Bin search; cost = n*ceil(log2(bins)). |
divide |
me.divide |
np.divide |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise true division. |
divmod |
me.divmod |
np.divmod |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise (quotient, remainder) tuple. |
dot |
me.dot |
np.dot |
counted_custom |
\(2 \cdot m \cdot k \cdot n\) |
🟠 supported |
Dot product; cost = 2MN*K for matrix multiply. |
dsplit |
me.dsplit |
np.dsplit |
free |
\(0\) |
🟢 supported |
Split array into multiple sub-arrays depth-wise. |
dstack |
me.dstack |
np.dstack |
free |
\(0\) |
🟢 supported |
Stack arrays depth-wise (along third axis). |
ediff1d |
me.ediff1d |
np.ediff1d |
counted_custom |
\(\text{numel}(\text{input})\) |
🟠 supported |
Differences between consecutive elements. |
einsum |
me.einsum |
np.einsum |
counted_custom |
\(\text{op\_factor} \cdot \prod_i d_i\) |
🟠 supported |
Generalized Einstein summation. |
einsum_path |
me.einsum_path |
np.einsum_path |
counted_custom |
\(0\) |
🟠 supported |
Optimize einsum contraction path (no numeric output). |
empty |
me.empty |
np.empty |
free |
\(0\) |
🟢 supported |
Uninitialized array allocation. |
empty_like |
me.empty_like |
np.empty_like |
free |
\(0\) |
🟢 supported |
Uninitialized array with same shape/type as input. |
equal |
me.equal |
np.equal |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise x1 == x2. |
exp |
me.exp |
np.exp |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise e^x. |
exp2 |
me.exp2 |
np.exp2 |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise 2^x. |
expand_dims |
me.expand_dims |
np.expand_dims |
free |
\(0\) |
🟢 supported |
Insert new size-1 axis. |
expm1 |
me.expm1 |
np.expm1 |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise e^x - 1 (accurate near zero). |
extract |
me.extract |
np.extract |
free |
\(0\) |
🟢 supported |
Return elements satisfying condition. |
eye |
me.eye |
np.eye |
free |
\(0\) |
🟢 supported |
Create identity matrix. |
fabs |
me.fabs |
np.fabs |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise absolute value (always float). |
fft.fft |
me.fft.fft |
np.fft.fft |
counted_custom |
\(5n \cdot \lceil\log_2 n\rceil\) |
🟠 supported |
1-D complex FFT. Cost: 5nceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.fft2 |
me.fft.fft2 |
np.fft.fft2 |
counted_custom |
\(5N \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
2-D complex FFT. Cost: 5Nceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.fftfreq |
me.fft.fftfreq |
np.fft.fftfreq |
free |
\(0\) |
🟢 supported |
FFT sample frequencies. No arithmetic; returns index array. |
fft.fftn |
me.fft.fftn |
np.fft.fftn |
counted_custom |
\(5N \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
N-D complex FFT. Cost: 5Nceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.fftshift |
me.fft.fftshift |
np.fft.fftshift |
free |
\(0\) |
🟢 supported |
Shift zero-frequency component to center. No arithmetic; index reordering only. |
fft.hfft |
me.fft.hfft |
np.fft.hfft |
counted_custom |
\(5n \cdot \lceil\log_2 n\rceil\) |
🟠 supported |
FFT of Hermitian-symmetric signal. Cost: 5n_outceil(log2(n_out)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.ifft |
me.fft.ifft |
np.fft.ifft |
counted_custom |
\(5n \cdot \lceil\log_2 n\rceil\) |
🟠 supported |
Inverse 1-D complex FFT. Cost: 5nceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.ifft2 |
me.fft.ifft2 |
np.fft.ifft2 |
counted_custom |
\(5N \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
Inverse 2-D complex FFT. Cost: 5Nceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.ifftn |
me.fft.ifftn |
np.fft.ifftn |
counted_custom |
\(5N \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
Inverse N-D complex FFT. Cost: 5Nceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.ifftshift |
me.fft.ifftshift |
np.fft.ifftshift |
free |
\(0\) |
🟢 supported |
Inverse of fftshift. No arithmetic; index reordering only. |
fft.ihfft |
me.fft.ihfft |
np.fft.ihfft |
counted_custom |
\(5n \cdot \lceil\log_2 n\rceil\) |
🟠 supported |
Inverse FFT of Hermitian signal. Cost: 5nceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.irfft |
me.fft.irfft |
np.fft.irfft |
counted_custom |
\(5(n/2) \cdot \lceil\log_2 n\rceil\) |
🟠 supported |
Inverse 1-D real FFT. Cost: 5(n//2)ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.irfft2 |
me.fft.irfft2 |
np.fft.irfft2 |
counted_custom |
\(5(N/2) \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
Inverse 2-D real FFT. Cost: 5(N//2)ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.irfftn |
me.fft.irfftn |
np.fft.irfftn |
counted_custom |
\(5(N/2) \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
Inverse N-D real FFT. Cost: 5(N//2)ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.rfft |
me.fft.rfft |
np.fft.rfft |
counted_custom |
\(5(n/2) \cdot \lceil\log_2 n\rceil\) |
🟠 supported |
1-D real FFT. Cost: 5(n//2)ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.rfft2 |
me.fft.rfft2 |
np.fft.rfft2 |
counted_custom |
\(5(N/2) \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
2-D real FFT. Cost: 5(N//2)ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fft.rfftfreq |
me.fft.rfftfreq |
np.fft.rfftfreq |
free |
\(0\) |
🟢 supported |
Real FFT sample frequencies. No arithmetic; returns index array. |
fft.rfftn |
me.fft.rfftn |
np.fft.rfftn |
counted_custom |
\(5(N/2) \cdot \lceil\log_2 N\rceil\) |
🟠 supported |
N-D real FFT. Cost: 5(N//2)ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4). |
fill_diagonal |
me.fill_diagonal |
np.fill_diagonal |
free |
\(0\) |
🟢 supported |
Fill main diagonal of given array. |
fix |
me.fix |
np.fix |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Round toward zero element-wise (alias for trunc). |
flatnonzero |
me.flatnonzero |
np.flatnonzero |
free |
\(0\) |
🟢 supported |
Return indices of non-zero elements in flattened array. |
flip |
me.flip |
np.flip |
free |
\(0\) |
🟢 supported |
Reverse order of elements along axis. |
fliplr |
me.fliplr |
np.fliplr |
free |
\(0\) |
🟢 supported |
Flip array left-right. |
flipud |
me.flipud |
np.flipud |
free |
\(0\) |
🟢 supported |
Flip array up-down. |
float_power |
me.float_power |
np.float_power |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise exponentiation in float64. |
floor |
me.floor |
np.floor |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise floor. |
floor_divide |
me.floor_divide |
np.floor_divide |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise floor division. |
fmax |
me.fmax |
np.fmax |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise maximum ignoring NaN. |
fmin |
me.fmin |
np.fmin |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise minimum ignoring NaN. |
fmod |
me.fmod |
np.fmod |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise C-style fmod (remainder toward zero). |
format_float_positional |
— |
np.format_float_positional |
blacklisted |
N/A |
🔴 blocked |
Format floating point scalar as decimal string. Not supported. |
format_float_scientific |
— |
np.format_float_scientific |
blacklisted |
N/A |
🔴 blocked |
Format floating point scalar as scientific notation. Not supported. |
frexp |
me.frexp |
np.frexp |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Decompose x into mantissa and exponent element-wise. |
from_dlpack |
me.from_dlpack |
np.from_dlpack |
free |
\(0\) |
🟢 supported |
Create ndarray from DLPack object (zero-copy). |
frombuffer |
me.frombuffer |
np.frombuffer |
free |
\(0\) |
🟢 supported |
Interpret buffer as 1-D array. |
fromfile |
me.fromfile |
np.fromfile |
free |
\(0\) |
🟢 supported |
Construct array from binary/text file. |
fromfunction |
me.fromfunction |
np.fromfunction |
free |
\(0\) |
🟢 supported |
Construct array by executing function over each coordinate. |
fromiter |
me.fromiter |
np.fromiter |
free |
\(0\) |
🟢 supported |
Create array from an iterable. |
frompyfunc |
— |
np.frompyfunc |
blacklisted |
N/A |
🔴 blocked |
Take arbitrary Python function and return NumPy ufunc. Not supported. |
fromregex |
me.fromregex |
np.fromregex |
free |
\(0\) |
🟢 supported |
Construct array from text file using regex. |
fromstring |
me.fromstring |
np.fromstring |
free |
\(0\) |
🟢 supported |
Create 1-D array from string data. |
full |
me.full |
np.full |
free |
\(0\) |
🟢 supported |
Create array filled with scalar value. |
full_like |
me.full_like |
np.full_like |
free |
\(0\) |
🟢 supported |
Array filled with scalar, same shape/type as input. |
gcd |
me.gcd |
np.gcd |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise greatest common divisor. |
genfromtxt |
— |
np.genfromtxt |
blacklisted |
N/A |
🔴 blocked |
Load data from text file with missing values. Not supported. |
geomspace |
me.geomspace |
np.geomspace |
counted_custom |
varies |
🟠 supported |
Geometric-spaced generation; cost = num. |
get_include |
— |
np.get_include |
blacklisted |
N/A |
🔴 blocked |
Return directory containing NumPy C header files. Not supported. |
getbufsize |
— |
np.getbufsize |
blacklisted |
N/A |
🔴 blocked |
Return size of buffer used in ufuncs. Not supported. |
geterr |
— |
np.geterr |
blacklisted |
N/A |
🔴 blocked |
Get current way of handling floating-point errors. Not supported. |
geterrcall |
— |
np.geterrcall |
blacklisted |
N/A |
🔴 blocked |
Return current callback function for floating-point errors. Not supported. |
gradient |
me.gradient |
np.gradient |
counted_custom |
\(\text{numel}(\text{input})\) |
🟠 supported |
Gradient using central differences. |
greater |
me.greater |
np.greater |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise x1 > x2. |
greater_equal |
me.greater_equal |
np.greater_equal |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise x1 >= x2. |
hamming |
me.hamming |
np.hamming |
counted_custom |
\(n\) |
🟠 supported |
Hamming window. Cost: n (one cosine per sample). |
hanning |
me.hanning |
np.hanning |
counted_custom |
\(n\) |
🟠 supported |
Hanning window. Cost: n (one cosine per sample). |
heaviside |
me.heaviside |
np.heaviside |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Heaviside step function element-wise. |
histogram |
me.histogram |
np.histogram |
counted_custom |
varies |
🟠 supported |
Binning; cost = n*ceil(log2(bins)). |
histogram2d |
me.histogram2d |
np.histogram2d |
counted_custom |
varies |
🟠 supported |
2D binning; cost = n*(ceil(log2(bx))+ceil(log2(by))). |
histogram_bin_edges |
me.histogram_bin_edges |
np.histogram_bin_edges |
counted_custom |
varies |
🟠 supported |
Bin edge computation; cost = numel(a). |
histogramdd |
me.histogramdd |
np.histogramdd |
counted_custom |
varies |
🟠 supported |
ND binning; cost = n*sum(ceil(log2(b_i))). |
hsplit |
me.hsplit |
np.hsplit |
free |
\(0\) |
🟢 supported |
Split array into columns. |
hstack |
me.hstack |
np.hstack |
free |
\(0\) |
🟢 supported |
Stack arrays horizontally. |
hypot |
me.hypot |
np.hypot |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise Euclidean norm sqrt(x1^2 + x2^2). |
i0 |
me.i0 |
np.i0 |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Modified Bessel function of order 0, element-wise. |
identity |
me.identity |
np.identity |
free |
\(0\) |
🟢 supported |
Create square identity matrix. |
imag |
me.imag |
np.imag |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return imaginary part of complex array. |
in1d |
me.in1d |
np.in1d |
counted_custom |
varies |
🟠 supported |
Set membership; cost = (n+m)*ceil(log2(n+m)). |
indices |
me.indices |
np.indices |
free |
\(0\) |
🟢 supported |
Return array representing indices of a grid. |
inner |
me.inner |
np.inner |
counted_custom |
\(n\) |
🟠 supported |
Inner product; cost = 2N for 1-D, 2N*M for n-D. |
insert |
me.insert |
np.insert |
free |
\(0\) |
🟢 supported |
Insert values along axis before given indices. |
interp |
me.interp |
np.interp |
counted_custom |
\(n \cdot \log m\) |
🟠 supported |
1-D linear interpolation. |
intersect1d |
me.intersect1d |
np.intersect1d |
counted_custom |
varies |
🟠 supported |
Set intersection; cost = (n+m)*ceil(log2(n+m)). |
invert |
me.invert |
np.invert |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Bitwise NOT element-wise. |
is_busday |
— |
np.is_busday |
blacklisted |
N/A |
🔴 blocked |
Calculates which of given dates are valid days. Not supported. |
isclose |
me.isclose |
np.isclose |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise approximate equality test. |
iscomplex |
me.iscomplex |
np.iscomplex |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Test if element is complex element-wise. |
iscomplexobj |
me.iscomplexobj |
np.iscomplexobj |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return True if input is a complex type or array. |
isdtype |
me.isdtype |
np.isdtype |
free |
\(0\) |
🟢 supported |
Return True if array or dtype is of specified kind (NumPy 2.x). |
isfinite |
me.isfinite |
np.isfinite |
free |
\(0\) |
🟢 supported |
Test for finite values element-wise. |
isfortran |
me.isfortran |
np.isfortran |
free |
\(0\) |
🟢 supported |
Return True if array is Fortran contiguous. |
isin |
me.isin |
np.isin |
counted_custom |
varies |
🟠 supported |
Set membership; cost = (n+m)*ceil(log2(n+m)). |
isinf |
me.isinf |
np.isinf |
free |
\(0\) |
🟢 supported |
Test for infinity element-wise. |
isnan |
me.isnan |
np.isnan |
free |
\(0\) |
🟢 supported |
Test for NaN element-wise. |
isnat |
me.isnat |
np.isnat |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Test for NaT (not-a-time) element-wise. |
isneginf |
me.isneginf |
np.isneginf |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Test for negative infinity element-wise. |
isposinf |
me.isposinf |
np.isposinf |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Test for positive infinity element-wise. |
isreal |
me.isreal |
np.isreal |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Test if element is real (imag == 0) element-wise. |
isrealobj |
me.isrealobj |
np.isrealobj |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return True if x is a not complex type or array. |
isscalar |
me.isscalar |
np.isscalar |
free |
\(0\) |
🟢 supported |
Return True if input is a scalar. |
issubdtype |
me.issubdtype |
np.issubdtype |
free |
\(0\) |
🟢 supported |
Return True if first argument is lower in type hierarchy. |
iterable |
me.iterable |
np.iterable |
free |
\(0\) |
🟢 supported |
Return True if object is iterable. |
ix_ |
me.ix_ |
np.ix_ |
free |
\(0\) |
🟢 supported |
Construct open mesh from multiple sequences. |
kaiser |
me.kaiser |
np.kaiser |
counted_custom |
\(3n\) |
🟠 supported |
Kaiser window. Cost: 3*n (Bessel function eval per sample). |
kron |
me.kron |
np.kron |
counted_custom |
\(m_1 m_2 \cdot n_1 n_2\) |
🟠 supported |
Kronecker product; cost proportional to output size. |
lcm |
me.lcm |
np.lcm |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise least common multiple. |
ldexp |
me.ldexp |
np.ldexp |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return x1 * 2**x2 element-wise. |
left_shift |
me.left_shift |
np.left_shift |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise left bit shift (legacy name). |
less |
me.less |
np.less |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise x1 < x2. |
less_equal |
me.less_equal |
np.less_equal |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise x1 <= x2. |
lexsort |
me.lexsort |
np.lexsort |
counted_custom |
varies |
🟠 supported |
Multi-key sort; cost = knceil(log2(n)). |
linalg.cholesky |
me.linalg.cholesky |
np.linalg.cholesky |
counted_custom |
\(n^3 / 3\) |
🟠 supported |
Cholesky decomposition. Cost: \(n^3/3\) (Golub & Van Loan §4.2). |
linalg.cond |
me.linalg.cond |
np.linalg.cond |
counted_custom |
\(m \cdot n \cdot \min(m,n)\) |
🟠 supported |
Condition number. Cost: mnmin(m,n) (via SVD). |
linalg.cross |
me.linalg.cross |
np.linalg.cross |
counted_custom |
delegates to cross |
🟠 supported |
Delegates to me.cross which charges numel(output) FLOPs. |
linalg.det |
me.linalg.det |
np.linalg.det |
counted_custom |
\(n^3\) |
🟠 supported |
Determinant. Cost: \(n^3\) (LU factorization). |
linalg.diagonal |
me.linalg.diagonal |
np.linalg.diagonal |
free |
\(0\) |
🟢 supported |
View of diagonal — delegates to mechestim.diagonal. Cost: 0 FLOPs. |
linalg.eig |
me.linalg.eig |
np.linalg.eig |
counted_custom |
\(10n^3\) |
🟠 supported |
Eigendecomposition. Cost: \(10n^3\) (Francis QR, Golub & Van Loan §7.5). |
linalg.eigh |
me.linalg.eigh |
np.linalg.eigh |
counted_custom |
\(4n^3 / 3\) |
🟠 supported |
Symmetric eigendecomposition. Cost: \((4/3)n^3\) (Golub & Van Loan §8.3). |
linalg.eigvals |
me.linalg.eigvals |
np.linalg.eigvals |
counted_custom |
\(10n^3\) |
🟠 supported |
Eigenvalues only. Cost: \(10n^3\) (same as eig). |
linalg.eigvalsh |
me.linalg.eigvalsh |
np.linalg.eigvalsh |
counted_custom |
\(4n^3 / 3\) |
🟠 supported |
Symmetric eigenvalues. Cost: \((4/3)n^3\) (same as eigh). |
linalg.inv |
me.linalg.inv |
np.linalg.inv |
counted_custom |
\(n^3\) |
🟠 supported |
Matrix inverse. Cost: \(n^3\) (LU + solve). |
linalg.lstsq |
me.linalg.lstsq |
np.linalg.lstsq |
counted_custom |
\(m \cdot n \cdot \min(m,n)\) |
🟠 supported |
Least squares. Cost: mnmin(m,n) (LAPACK gelsd/SVD). |
linalg.matmul |
me.linalg.matmul |
np.linalg.matmul |
counted_custom |
delegates to matmul |
🟠 supported |
Delegates to me.matmul which charges 2*m*k*n FLOPs. |
linalg.matrix_norm |
me.linalg.matrix_norm |
np.linalg.matrix_norm |
counted_custom |
varies |
🟠 supported |
Matrix norm. Cost depends on ord: 2numel for Frobenius, mn*min(m,n) for ord=2. |
linalg.matrix_power |
me.linalg.matrix_power |
np.linalg.matrix_power |
counted_custom |
\(\lfloor\log_2 k\rfloor \cdot n^3\) |
🟠 supported |
Matrix power. Cost: \((\lfloor\log_2 k\rfloor + \text{popcount}(k) - 1) \cdot n^3\) (exponentiation by squaring). |
linalg.matrix_rank |
me.linalg.matrix_rank |
np.linalg.matrix_rank |
counted_custom |
\(m \cdot n \cdot \min(m,n)\) |
🟠 supported |
Matrix rank. Cost: mnmin(m,n) (via SVD). |
linalg.matrix_transpose |
me.linalg.matrix_transpose |
np.linalg.matrix_transpose |
free |
\(0\) |
🟢 supported |
Transpose view — delegates to mechestim.matrix_transpose. Cost: 0 FLOPs. |
linalg.multi_dot |
me.linalg.multi_dot |
np.linalg.multi_dot |
counted_custom |
optimal chain |
🟠 supported |
Chain matmul. Cost: sum of optimal chain matmul costs (CLRS §15.2). |
linalg.norm |
me.linalg.norm |
np.linalg.norm |
counted_custom |
varies |
🟠 supported |
Norm. Cost depends on ord: numel for L1/inf, 2numel for Frobenius, mn*min(m,n) for ord=2. |
linalg.outer |
me.linalg.outer |
np.linalg.outer |
counted_custom |
delegates to outer |
🟠 supported |
Delegates to me.outer which charges m*n FLOPs. |
linalg.pinv |
me.linalg.pinv |
np.linalg.pinv |
counted_custom |
\(m \cdot n \cdot \min(m,n)\) |
🟠 supported |
Pseudoinverse. Cost: mnmin(m,n) (via SVD). |
linalg.qr |
me.linalg.qr |
np.linalg.qr |
counted_custom |
\(2mn^2 - 2n^3/3\) |
🟠 supported |
QR decomposition. Cost: \(2mn^2 - (2/3)n^3\) (Golub & Van Loan §5.2). |
linalg.slogdet |
me.linalg.slogdet |
np.linalg.slogdet |
counted_custom |
\(n^3\) |
🟠 supported |
Sign + log determinant. Cost: \(n^3\) (LU factorization). |
linalg.solve |
me.linalg.solve |
np.linalg.solve |
counted_custom |
\(2n^3/3 + n^2 \cdot n_{\text{rhs}}\) |
🟠 supported |
Solve Ax=b. Cost: \(2n^3/3\) (LU) + \(n^2 \cdot n_{\text{rhs}}\) (back-substitution). |
linalg.svd |
me.linalg.svd |
np.linalg.svd |
counted_custom |
\(m \cdot n \cdot k\) |
🟠 supported |
Singular value decomposition; cost ~ O(min(m,n)mn). |
linalg.svdvals |
me.linalg.svdvals |
np.linalg.svdvals |
counted_custom |
\(m \cdot n \cdot \min(m,n)\) |
🟠 supported |
Singular values only. Cost: mnmin(m,n) (Golub-Reinsch). |
linalg.tensordot |
me.linalg.tensordot |
np.linalg.tensordot |
counted_custom |
delegates to tensordot |
🟠 supported |
Delegates to me.tensordot which charges FLOPs based on contraction. |
linalg.tensorinv |
me.linalg.tensorinv |
np.linalg.tensorinv |
counted_custom |
\(n^3\) |
🟠 supported |
Tensor inverse. Cost: \(n^3\) after reshape (delegates to inv). |
linalg.tensorsolve |
me.linalg.tensorsolve |
np.linalg.tensorsolve |
counted_custom |
\(n^3\) |
🟠 supported |
Tensor solve. Cost: \(n^3\) after reshape (delegates to solve). |
linalg.trace |
me.linalg.trace |
np.linalg.trace |
counted_custom |
\(n\) |
🟠 supported |
Matrix trace. Cost: n (sum of diagonal elements). |
linalg.vecdot |
me.linalg.vecdot |
np.linalg.vecdot |
counted_custom |
delegates to vecdot |
🟠 supported |
Delegates to me.vecdot which charges 2*n FLOPs. |
linalg.vector_norm |
me.linalg.vector_norm |
np.linalg.vector_norm |
counted_custom |
\(n\) or \(2n\) |
🟠 supported |
Vector norm. Cost: numel (or 2*numel for general p-norm). |
linspace |
me.linspace |
np.linspace |
free |
\(0\) |
🟢 supported |
Return evenly spaced numbers over interval. |
load |
— |
np.load |
blacklisted |
N/A |
🔴 blocked |
Load arrays from .npy/.npz files. Not supported. |
loadtxt |
— |
np.loadtxt |
blacklisted |
N/A |
🔴 blocked |
Load data from text file. Not supported. |
log |
me.log |
np.log |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise natural logarithm. |
log10 |
me.log10 |
np.log10 |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise base-10 logarithm. |
log1p |
me.log1p |
np.log1p |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise log(1+x) (accurate near zero). |
log2 |
me.log2 |
np.log2 |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise base-2 logarithm. |
logaddexp |
me.logaddexp |
np.logaddexp |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
log(exp(x1) + exp(x2)) element-wise. |
logaddexp2 |
me.logaddexp2 |
np.logaddexp2 |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
log2(2x1 + 2x2) element-wise. |
logical_and |
me.logical_and |
np.logical_and |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise logical AND. |
logical_not |
me.logical_not |
np.logical_not |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise logical NOT. |
logical_or |
me.logical_or |
np.logical_or |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise logical OR. |
logical_xor |
me.logical_xor |
np.logical_xor |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise logical XOR. |
logspace |
me.logspace |
np.logspace |
counted_custom |
varies |
🟠 supported |
Log-spaced generation; cost = num. |
mask_indices |
me.mask_indices |
np.mask_indices |
free |
\(0\) |
🟢 supported |
Return indices of mask for n x n array. |
matmul |
me.matmul |
np.matmul |
counted_custom |
\(2 \cdot m \cdot k \cdot n\) |
🟠 supported |
Matrix multiplication; cost = 2MN*K. |
matrix_transpose |
me.matrix_transpose |
np.matrix_transpose |
free |
\(0\) |
🟢 supported |
Transpose last two dimensions (NumPy 2.x array API). |
max |
me.max |
np.max |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Maximum value of array. |
maximum |
me.maximum |
np.maximum |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise maximum (propagates NaN). |
may_share_memory |
me.may_share_memory |
np.may_share_memory |
free |
\(0\) |
🟢 supported |
Determine if two arrays might share memory. |
mean |
me.mean |
np.mean |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Arithmetic mean of array elements. |
median |
me.median |
np.median |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Median of array elements (sorts internally). |
meshgrid |
me.meshgrid |
np.meshgrid |
free |
\(0\) |
🟢 supported |
Coordinate matrices from coordinate vectors. |
min |
me.min |
np.min |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Minimum value of array. |
min_scalar_type |
me.min_scalar_type |
np.min_scalar_type |
free |
\(0\) |
🟢 supported |
Return the minimum scalar type for a value. |
minimum |
me.minimum |
np.minimum |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise minimum (propagates NaN). |
mintypecode |
me.mintypecode |
np.mintypecode |
free |
\(0\) |
🟢 supported |
Return minimum data type character that can satisfy all given types. |
mod |
me.mod |
np.mod |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise modulo. |
modf |
me.modf |
np.modf |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return fractional and integral parts element-wise. |
moveaxis |
me.moveaxis |
np.moveaxis |
free |
\(0\) |
🟢 supported |
Move axes to new positions. |
multiply |
me.multiply |
np.multiply |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise multiplication. |
nan_to_num |
me.nan_to_num |
np.nan_to_num |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Replace NaN/inf with finite numbers element-wise. |
nanargmax |
me.nanargmax |
np.nanargmax |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Index of maximum ignoring NaNs. |
nanargmin |
me.nanargmin |
np.nanargmin |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Index of minimum ignoring NaNs. |
nancumprod |
me.nancumprod |
np.nancumprod |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Cumulative product ignoring NaNs. |
nancumsum |
me.nancumsum |
np.nancumsum |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Cumulative sum ignoring NaNs. |
nanmax |
me.nanmax |
np.nanmax |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Maximum ignoring NaNs. |
nanmean |
me.nanmean |
np.nanmean |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Mean ignoring NaNs. |
nanmedian |
me.nanmedian |
np.nanmedian |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Median ignoring NaNs. |
nanmin |
me.nanmin |
np.nanmin |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Minimum ignoring NaNs. |
nanpercentile |
me.nanpercentile |
np.nanpercentile |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
q-th percentile ignoring NaNs. |
nanprod |
me.nanprod |
np.nanprod |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Product ignoring NaNs. |
nanquantile |
me.nanquantile |
np.nanquantile |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
q-th quantile ignoring NaNs. |
nanstd |
me.nanstd |
np.nanstd |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Standard deviation ignoring NaNs. |
nansum |
me.nansum |
np.nansum |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Sum ignoring NaNs. |
nanvar |
me.nanvar |
np.nanvar |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Variance ignoring NaNs. |
ndim |
me.ndim |
np.ndim |
free |
\(0\) |
🟢 supported |
Return number of dimensions of array. |
negative |
me.negative |
np.negative |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise negation. |
nested_iters |
— |
np.nested_iters |
blacklisted |
N/A |
🔴 blocked |
Create nested iterators for multi-index broadcasting. Not supported. |
nextafter |
me.nextafter |
np.nextafter |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return next float after x1 toward x2 element-wise. |
nonzero |
me.nonzero |
np.nonzero |
free |
\(0\) |
🟢 supported |
Return indices of non-zero elements. |
not_equal |
me.not_equal |
np.not_equal |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise x1 != x2. |
ones |
me.ones |
np.ones |
free |
\(0\) |
🟢 supported |
Create one-filled array. |
ones_like |
me.ones_like |
np.ones_like |
free |
\(0\) |
🟢 supported |
Array of ones with same shape/type as input. |
outer |
me.outer |
np.outer |
counted_custom |
\(m \cdot n\) |
🟠 supported |
Outer product of two vectors; cost = M*N. |
packbits |
me.packbits |
np.packbits |
free |
\(0\) |
🟢 supported |
Pack elements of array into bits. |
pad |
me.pad |
np.pad |
free |
\(0\) |
🟢 supported |
Pad array. |
partition |
me.partition |
np.partition |
counted_custom |
varies |
🟠 supported |
Quickselect; cost = n per slice. |
percentile |
me.percentile |
np.percentile |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
q-th percentile of array elements. |
permute_dims |
me.permute_dims |
np.permute_dims |
free |
\(0\) |
🟢 supported |
Permute dimensions (NumPy 2.x array API). |
piecewise |
— |
np.piecewise |
blacklisted |
N/A |
🔴 blocked |
Evaluate piecewise-defined function. Not supported. |
place |
me.place |
np.place |
free |
\(0\) |
🟢 supported |
Change elements satisfying condition. |
poly |
me.poly |
np.poly |
counted_custom |
\(n^2\) |
🟠 supported |
Polynomial from roots. Cost: \(n^2\) FLOPs. |
polyadd |
me.polyadd |
np.polyadd |
counted_custom |
\(\max(n_1, n_2)\) |
🟠 supported |
Add two polynomials. Cost: max(n1, n2) FLOPs. |
polyder |
me.polyder |
np.polyder |
counted_custom |
\(n\) |
🟠 supported |
Differentiate polynomial. Cost: n FLOPs. |
polydiv |
me.polydiv |
np.polydiv |
counted_custom |
\(n_1 \cdot n_2\) |
🟠 supported |
Divide one polynomial by another. Cost: n1 * n2 FLOPs. |
polyfit |
me.polyfit |
np.polyfit |
counted_custom |
\(2m \cdot (\text{deg}+1)^2\) |
🟠 supported |
Least squares polynomial fit. Cost: 2 * m * (deg+1)^2 FLOPs. |
polyint |
me.polyint |
np.polyint |
counted_custom |
\(n\) |
🟠 supported |
Integrate polynomial. Cost: n FLOPs. |
polymul |
me.polymul |
np.polymul |
counted_custom |
\(n_1 \cdot n_2\) |
🟠 supported |
Multiply polynomials. Cost: n1 * n2 FLOPs. |
polysub |
me.polysub |
np.polysub |
counted_custom |
\(\max(n_1, n_2)\) |
🟠 supported |
Difference (subtraction) of two polynomials. Cost: max(n1, n2) FLOPs. |
polyval |
me.polyval |
np.polyval |
counted_custom |
\(2 \cdot m \cdot \text{deg}\) |
🟠 supported |
Evaluate polynomial at given points. Cost: 2 * m * deg FLOPs (Horner's method). |
positive |
me.positive |
np.positive |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise unary plus (copy with sign preserved). |
pow |
me.pow |
np.pow |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for power (NumPy 2.x). |
power |
me.power |
np.power |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise exponentiation x**y. |
prod |
me.prod |
np.prod |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Product of array elements. |
promote_types |
me.promote_types |
np.promote_types |
free |
\(0\) |
🟢 supported |
Return smallest type to which both types may be safely cast. |
ptp |
me.ptp |
np.ptp |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Peak-to-peak (max - min) range of array. |
put |
me.put |
np.put |
free |
\(0\) |
🟢 supported |
Replace elements at given flat indices. |
put_along_axis |
me.put_along_axis |
np.put_along_axis |
free |
\(0\) |
🟢 supported |
Put values into destination array using indices. |
putmask |
me.putmask |
np.putmask |
free |
\(0\) |
🟢 supported |
Change elements of array based on condition and input values. |
quantile |
me.quantile |
np.quantile |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
q-th quantile of array elements. |
rad2deg |
me.rad2deg |
np.rad2deg |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Alias for degrees. |
radians |
me.radians |
np.radians |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Convert degrees to radians element-wise. |
random.beta |
me.random.beta |
np.random.beta |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.binomial |
me.random.binomial |
np.random.binomial |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.bytes |
me.random.bytes |
np.random.bytes |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.chisquare |
me.random.chisquare |
np.random.chisquare |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.choice |
me.random.choice |
np.random.choice |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output) if replace, n*ceil(log2(n)) if not. |
random.default_rng |
me.random.default_rng |
np.random.default_rng |
free |
\(0\) |
🟢 supported |
Construct a new Generator with default BitGenerator. |
random.dirichlet |
me.random.dirichlet |
np.random.dirichlet |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.exponential |
me.random.exponential |
np.random.exponential |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.f |
me.random.f |
np.random.f |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.gamma |
me.random.gamma |
np.random.gamma |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.geometric |
me.random.geometric |
np.random.geometric |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.get_state |
me.random.get_state |
np.random.get_state |
free |
\(0\) |
🟢 supported |
Return tuple representing internal state of generator. |
random.gumbel |
me.random.gumbel |
np.random.gumbel |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.hypergeometric |
me.random.hypergeometric |
np.random.hypergeometric |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.laplace |
me.random.laplace |
np.random.laplace |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.logistic |
me.random.logistic |
np.random.logistic |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.lognormal |
me.random.lognormal |
np.random.lognormal |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.logseries |
me.random.logseries |
np.random.logseries |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.multinomial |
me.random.multinomial |
np.random.multinomial |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.multivariate_normal |
me.random.multivariate_normal |
np.random.multivariate_normal |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.negative_binomial |
me.random.negative_binomial |
np.random.negative_binomial |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.noncentral_chisquare |
me.random.noncentral_chisquare |
np.random.noncentral_chisquare |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.noncentral_f |
me.random.noncentral_f |
np.random.noncentral_f |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.normal |
me.random.normal |
np.random.normal |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.pareto |
me.random.pareto |
np.random.pareto |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.permutation |
me.random.permutation |
np.random.permutation |
counted_custom |
varies |
🟠 supported |
Shuffle; cost = n*ceil(log2(n)). |
random.poisson |
me.random.poisson |
np.random.poisson |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.power |
me.random.power |
np.random.power |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.rand |
me.random.rand |
np.random.rand |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.randint |
me.random.randint |
np.random.randint |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.randn |
me.random.randn |
np.random.randn |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.random |
me.random.random |
np.random.random |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.random_integers |
me.random.random_integers |
np.random.random_integers |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.random_sample |
me.random.random_sample |
np.random.random_sample |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.ranf |
me.random.ranf |
np.random.ranf |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.rayleigh |
me.random.rayleigh |
np.random.rayleigh |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.sample |
me.random.sample |
np.random.sample |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.seed |
me.random.seed |
np.random.seed |
free |
\(0\) |
🟢 supported |
Seed random number generator. |
random.set_state |
me.random.set_state |
np.random.set_state |
free |
\(0\) |
🟢 supported |
Set internal state of generator. |
random.shuffle |
me.random.shuffle |
np.random.shuffle |
counted_custom |
varies |
🟠 supported |
Shuffle; cost = n*ceil(log2(n)). |
random.standard_cauchy |
me.random.standard_cauchy |
np.random.standard_cauchy |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.standard_exponential |
me.random.standard_exponential |
np.random.standard_exponential |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.standard_gamma |
me.random.standard_gamma |
np.random.standard_gamma |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.standard_normal |
me.random.standard_normal |
np.random.standard_normal |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.standard_t |
me.random.standard_t |
np.random.standard_t |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.triangular |
me.random.triangular |
np.random.triangular |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.uniform |
me.random.uniform |
np.random.uniform |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.vonmises |
me.random.vonmises |
np.random.vonmises |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.wald |
me.random.wald |
np.random.wald |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.weibull |
me.random.weibull |
np.random.weibull |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
random.zipf |
me.random.zipf |
np.random.zipf |
counted_custom |
varies |
🟠 supported |
Sampling; cost = numel(output). |
ravel |
me.ravel |
np.ravel |
free |
\(0\) |
🟢 supported |
Return contiguous flattened array. |
ravel_multi_index |
me.ravel_multi_index |
np.ravel_multi_index |
free |
\(0\) |
🟢 supported |
Convert multi-dimensional index to flat index. |
real |
me.real |
np.real |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return real part of complex array. |
real_if_close |
me.real_if_close |
np.real_if_close |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return real array if imaginary part is negligible. |
reciprocal |
me.reciprocal |
np.reciprocal |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise 1/x. |
remainder |
me.remainder |
np.remainder |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise remainder (same as mod). |
repeat |
me.repeat |
np.repeat |
free |
\(0\) |
🟢 supported |
Repeat elements of an array. |
require |
me.require |
np.require |
free |
\(0\) |
🟢 supported |
Return array that satisfies requirements. |
reshape |
me.reshape |
np.reshape |
free |
\(0\) |
🟢 supported |
Reshape array without copying. |
resize |
me.resize |
np.resize |
free |
\(0\) |
🟢 supported |
Return new array with given shape by repeating. |
result_type |
me.result_type |
np.result_type |
free |
\(0\) |
🟢 supported |
Return type that results from applying NumPy type promotion. |
right_shift |
me.right_shift |
np.right_shift |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise right bit shift (legacy name). |
rint |
me.rint |
np.rint |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Round to nearest integer element-wise. |
roll |
me.roll |
np.roll |
free |
\(0\) |
🟢 supported |
Roll array elements along axis. |
rollaxis |
me.rollaxis |
np.rollaxis |
free |
\(0\) |
🟢 supported |
Roll specified axis backwards. |
roots |
me.roots |
np.roots |
counted_custom |
\(10n^3\) |
🟠 supported |
Return roots of polynomial with given coefficients. Cost: \(10n^3\) FLOPs (companion matrix eig). |
rot90 |
me.rot90 |
np.rot90 |
free |
\(0\) |
🟢 supported |
Rotate array 90 degrees. |
round |
me.round |
np.round |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Round to given number of decimals element-wise. |
row_stack |
me.row_stack |
np.row_stack |
free |
\(0\) |
🟢 supported |
Stack arrays vertically (alias for vstack). |
save |
— |
np.save |
blacklisted |
N/A |
🔴 blocked |
Save array to .npy file. Not supported. |
savetxt |
— |
np.savetxt |
blacklisted |
N/A |
🔴 blocked |
Save array to text file. Not supported. |
savez |
— |
np.savez |
blacklisted |
N/A |
🔴 blocked |
Save multiple arrays to .npz file. Not supported. |
savez_compressed |
— |
np.savez_compressed |
blacklisted |
N/A |
🔴 blocked |
Save multiple arrays to compressed .npz file. Not supported. |
searchsorted |
me.searchsorted |
np.searchsorted |
counted_custom |
varies |
🟠 supported |
Binary search; cost = m*ceil(log2(n)). |
select |
me.select |
np.select |
free |
\(0\) |
🟢 supported |
Return array from list of choices based on conditions. |
setbufsize |
— |
np.setbufsize |
blacklisted |
N/A |
🔴 blocked |
Set size of buffer used in ufuncs. Not supported. |
setdiff1d |
me.setdiff1d |
np.setdiff1d |
counted_custom |
varies |
🟠 supported |
Set difference; cost = (n+m)*ceil(log2(n+m)). |
seterr |
— |
np.seterr |
blacklisted |
N/A |
🔴 blocked |
Set how floating-point errors are handled. Not supported. |
seterrcall |
— |
np.seterrcall |
blacklisted |
N/A |
🔴 blocked |
Set callback function for floating-point errors. Not supported. |
setxor1d |
me.setxor1d |
np.setxor1d |
counted_custom |
varies |
🟠 supported |
Symmetric set difference; cost = (n+m)*ceil(log2(n+m)). |
shape |
me.shape |
np.shape |
free |
\(0\) |
🟢 supported |
Return shape of array. |
shares_memory |
me.shares_memory |
np.shares_memory |
free |
\(0\) |
🟢 supported |
Determine if two arrays share memory. |
show_config |
— |
np.show_config |
blacklisted |
N/A |
🔴 blocked |
Show NumPy build configuration. Not supported. |
show_runtime |
— |
np.show_runtime |
blacklisted |
N/A |
🔴 blocked |
Show runtime info. Not supported. |
sign |
me.sign |
np.sign |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise sign function. |
signbit |
me.signbit |
np.signbit |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Returns True for elements with negative sign bit. |
sin |
me.sin |
np.sin |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise sine. |
sinc |
me.sinc |
np.sinc |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Normalized sinc function element-wise. |
sinh |
me.sinh |
np.sinh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise hyperbolic sine. |
size |
me.size |
np.size |
free |
\(0\) |
🟢 supported |
Return number of elements in array. |
sort |
me.sort |
np.sort |
counted_custom |
varies |
🟠 supported |
Comparison sort; cost = n*ceil(log2(n)) per slice. |
sort_complex |
me.sort_complex |
np.sort_complex |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Sort complex array by real then imaginary part. |
spacing |
me.spacing |
np.spacing |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Return ULP spacing for each element. |
split |
me.split |
np.split |
free |
\(0\) |
🟢 supported |
Split array into sub-arrays. |
sqrt |
me.sqrt |
np.sqrt |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise square root. |
square |
me.square |
np.square |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise x^2. |
squeeze |
me.squeeze |
np.squeeze |
free |
\(0\) |
🟢 supported |
Remove size-1 dimensions. |
stack |
me.stack |
np.stack |
free |
\(0\) |
🟢 supported |
Join arrays along new axis. |
std |
me.std |
np.std |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Standard deviation; cost_multiplier=2 (two passes). |
subtract |
me.subtract |
np.subtract |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise subtraction. |
sum |
me.sum |
np.sum |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Sum of array elements. |
swapaxes |
me.swapaxes |
np.swapaxes |
free |
\(0\) |
🟢 supported |
Interchange two axes of an array. |
take |
me.take |
np.take |
free |
\(0\) |
🟢 supported |
Take elements from array along axis. |
take_along_axis |
me.take_along_axis |
np.take_along_axis |
free |
\(0\) |
🟢 supported |
Take values from input array by matching 1-D index. |
tan |
me.tan |
np.tan |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise tangent. |
tanh |
me.tanh |
np.tanh |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise hyperbolic tangent. |
tensordot |
me.tensordot |
np.tensordot |
counted_custom |
\(\prod_i d_i\) |
🟠 supported |
Tensor dot product along specified axes. |
tile |
me.tile |
np.tile |
free |
\(0\) |
🟢 supported |
Repeat array by tiling. |
trace |
me.trace |
np.trace |
counted_custom |
varies |
🟠 supported |
Diagonal sum; cost = min(n,m). |
transpose |
me.transpose |
np.transpose |
free |
\(0\) |
🟢 supported |
Permute array dimensions. |
trapezoid |
me.trapezoid |
np.trapezoid |
counted_custom |
\(\text{numel}(\text{input})\) |
🟠 supported |
Integrate using the trapezoidal rule. |
trapz |
me.trapz |
np.trapz |
counted_custom |
\(\text{numel}(\text{input})\) |
🟠 supported |
Alias for trapezoid (deprecated). |
tri |
me.tri |
np.tri |
free |
\(0\) |
🟢 supported |
Array with ones at and below given diagonal. |
tril |
me.tril |
np.tril |
free |
\(0\) |
🟢 supported |
Lower triangle of array. |
tril_indices |
me.tril_indices |
np.tril_indices |
free |
\(0\) |
🟢 supported |
Return lower-triangle indices for n x n array. |
tril_indices_from |
me.tril_indices_from |
np.tril_indices_from |
free |
\(0\) |
🟢 supported |
Return lower-triangle indices for given array. |
trim_zeros |
me.trim_zeros |
np.trim_zeros |
free |
\(0\) |
🟢 supported |
Trim leading/trailing zeros from 1-D array. |
triu |
me.triu |
np.triu |
free |
\(0\) |
🟢 supported |
Upper triangle of array. |
triu_indices |
me.triu_indices |
np.triu_indices |
free |
\(0\) |
🟢 supported |
Return upper-triangle indices for n x n array. |
triu_indices_from |
me.triu_indices_from |
np.triu_indices_from |
free |
\(0\) |
🟢 supported |
Return upper-triangle indices for given array. |
true_divide |
me.true_divide |
np.true_divide |
counted_binary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Element-wise true division (explicit). |
trunc |
me.trunc |
np.trunc |
counted_unary |
\(\text{numel}(\text{output})\) |
🟡 supported |
Truncate toward zero element-wise. |
typename |
me.typename |
np.typename |
free |
\(0\) |
🟢 supported |
Return description of given data type code. |
union1d |
me.union1d |
np.union1d |
counted_custom |
varies |
🟠 supported |
Set union; cost = (n+m)*ceil(log2(n+m)). |
unique |
me.unique |
np.unique |
counted_custom |
varies |
🟠 supported |
Sort-based unique; cost = n*ceil(log2(n)). |
unique_all |
me.unique_all |
np.unique_all |
counted_custom |
varies |
🟠 supported |
Sort-based unique; cost = n*ceil(log2(n)). |
unique_counts |
me.unique_counts |
np.unique_counts |
counted_custom |
varies |
🟠 supported |
Sort-based unique; cost = n*ceil(log2(n)). |
unique_inverse |
me.unique_inverse |
np.unique_inverse |
counted_custom |
varies |
🟠 supported |
Sort-based unique; cost = n*ceil(log2(n)). |
unique_values |
me.unique_values |
np.unique_values |
counted_custom |
varies |
🟠 supported |
Sort-based unique; cost = n*ceil(log2(n)). |
unpackbits |
me.unpackbits |
np.unpackbits |
free |
\(0\) |
🟢 supported |
Unpack elements of array into bits. |
unravel_index |
me.unravel_index |
np.unravel_index |
free |
\(0\) |
🟢 supported |
Convert flat index to multi-dimensional index. |
unstack |
me.unstack |
np.unstack |
free |
\(0\) |
🟢 supported |
Unstack array along axis into tuple of arrays (NumPy 2.x). |
unwrap |
me.unwrap |
np.unwrap |
counted_custom |
\(\text{numel}(\text{input})\) |
🟠 supported |
Phase unwrap. Cost: \(\text{numel}(\text{input})\) (diff + conditional adjustment). |
vander |
me.vander |
np.vander |
counted_custom |
varies |
🟠 supported |
Vandermonde matrix; cost = len(x)*(N-1). |
var |
me.var |
np.var |
counted_reduction |
\(\text{numel}(\text{input})\) |
🟡 supported |
Variance; cost_multiplier=2 (two passes). |
vdot |
me.vdot |
np.vdot |
counted_custom |
\(n\) |
🟠 supported |
Dot product with conjugation; cost = 2*N. |
vecdot |
me.vecdot |
np.vecdot |
counted_binary |
\(n\) |
🟡 supported |
Vector dot product along last axis. |
vsplit |
me.vsplit |
np.vsplit |
free |
\(0\) |
🟢 supported |
Split array into rows. |
vstack |
me.vstack |
np.vstack |
free |
\(0\) |
🟢 supported |
Stack arrays vertically. |
where |
me.where |
np.where |
free |
\(0\) |
🟢 supported |
Select elements based on condition. |
zeros |
me.zeros |
np.zeros |
free |
\(0\) |
🟢 supported |
Create zero-filled array. |
zeros_like |
me.zeros_like |
np.zeros_like |
free |
\(0\) |
🟢 supported |
Array of zeros with same shape/type as input. |