Skip to content

module numpy.ndmath

module `numpy.ndmath`¶

Source: stdlib/numpy/ndmath.codon

`cumprod(a, axis = None, dtype: type = NoneType, out = None)`¶

`cumsum(a, axis = None, dtype: type = NoneType, out = None)`¶

`diff(a, axis: int = -1, n: int = 1, append = None, prepend = None)`¶

**`gradient(f, *varargs, axis = None, edge_order: int = 1)`**¶

`ediff1d(ary, to_begin = None, to_end = None)`¶

`cross(a, b, axisa: int = -1, axisb: int = -1, axisc: int = -1, axis = None)`¶

`trapz(y, x = None, dx = 1.0, axis: int = -1)`¶

`convolve(v, a, mode: str = "full")`¶

`add` = `BinaryUFunc(operator.add, "add", 0)`¶

`subtract` = `BinaryUFunc(operator.sub, "subtract")`¶

`multiply` = `BinaryUFunc(operator.mul, "multiply", 1)`¶

`divide` = `BinaryUFunc(operator.truediv, "divide")`¶

`true_divide` = `divide`¶

`logaddexp` = `BinaryUFunc(_logaddexp, "logaddexp")`¶

`logaddexp2` = `BinaryUFunc(_logaddexp2, "logaddexp2")`¶

`floor_divide` = `BinaryUFunc(_floor_divide, "floor_divide")`¶

`negative` = `UnaryUFunc(operator.neg, "negative")`¶

`positive` = `UnaryUFunc(operator.pos, "positive")`¶

`power` = `BinaryUFunc(operator.pow, "power")`¶

`remainder` = `BinaryUFunc(_remainder, "remainder")`¶

`mod` = `remainder`¶

`fmod` = `BinaryUFunc(_fmod, "fmod")`¶

`absolute` = `UnaryUFunc(operator.abs, "absolute")`¶

`abs` = `absolute`¶

`fabs` = `UnaryUFunc(_fabs, "fabs")`¶

`rint` = `UnaryUFunc(_rint, "rint")`¶

`sign` = `UnaryUFunc(_sign, "sign")`¶

`heaviside` = `BinaryUFunc(_heaviside, "heaviside")`¶

`conjugate` = `UnaryUFunc(_conj, "conjugate")`¶

`conj` = `conjugate`¶

`exp` = `UnaryUFunc(_exp, "exp")`¶

`exp2` = `UnaryUFunc(_exp2, "exp2")`¶

`log` = `UnaryUFunc(_log, "log")`¶

`log2` = `UnaryUFunc(_log2, "log2")`¶

`log10` = `UnaryUFunc(_log10, "log10")`¶

`expm1` = `UnaryUFunc(_expm1, "expm1")`¶

`log1p` = `UnaryUFunc(_log1p, "log1p")`¶

`sqrt` = `UnaryUFunc(_sqrt, "sqrt")`¶

`square` = `UnaryUFunc(_square, "square")`¶

`cbrt` = `UnaryUFunc(_cbrt, "cbrt")`¶

`reciprocal` = `UnaryUFunc(_reciprocal, "reciprocal")`¶

`gcd` = `BinaryUFunc(_gcd, "gcd", 0)`¶

`lcm` = `BinaryUFunc(_lcm, "lcm")`¶

`sin` = `UnaryUFunc(_sin, "sin")`¶

`cos` = `UnaryUFunc(_cos, "cos")`¶

`tan` = `UnaryUFunc(_tan, "tan")`¶

`arcsin` = `UnaryUFunc(_arcsin, "arcsin")`¶

`arccos` = `UnaryUFunc(_arccos, "arccos")`¶

`arctan` = `UnaryUFunc(_arctan, "arctan")`¶

`arctan2` = `BinaryUFunc(_arctan2, "arctan2")`¶

`hypot` = `BinaryUFunc(_hypot, "hypot")`¶

`sinh` = `UnaryUFunc(_sinh, "sinh")`¶

