Tessero\Ext\Math · TesseroPHP

negative static

negative($x, ?Tessero\Ext\NDArray $out = …)

-x

absolute static

absolute($x, ?Tessero\Ext\NDArray $out = …)

|x| (modulus for complex)

abs static

abs($x, ?Tessero\Ext\NDArray $out = …)

alias of absolute

square static

square($x, ?Tessero\Ext\NDArray $out = …)

x * x

sign static

sign($x, ?Tessero\Ext\NDArray $out = …)

-1, 0 or 1

sqrt static

sqrt($x, ?Tessero\Ext\NDArray $out = …)

square root

exp static

exp($x, ?Tessero\Ext\NDArray $out = …)

e^x

expm1 static

expm1($x, ?Tessero\Ext\NDArray $out = …)

e^x - 1, accurate near 0

log static

log($x, ?Tessero\Ext\NDArray $out = …)

natural logarithm

log10 static

log10($x, ?Tessero\Ext\NDArray $out = …)

base-10 logarithm

log2 static

log2($x, ?Tessero\Ext\NDArray $out = …)

base-2 logarithm

log1p static

log1p($x, ?Tessero\Ext\NDArray $out = …)

log(1 + x), accurate near 0

sin static

sin($x, ?Tessero\Ext\NDArray $out = …)

sine (radians)

cos static

cos($x, ?Tessero\Ext\NDArray $out = …)

cosine (radians)

tan static

tan($x, ?Tessero\Ext\NDArray $out = …)

tangent (radians)

arcsin static

arcsin($x, ?Tessero\Ext\NDArray $out = …)

inverse sine

arccos static

arccos($x, ?Tessero\Ext\NDArray $out = …)

inverse cosine

arctan static

arctan($x, ?Tessero\Ext\NDArray $out = …)

inverse tangent

sinh static

sinh($x, ?Tessero\Ext\NDArray $out = …)

hyperbolic sine

cosh static

cosh($x, ?Tessero\Ext\NDArray $out = …)

hyperbolic cosine

tanh static

tanh($x, ?Tessero\Ext\NDArray $out = …)

hyperbolic tangent

floor static

floor($x, ?Tessero\Ext\NDArray $out = …)

round down

ceil static

ceil($x, ?Tessero\Ext\NDArray $out = …)

round up

rint static

rint($x, ?Tessero\Ext\NDArray $out = …)

round to nearest, ties to even

reciprocal static

reciprocal($x, ?Tessero\Ext\NDArray $out = …)

1 / x

isnan static

isnan($x, ?Tessero\Ext\NDArray $out = …)

x is NaN (bool)

isinf static

isinf($x, ?Tessero\Ext\NDArray $out = …)

x is +/-INF (bool)

isfinite static

isfinite($x, ?Tessero\Ext\NDArray $out = …)

x is finite (bool)

invert static

invert($x, ?Tessero\Ext\NDArray $out = …)

bitwise NOT (logical NOT for bool)

real static

real($x, ?Tessero\Ext\NDArray $out = …)

real part

imag static

imag($x, ?Tessero\Ext\NDArray $out = …)

imaginary part

conj static

conj($x, ?Tessero\Ext\NDArray $out = …)

complex conjugate

angle static

angle($x, ?Tessero\Ext\NDArray $out = …)

argument of a complex number

add static

add($x, $y, ?Tessero\Ext\NDArray $out = …)

x + y

subtract static

subtract($x, $y, ?Tessero\Ext\NDArray $out = …)

x - y

multiply static

multiply($x, $y, ?Tessero\Ext\NDArray $out = …)

x * y

divide static

divide($x, $y, ?Tessero\Ext\NDArray $out = …)

x / y (true division)

power static

power($x, $y, ?Tessero\Ext\NDArray $out = …)

x ** y

mod static

mod($x, $y, ?Tessero\Ext\NDArray $out = …)

remainder with the sign of y (Python %)

remainder static

remainder($x, $y, ?Tessero\Ext\NDArray $out = …)

alias of mod

floorDivide static

floorDivide($x, $y, ?Tessero\Ext\NDArray $out = …)

floor(x / y)

maximum static

maximum($x, $y, ?Tessero\Ext\NDArray $out = …)

element-wise maximum, NaN propagates

minimum static

minimum($x, $y, ?Tessero\Ext\NDArray $out = …)

element-wise minimum, NaN propagates

arctan2 static

arctan2($x, $y, ?Tessero\Ext\NDArray $out = …)

