{:.no_toc}
* TOC {:toc}Matrices alone are useless. We need some math functions to act upon them.
Questions to David Rotermund
I will focus on the important ones. Those will get a link.
| sin(x, /[, out, where, casting, order, ...]) | Trigonometric sine, element-wise. |
| cos(x, /[, out, where, casting, order, ...]) | Cosine element-wise. |
| tan(x, /[, out, where, casting, order, ...]) | Compute tangent element-wise. |
| arcsin(x, /[, out, where, casting, order, ...]) | Inverse sine, element-wise. |
| arccos(x, /[, out, where, casting, order, ...]) | Trigonometric inverse cosine, element-wise. |
| arctan(x, /[, out, where, casting, order, ...]) | Trigonometric inverse tangent, element-wise. |
| hypot(x1, x2, /[, out, where, casting, ...]) | Given the "legs" of a right triangle, return its hypotenuse. |
| arctan2(x1, x2, /[, out, where, casting, ...]) | Element-wise arc tangent of x1/x2 choosing the quadrant correctly. |
| degrees(x, /[, out, where, casting, order, ...]) | Convert angles from radians to degrees. |
| radians(x, /[, out, where, casting, order, ...]) | Convert angles from degrees to radians. |
| unwrap(p[, discont, axis, period]) | Unwrap by taking the complement of large deltas with respect to the period. |
| deg2rad(x, /[, out, where, casting, order, ...]) | Convert angles from degrees to radians. |
| rad2deg(x, /[, out, where, casting, order, ...]) | Convert angles from radians to degrees. |
| sinh(x, /[, out, where, casting, order, ...]) | Hyperbolic sine, element-wise. |
| cosh(x, /[, out, where, casting, order, ...]) | Hyperbolic cosine, element-wise. |
| tanh(x, /[, out, where, casting, order, ...]) | Compute hyperbolic tangent element-wise. |
| arcsinh(x, /[, out, where, casting, order, ...]) | Inverse hyperbolic sine element-wise. |
| arccosh(x, /[, out, where, casting, order, ...]) | Inverse hyperbolic cosine, element-wise. |
| arctanh(x, /[, out, where, casting, order, ...]) | Inverse hyperbolic tangent element-wise. |
| round(a[, decimals, out]) | Evenly round to the given number of decimals. |
| around(a[, decimals, out]) | Round an array to the given number of decimals. |
| rint(x, /[, out, where, casting, order, ...]) | Round elements of the array to the nearest integer. |
| fix(x[, out]) | Round to nearest integer towards zero. |
| floor(x, /[, out, where, casting, order, ...]) | Return the floor of the input, element-wise. |
| ceil(x, /[, out, where, casting, order, ...]) | Return the ceiling of the input, element-wise. |
| trunc(x, /[, out, where, casting, order, ...]) | Return the truncated value of the input, element-wise. |
| prod(a[, axis, dtype, out, keepdims, ...]) | Return the product of array elements over a given axis. |
| sum(a[, axis, dtype, out, keepdims, ...]) | Sum of array elements over a given axis. |
| nanprod(a[, axis, dtype, out, keepdims, ...]) | Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones. |
| nansum(a[, axis, dtype, out, keepdims, ...]) | Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero. |
| cumprod(a[, axis, dtype, out]) | Return the cumulative product of elements along a given axis. |
| cumsum(a[, axis, dtype, out]) | Return the cumulative sum of the elements along a given axis. |
| nancumprod(a[, axis, dtype, out]) | Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one. |
| nancumsum(a[, axis, dtype, out]) | Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero. |
| diff(a[, n, axis, prepend, append]) | Calculate the n-th discrete difference along the given axis. |
| ediff1d(ary[, to_end, to_begin]) | The differences between consecutive elements of an array. |
| gradient(f, *varargs[, axis, edge_order]) | Return the gradient of an N-dimensional array. |
| cross(a, b[, axisa, axisb, axisc, axis]) | Return the cross product of two (arrays of) vectors. |
| trapz(y[, x, dx, axis]) | Integrate along the given axis using the composite trapezoidal rule. |
| exp(x, /[, out, where, casting, order, ...]) | Calculate the exponential of all elements in the input array. |
| expm1(x, /[, out, where, casting, order, ...]) | Calculate exp(x) - 1 for all elements in the array. |
| exp2(x, /[, out, where, casting, order, ...]) | Calculate 2**p for all p in the input array. |
| log(x, /[, out, where, casting, order, ...]) | Natural logarithm, element-wise. |
| log10(x, /[, out, where, casting, order, ...]) | Return the base 10 logarithm of the input array, element-wise. |
| log2(x, /[, out, where, casting, order, ...]) | Base-2 logarithm of x. |
| log1p(x, /[, out, where, casting, order, ...]) | Return the natural logarithm of one plus the input array, element-wise. |
| logaddexp(x1, x2, /[, out, where, casting, ...]) | Logarithm of the sum of exponentiations of the inputs. |
| logaddexp2(x1, x2, /[, out, where, casting, ...]) | Logarithm of the sum of exponentiations of the inputs in base-2. |
| i0(x) | Modified Bessel function of the first kind, order 0. |
| sinc(x) | Return the normalized sinc function. |
| signbit(x, /[, out, where, casting, order, ...]) | Returns element-wise True where signbit is set (less than zero). |
| copysign(x1, x2, /[, out, where, casting, ...]) | Change the sign of x1 to that of x2, element-wise. |
| frexp(x[, out1, out2], / [[, out, where, ...]) | Decompose the elements of x into mantissa and twos exponent. |
| ldexp(x1, x2, /[, out, where, casting, ...]) | Returns x1 * 2**x2, element-wise. |
| nextafter(x1, x2, /[, out, where, casting, ...]) | Return the next floating-point value after x1 towards x2, element-wise. |
| spacing(x, /[, out, where, casting, order, ...]) | Return the distance between x and the nearest adjacent number. |
| lcm(x1, x2, /[, out, where, casting, order, ...]) | Returns the lowest common multiple of |x1| and |x2| |
| gcd(x1, x2, /[, out, where, casting, order, ...]) | Returns the greatest common divisor of |x1| and |x2| |
| add(x1, x2, /[, out, where, casting, order, ...]) | Add arguments element-wise. |
| reciprocal(x, /[, out, where, casting, ...]) | Return the reciprocal of the argument, element-wise. |
| positive(x, /[, out, where, casting, order, ...]) | Numerical positive, element-wise. |
| negative(x, /[, out, where, casting, order, ...]) | Numerical negative, element-wise. |
| multiply(x1, x2, /[, out, where, casting, ...]) | Multiply arguments element-wise. |
| divide(x1, x2, /[, out, where, casting, ...]) | Divide arguments element-wise. |
| power(x1, x2, /[, out, where, casting, ...]) | First array elements raised to powers from second array, element-wise. |
| subtract(x1, x2, /[, out, where, casting, ...]) | Subtract arguments, element-wise. |
| true_divide(x1, x2, /[, out, where, ...]) | Divide arguments element-wise. |
| floor_divide(x1, x2, /[, out, where, ...]) | Return the largest integer smaller or equal to the division of the inputs. |
| float_power(x1, x2, /[, out, where, ...]) | First array elements raised to powers from second array, element-wise. |
| fmod(x1, x2, /[, out, where, casting, ...]) | Returns the element-wise remainder of division. |
| mod(x1, x2, /[, out, where, casting, order, ...]) | Returns the element-wise remainder of division. |
| modf(x[, out1, out2], / [[, out, where, ...]) | Return the fractional and integral parts of an array, element-wise. |
| remainder(x1, x2, /[, out, where, casting, ...]) | Returns the element-wise remainder of division. |
| divmod(x1, x2[, out1, out2], / [[, out, ...]) | Return element-wise quotient and remainder simultaneously. |
| angle(z[, deg]) | Return the angle of the complex argument. |
| real(val) | Return the real part of the complex argument. |
| imag(val) | Return the imaginary part of the complex argument. |
| conj(x, /[, out, where, casting, order, ...]) | Return the complex conjugate, element-wise. |
| conjugate(x, /[, out, where, casting, ...]) | Return the complex conjugate, element-wise. |
| maximum(x1, x2, /[, out, where, casting, ...]) | Element-wise maximum of array elements. |
| max(a[, axis, out, keepdims, initial, where]) | Return the maximum of an array or maximum along an axis. |
| amax(a[, axis, out, keepdims, initial, where]) | Return the maximum of an array or maximum along an axis. |
| fmax(x1, x2, /[, out, where, casting, ...]) | Element-wise maximum of array elements. |
| nanmax(a[, axis, out, keepdims, initial, where]) | Return the maximum of an array or maximum along an axis, ignoring any NaNs. |
| minimum(x1, x2, /[, out, where, casting, ...]) | Element-wise minimum of array elements. |
| min(a[, axis, out, keepdims, initial, where]) | Return the minimum of an array or minimum along an axis. |
| amin(a[, axis, out, keepdims, initial, where]) | Return the minimum of an array or minimum along an axis. |
| fmin(x1, x2, /[, out, where, casting, ...]) | Element-wise minimum of array elements. |
| nanmin(a[, axis, out, keepdims, initial, where]) | Return minimum of an array or minimum along an axis, ignoring any NaNs. |
| convolve(a, v[, mode]) | Returns the discrete, linear convolution of two one-dimensional sequences. |
| clip(a, a_min, a_max[, out]) | Clip (limit) the values in an array. |
| sqrt(x, /[, out, where, casting, order, ...]) | Return the non-negative square-root of an array, element-wise. |
| cbrt(x, /[, out, where, casting, order, ...]) | Return the cube-root of an array, element-wise. |
| square(x, /[, out, where, casting, order, ...]) | Return the element-wise square of the input. |
| absolute(x, /[, out, where, casting, order, ...]) | Calculate the absolute value element-wise. |
| fabs(x, /[, out, where, casting, order, ...]) | Compute the absolute values element-wise. |
| sign(x, /[, out, where, casting, order, ...]) | Returns an element-wise indication of the sign of a number. |
| heaviside(x1, x2, /[, out, where, casting, ...]) | Compute the Heaviside step function. |
| nan_to_num(x[, copy, nan, posinf, neginf]) | Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the nan, posinf and/or neginf keywords. |
| real_if_close(a[, tol]) | If input is complex with all imaginary parts close to zero, return real parts. |
| interp(x, xp, fp[, left, right, period]) | One-dimensional linear interpolation for monotonically increasing sample points. |