`cosh` = `UnaryUFunc(_cosh, "cosh")`¶

`tanh` = `UnaryUFunc(_tanh, "tanh")`¶

`arcsinh` = `UnaryUFunc(_arcsinh, "arcsinh")`¶

`arccosh` = `UnaryUFunc(_arccosh, "arccosh")`¶

`arctanh` = `UnaryUFunc(_arctanh, "arctanh")`¶

`deg2rad` = `UnaryUFunc(_deg2rad, "deg2rad")`¶

`radians` = `UnaryUFunc(_deg2rad, "radians")`¶

`rad2deg` = `UnaryUFunc(_rad2deg, "rad2deg")`¶

`degrees` = `UnaryUFunc(_rad2deg, "degrees")`¶

`bitwise_and` = `BinaryUFunc(operator.and_, "bitwise_and")`¶

`bitwise_or` = `BinaryUFunc(operator.or_, "bitwise_or")`¶

`bitwise_xor` = `BinaryUFunc(operator.xor, "bitwise_xor")`¶

`invert` = `UnaryUFunc(operator.invert, "invert")`¶

`left_shift` = `BinaryUFunc(operator.lshift, "left_shift")`¶

`right_shift` = `BinaryUFunc(operator.rshift, "right_shift")`¶

`greater` = `BinaryUFunc(operator.gt, "greater")`¶

`greater_equal` = `BinaryUFunc(operator.ge, "greater_equal")`¶

`less` = `BinaryUFunc(operator.lt, "less")`¶

`less_equal` = `BinaryUFunc(operator.le, "less_equal")`¶

`not_equal` = `BinaryUFunc(operator.ne, "not_equal")`¶

`equal` = `BinaryUFunc(operator.eq, "equal")`¶

`logical_and` = `BinaryUFunc(_logical_and, "logical_and")`¶

`logical_or` = `BinaryUFunc(_logical_or, "logical_or")`¶

`logical_xor` = `BinaryUFunc(_logical_xor, "logical_xor")`¶

`logical_not` = `UnaryUFunc(_logical_not, "logical_not")`¶

`maximum` = `BinaryUFunc(_maximum, "maximum")`¶

`minimum` = `BinaryUFunc(_minimum, "minimum")`¶

`fmax` = `BinaryUFunc(_fmax, "fmax")`¶

`fmin` = `BinaryUFunc(_fmin, "fmin")`¶

`isfinite` = `UnaryUFunc(_isfinite, "isfinite")`¶

`isinf` = `UnaryUFunc(_isinf, "isinf")`¶

`isnan` = `UnaryUFunc(_isnan, "isnan")`¶

`isnat` = `UnaryUFunc(_isnat, "isnat")`¶

`signbit` = `UnaryUFunc(_signbit, "signbit")`¶

`copysign` = `BinaryUFunc(_copysign, "copysign")`¶

`nextafter` = `BinaryUFunc(_nextafter, "nextafter")`¶

`spacing` = `UnaryUFunc(_spacing, "spacing")`¶

`modf` = `UnaryUFunc2(_modf, "modf")`¶

`ldexp` = `BinaryUFunc(_ldexp, "ldexp")`¶

`frexp` = `UnaryUFunc2(_frexp, "frexp")`¶

`floor` = `UnaryUFunc(_floor, "floor")`¶

`ceil` = `UnaryUFunc(_ceil, "ceil")`¶

`trunc` = `UnaryUFunc(_trunc, "trunc")`¶

`i0(x)`¶

`sinc(x)`¶

`nancumprod(a, axis = None, dtype: type = NoneType, out = None)`¶

`nancumsum(a, axis = None, dtype: type = NoneType, out = None)`¶

`ndarray[dtype,ndim]` @extend Class is extended to add given methods ¶

Methods¶

`cumprod(self, axis = None, dtype: type = NoneType, out = None)`¶

`cumsum(self, axis = None, dtype: type = NoneType, out = None)`¶