angle of (x=y2, y=x1): atan2(x1, x2)

hypot static

hypot($x, $y, ?Tessero\Ext\NDArray $out = …)

sqrt(x^2 + y^2) without overflow

equal static

equal($x, $y, ?Tessero\Ext\NDArray $out = …)

x == y (bool)

notEqual static

notEqual($x, $y, ?Tessero\Ext\NDArray $out = …)

x != y (bool)

less static

less($x, $y, ?Tessero\Ext\NDArray $out = …)

x < y (bool)

lessEqual static

lessEqual($x, $y, ?Tessero\Ext\NDArray $out = …)

x <= y (bool)

greater static

greater($x, $y, ?Tessero\Ext\NDArray $out = …)

x > y (bool)

greaterEqual static

greaterEqual($x, $y, ?Tessero\Ext\NDArray $out = …)

x >= y (bool)

logicalAnd static

logicalAnd($x, $y, ?Tessero\Ext\NDArray $out = …)

x AND y (bool)

logicalOr static

logicalOr($x, $y, ?Tessero\Ext\NDArray $out = …)

x OR y (bool)

logicalXor static

logicalXor($x, $y, ?Tessero\Ext\NDArray $out = …)

x XOR y (bool)

cbrt static

cbrt($x, ?Tessero\Ext\NDArray $out = …)

cube root

exp2 static

exp2($x, ?Tessero\Ext\NDArray $out = …)

2^x

trunc static

trunc($x, ?Tessero\Ext\NDArray $out = …)

round towards zero

arcsinh static

arcsinh($x, ?Tessero\Ext\NDArray $out = …)

inverse hyperbolic sine

arccosh static

arccosh($x, ?Tessero\Ext\NDArray $out = …)

inverse hyperbolic cosine

arctanh static

arctanh($x, ?Tessero\Ext\NDArray $out = …)

inverse hyperbolic tangent

degrees static

degrees($x, ?Tessero\Ext\NDArray $out = …)

radians to degrees

radians static

radians($x, ?Tessero\Ext\NDArray $out = …)

degrees to radians

erf static

erf($x, ?Tessero\Ext\NDArray $out = …)

error function (scipy.special.erf)

erfc static

erfc($x, ?Tessero\Ext\NDArray $out = …)

complementary error function

gamma static

gamma($x, ?Tessero\Ext\NDArray $out = …)

gamma function (scipy.special.gamma)

lgamma static

lgamma($x, ?Tessero\Ext\NDArray $out = …)

log|gamma(x)| (scipy.special.gammaln)

signbit static

signbit($x, ?Tessero\Ext\NDArray $out = …)

sign bit is set (bool; true for -0.0)

fmax static

fmax($x, $y, ?Tessero\Ext\NDArray $out = …)

maximum ignoring NaN

fmin static

fmin($x, $y, ?Tessero\Ext\NDArray $out = …)

minimum ignoring NaN

copysign static

copysign($x, $y, ?Tessero\Ext\NDArray $out = …)

magnitude of x with the sign of y

nextafter static

nextafter($x, $y, ?Tessero\Ext\NDArray $out = …)

next representable value after x towards y

heaviside static

heaviside($x, $y, ?Tessero\Ext\NDArray $out = …)

0 if x1<0, x2 if x1==0, 1 if x1>0 (numpy.heaviside)

logaddexp static

logaddexp($x, $y, ?Tessero\Ext\NDArray $out = …)

log(e^x + e^y) without overflow

logaddexp2 static

logaddexp2($x, $y, ?Tessero\Ext\NDArray $out = …)

log2(2^x + 2^y) without overflow

fmod static

fmod($x, $y, ?Tessero\Ext\NDArray $out = …)

C remainder with the sign of x (numpy.fmod); integer x % 0 gives 0

gcd static

gcd($x, $y, ?Tessero\Ext\NDArray $out = …)

greatest common divisor (numpy.gcd; integer inputs only)

lcm static

lcm($x, $y, ?Tessero\Ext\NDArray $out = …)

least common multiple (numpy.lcm; integer inputs only)

floatPower static

floatPower($x, $y, ?Tessero\Ext\NDArray $out = …)

x1**x2 computed in float64 (numpy.float_power)

ufuncs static

ufuncs()

apply static

apply(string $name, $x, $y = …, ?Tessero\Ext\NDArray $out = …)

Build this with Claude Code, Cursor or Copilot