fastmath.core — generateme/fastmath 2.4.0

Collection of fast math functions and plethora of constants known from other math libraries.

Primitive math operators

Based on Primitive Math by Zach Tellman several operators are introduced and replace clojure.core functions. All operators are macros and can't be used as functions. List includes:

Known from Clojure: * + - / > < >= <= == rem quot mod bit-or bit-and bit-xor bit-and-not bit-set bit-clear bit-test bit-flip bit-not bit-shift-left bit-shift-right unsigned-bit-shift-right inc dec zero? neg? pos? min max even? odd? abs

And additionally:

• << - bit shift left
• >> - signed bit shift right
• >>> - unsigned bit shift right
• not== - not equal

Warning: All bool- evaluate all parameters.

To turn on primitive math on your namespace call use-primitive-operators. To turn off and revert original versions call unuse-primitive-operators

Fast Math

Almost all math functions are backed by FastMath library. Most of them are macros. Some of them are wrapped in Clojure functions. Almost all operates on primitive double and returns double (with an exception round or qround which returns long).

Other functions

Additionally namespace contains functions which are common in frameworks like OpenFrameworks and Processing.

* clj macro

(* x)

(* x y)

(* x y & rest)

A primitive math version of *

+ clj macro

(+ x)

(+ x y)

(+ x y & rest)

A primitive math version of +

- clj macro

(- x)

(- x y)

(- x y & rest)

A primitive math version of -

-E clj

Value of \(-e\)

-HALF_PI clj

Value of \(-\frac{\pi}{2}\)

-PI clj

Value of \(-\pi\)

-QUARTER_PI clj

Value of \(-\frac{\pi}{4}\)

-TAU clj

Alias for [[TWO_PI-]]

-THIRD_PI clj

Value of \(-\frac{\pi}{3}\)

-TWO_PI clj

Value of \(-2 {\pi}\)

/ clj macro

(/ x)

(/ x y)

(/ x y & rest)

A primitive math version of /

< clj macro

(< x)

(< x y)

(< x y & rest)

A primitive math version of <

<< clj macro

(<< x y)

fastmath.java.PrimitiveMath/shiftLeft function wrapped in macro.

<= clj macro

(<= x)

(<= x y)

(<= x y & rest)

A primitive math version of <=

== clj macro

(== x)

(== x y)

(== x y & rest)

Equality. See also eq for function version.

> clj macro

(> x)

(> x y)

(> x y & rest)

A primitive math version of >

>= clj macro

(>= x)

(>= x y)

(>= x y & rest)

A primitive math version of >=

>> clj macro

(>> x y)

fastmath.java.PrimitiveMath/shiftRight function wrapped in macro.

>>> clj macro

(>>> x y)

fastmath.java.PrimitiveMath/unsignedShiftRight function wrapped in macro.

abs clj

(abs x)

\(|x|\) - double version. See iabs.

acos clj macro

(acos x)

net.jafama.FastMath/acos function wrapped in macro.

acosh clj macro

(acosh x)

net.jafama.FastMath/acosh function wrapped in macro.

acot clj

(acot v)

Arccotangent

acoth clj

(acoth v)

Area hyperbolic cotangent

acovercos clj

(acovercos v)

Arc covercosine

acoversin clj

(acoversin v)

Arc coversine

acrd clj

(acrd v)

Inverse chord

acsc clj

(acsc v)

Arcosecant

acsch clj

(acsch v)

Area hyperbolic cosecant

aexcsc clj

(aexcsc v)

Arc excosecant

aexsec clj

(aexsec v)

Arc exsecant

ahacovercos clj

(ahacovercos v)

Arc hacovercosine

ahacoversin clj

(ahacoversin v)

Arc hacoversine

ahavercos clj

(ahavercos v)

Arc havecosine

ahaversin clj

(ahaversin v)

Arc haversine

approx clj

(approx v)

(approx v digits)

Round v to specified (default: 2) decimal places. Be aware of double number accuracy.

approx-eq clj

(approx-eq a b)

(approx-eq a b digits)

Checks equality approximately. See approx.

approx= clj

Alias for approx-eq

asec clj

(asec v)

Arcsecant

asech clj

(asech v)

Area hyperbolic secant

asin clj macro

(asin x)

net.jafama.FastMath/asin function wrapped in macro.

asinh clj macro

(asinh x)

net.jafama.FastMath/asinh function wrapped in macro.

atan clj macro

(atan x)

net.jafama.FastMath/atan function wrapped in macro.

atan2 clj macro

(atan2 x y)

net.jafama.FastMath/atan2 function wrapped in macro.

atanh clj macro

(atanh x)

net.jafama.FastMath/atanh function wrapped in macro.

avercos clj

(avercos v)

Arc vecosine

aversin clj

(aversin v)

Arc versine

bessel-j clj macro

(bessel-j x y)

Bessel J function value for given order and argument.

between-? clj

(between-? [x y] v)

(between-? x y v)

Check if given number is within the range (x,y].

between? clj

(between? [x y] v)

(between? x y v)

Check if given number is within the range [x,y].

bit-and clj macro

(bit-and x)

(bit-and x y)

(bit-and x y & rest)

A primitive math version of bit-and

bit-and-not clj macro

(bit-and-not x)

(bit-and-not x y)

(bit-and-not x y & rest)

A primitive math version of bit-and-not

bit-clear clj macro

(bit-clear x y)

fastmath.java.PrimitiveMath/bitClear function wrapped in macro.

bit-flip clj macro

(bit-flip x y)

fastmath.java.PrimitiveMath/bitFlip function wrapped in macro.

bit-nand clj macro

(bit-nand x)

(bit-nand x y)

(bit-nand x y & rest)

A primitive math version of bit-nand

bit-nor clj macro

(bit-nor x)

(bit-nor x y)

(bit-nor x y & rest)

A primitive math version of bit-nor

bit-not clj macro

(bit-not x)

fastmath.java.PrimitiveMath/bitNot function wrapped in macro.

bit-or clj macro

(bit-or x)

(bit-or x y)

(bit-or x y & rest)

A primitive math version of bit-or

bit-set clj macro

(bit-set x y)

fastmath.java.PrimitiveMath/bitSet function wrapped in macro.

bit-shift-left clj macro

(bit-shift-left x y)

fastmath.java.PrimitiveMath/shiftLeft function wrapped in macro.

bit-shift-right clj macro

(bit-shift-right x y)

fastmath.java.PrimitiveMath/shiftRight function wrapped in macro.

bit-test clj macro

(bit-test x y)

fastmath.java.PrimitiveMath/bitTest function wrapped in macro.

bit-xor clj macro

(bit-xor x)

(bit-xor x y)

(bit-xor x y & rest)

A primitive math version of bit-xor

bits->double clj

(bits->double v)

Convert 64 bits to double

bool-and clj macro deprecated

(bool-and x)

(bool-and x y)

(bool-and x y & rest)

A primitive math version of bool-and

bool-not clj macro

(bool-not x)

fastmath.java.PrimitiveMath/not function wrapped in macro.

bool-or clj macro deprecated

(bool-or x)

(bool-or x y)

(bool-or x y & rest)

A primitive math version of bool-or

bool-xor clj macro deprecated

(bool-xor x)

(bool-xor x y)

(bool-xor x y & rest)

A primitive math version of bool-xor

CATALAN_G clj

Catalan G

cb clj

(cb x)

\(x^3\)

cbrt clj macro

(cbrt x)

\(\sqrt[3]{x}\)

ceil clj

(ceil x)

(ceil x scale)

\(\lceil x \rceil\). See: qceil.

Rounding is done to a multiply of scale value (when provided).

cexpexp clj

(cexpexp x)

1-exp(-exp(x))

Ci clj

(Ci x)

Negative of integral of cos(t)/t from x to inf

cloglog clj

(cloglog x)

log(-log(1-x))

cnorm clj

(cnorm v start stop)

(cnorm v start1 stop1 start2 stop2)

Constrained version of norm. Result of norm is applied to constrain to [0,1] or [start2,stop2] ranges.

co-intervals clj

(co-intervals data)

(co-intervals data number)

(co-intervals data number overlap)

Divide sequence to overlaping intervals containing similar number of values. Same as R's co.intervals()

combinations clj

(combinations n k)

Binomial coefficient (n choose k)

constrain clj macro

(constrain value mn mx)

Clamp value to the range [mn,mx].

copy-sign clj macro

(copy-sign x y)

Returns a value with a magnitude of first argument and sign of second.

cos clj macro

(cos x)

net.jafama.FastMath/cos function wrapped in macro.

cos-interpolation clj

(cos-interpolation start stop t)

oF interpolateCosine interpolation. See also lerp/mlerp, quad-interpolation or smooth-interpolation.

cosh clj macro

(cosh x)

net.jafama.FastMath/cosh function wrapped in macro.

cot clj

(cot v)

Cotangent

coth clj

(coth v)

Hyperbolic cotangent

covercos clj

(covercos v)

Covercosine

coversin clj

(coversin v)

Coversine

crd clj

(crd v)

Chord

csc clj

(csc v)

Cosecant

csch clj

(csch v)

Hyperbilic cosecant

cut clj

(cut data breaks)

(cut x1 x2 breaks)

Cut range or sequence into intervals

dec clj macro

(dec x)

fastmath.java.PrimitiveMath/dec function wrapped in macro.

deg-in-rad clj

\(\frac{\pi}{180}\)

degrees clj

(degrees rad)

Convert radians into degrees.

delta-eq clj

(delta-eq a b)

(delta-eq a b accuracy)

(delta-eq a b abs-tol rel-tol)

Checks equality for given absolute accuracy (default 1.0e-6).

Version with 4-arity accepts absolute and relative accuracy.

delta= clj

Alias for delta-eq

difference-of-products clj

(difference-of-products a b c d)

Kahan's algorithm for (ab)-(cd) to avoid catastrophic cancellation.

digamma clj macro

(digamma x)

Logarithmic derivative of \(\Gamma\).

dist clj

(dist [x1 y1] [x2 y2])

(dist x1 y1 x2 y2)

Euclidean distance between points (x1,y1) and (x2,y2). See fastmath.vector namespace to see other metrics which work on vectors.

double-array->seq clj

Convert double array into sequence.

Alias for seq.

double-array-type clj

double-bits clj

(double-bits v)

Returns double as 64-bits (long)

double-double-array->seq clj

(double-double-array->seq res)

Convert double array of double arrays into sequence of sequences.

double-double-array-type clj

double-exponent clj

(double-exponent v)

Extract exponent information from double

double-high-bits clj

(double-high-bits v)

Returns high word from double as bits

double-low-bits clj

(double-low-bits v)

Returns low word from double as bits

double-one-minus-epsilon clj

Value of 0x1.fffffffffffffp-1d = 0.(9)

double-significand clj

(double-significand v)

Extract significand from double

E clj

Value of \(e\)

EPSILON clj

Very small number \(\varepsilon\)

eq clj

(eq _)

(eq a b)

(eq a b c)

(eq a b c d)

Primitive math equality function for doubles. See ==.

erf clj macro

(erf x)

(erf x y)

Error function. For two arguments return difference between (erf x) and (erf y).

erfc clj macro

(erfc x)

Complementary error function.

evalpoly clj

(evalpoly x & coeffs)

Evaluate polynomial

even? clj macro

(even? x)

fastmath.java.PrimitiveMath/isEven function wrapped in macro.

excsc clj

(excsc v)

Excosecant

exp clj macro

(exp x)

net.jafama.FastMath/exp function wrapped in macro.

expm1 clj macro

(expm1 x)

net.jafama.FastMath/expm1 function wrapped in macro.

exsec clj

(exsec v)

Exsecant

factorial clj

(factorial n)

Factorial

factorial20 clj

(factorial20 n)

Factorial table up to 20!

fast* clj

(fast* a b)

Primitive * for two doubles as function.

fast+ clj

(fast+ a b)

Primitive + for two doubles as function.

fast- clj

(fast- a b)

Primitive - for two doubles as function.

fast-identity clj

(fast-identity a)

Identity on double.

fast-max clj

(fast-max a b)

Primitive max for two doubles as function.

fast-min clj

(fast-min a b)

Primitive min for two doubles as function

floor clj

(floor x)

(floor x scale)

\(\lfloor x \rfloor\). See: qfloor.

Rounding is done to a multiply of scale value (when provided).

fma clj macro

(fma x y z)

[x y z] -> (+ z (* x y)) or Math/fma for java 9+

FOUR_INV_PI clj

Value of \(\frac{4}{\pi}\)

fpow clj macro

(fpow x y)

Fast version of pow where exponent is integer.

frac clj

(frac v)

Fractional part, always returns values from 0.0 to 1.0 (exclusive). See sfrac for signed version.

gamma clj macro

(gamma x)

Gamma function \(\Gamma(x)\)

GAMMA clj

Euler-Mascheroni constant

gcd clj

(gcd a b)

Fast binary greatest common divisor (Stein's algorithm)

group-by-intervals clj

(group-by-intervals coll)

(group-by-intervals intervals coll)

Group sequence of values into given intervals.

If intervals are missing, use co-intervals to find some.

hacovercos clj

(hacovercos v)

Hacovercosine

hacoversin clj

(hacoversin v)

Hacoversine

HALF_PI clj

Value of \(\frac{\pi}{2}\)

havercos clj

(havercos v)

Havercosine

haversin clj

(haversin v)

(haversin [lat1 lon1] [lat2 lon2])

(haversin lat1 lon1 lat2 lon2)

Haversine formula for value or lattitude and longitude pairs.

haversine clj

Haversine (haversin alias)

haversine-dist clj

(haversine-dist [lat1 lon1] [lat2 lon2])

(haversine-dist lat1 lon1 lat2 lon2)

Haversine distance d for r=1

high-2-exp clj

(high-2-exp v)

Find lowest exponent (power of 2) which is greater or equal x. See low-2-exp.

high-exp clj

(high-exp b x)

Find lowest exponent for base b which is higher or equalx. See also low-exp.

hypot clj

(hypot x y)

(hypot x y z)

Hypot. See also hypot-sqrt.

hypot-sqrt clj

(hypot-sqrt x y)

(hypot-sqrt x y z)

Hypot, sqrt version: \(\sqrt{x^2+y^2}\) or \(\sqrt{x^2+y^2+z^2}\). Should be faster than hypot.

I0 clj

(I0 x)

Modified Bessel function of the first kind, order 0.

iabs clj

(iabs x)

\(|x|\) - long version. See abs.

inc clj macro

(inc x)

fastmath.java.PrimitiveMath/inc function wrapped in macro.

inf? clj

(inf? v)

Check if number is infinite

inv-erf clj macro

(inv-erf x)

Inverse erf.

inv-erfc clj macro

(inv-erfc x)

Inverse erfc.

inv-factorial clj

(inv-factorial n)

Inverse of factorial, 1/n!

inv-gamma-1pm1 clj macro

(inv-gamma-1pm1 x)

\(\frac{1}{\Gamma(1+x)}-1\).

INV_FOUR_PI clj

Value of \(\frac{1}{4 \pi}\)

INV_LN2 clj

\(\frac{1}{\ln{2}}\)

INV_LOG_HALF clj

\(\frac{1}{\ln{0.5}}\)

INV_PI clj

Value of \(\frac{1}{\pi}\)

INV_SQRT2PI clj

\(\frac{1}{\sqrt\pi}\)

INV_SQRT_2 clj

\(\frac{1}{\sqrt{2}}\)

INV_TWO_PI clj

Value of \(\frac{1}{2 \pi}\)

invalid-double? clj

(invalid-double? v)

Check if number is invalid

itrunc clj

(itrunc v)

Truncate fractional part, keep sign. Returns long.

jinc clj

(jinc x)

Besselj1 devided by x

jvm-version clj

LANCZOS_G clj

Lanchos approximation g constant

lcm clj

(lcm a b)

Fast binary least common multiplier.

lerp clj

(lerp start stop t)

Linear interpolation between start and stop for amount t. See also mlerp, cos-interpolation, quad-interpolation or smooth-interpolation.

ln clj macro

(ln x)

net.jafama.FastMath/log function wrapped in macro.

LN10 clj

\(\ln{10}\)

LN2 clj

\(\ln{2}\)

LN2_2 clj

\(\frac{\ln{2}}{2}\)

log clj macro

(log x)

net.jafama.FastMath/log function wrapped in macro.

log-beta clj macro

(log-beta x y)

Logarithm of Beta function.

log-combinations clj

(log-combinations n k)

Log of binomial coefficient (n choose k)

log-factorial clj

(log-factorial x)

Log factorial, alias to log-gamma

log-gamma clj macro

(log-gamma x)

Log of Gamma function \(\ln\Gamma(x)\)

log-gamma-1p clj macro

(log-gamma-1p x)

Log of Gamma function \(\ln\Gamma(1+x)\)

log-I0 clj

(log-I0 x)

Log of I0.

log10 clj macro

(log10 x)

\(\ln_{10}{x}\)

LOG10E clj

\(\log_{10}{e}\)

log1mexp clj

(log1mexp x)

log(1-exp(x))

log1p clj macro

(log1p x)

net.jafama.FastMath/log1p function wrapped in macro.

log1pexp clj

(log1pexp x)

log(1+exp(x))

log1pmx clj

(log1pmx x)

log(1+x)-x

log1psq clj

(log1psq x)

log(1+x^2))

log2 clj

(log2 x)

Logarithm with base 2.

\(\ln_2{x}\)

LOG2E clj

\(\log_{2}{e}\)

log2int clj

(log2int v)

Fast and integer version of log2, returns long

log2mexp clj

(log2mexp x)

log(2-exp(x))

LOG_HALF clj

\(\ln{0.5}\)

LOG_PI clj

\(\ln{\pi}\)

LOG_TWO_PI clj

\(\ln{2 \pi}\)

logaddexp clj

(logaddexp x y)

log(exp(x)+exp(y))

logb clj

(logb b x)

Logarithm with base b.

\(\ln_b{x}\)

logcosh clj

(logcosh x)

log(cosh(x))

logexpm1 clj

(logexpm1 x)

log(exp(x)-1))

logistic clj

Alias for sigmoid

logit clj

(logit x)

Logit function

logmxp1 clj

(logmxp1 x)

log(x)-x+1

logsubexp clj

(logsubexp x y)

log(abs(exp(x)-exp(y)))

logsumexp clj

(logsumexp xs)

log(exp(x1)+...+exp(xn))

low-2-exp clj

(low-2-exp x)

Find greatest exponent (power of 2) which is lower or equal x. See high-2-exp.

low-exp clj

(low-exp b x)

Find greatest exponent for base b which is lower or equal x. See also high-exp.

M_1_PI clj

\(\frac{1}{\pi}\)

M_2_PI clj

\(\frac{2}{\pi}\)

M_2_SQRTPI clj

\(\frac{2}{\sqrt\pi}\)

M_3PI_4 clj

\(\frac{3\pi}{4}\)

M_E clj

\(e\)

M_INVLN2 clj

\(\frac{1}{\ln{2}}\)

M_IVLN10 clj

\(\frac{1}{\ln{10}}\)

M_LN10 clj

\(\ln{10}\)

M_LN2 clj

\(\ln{2}\)

M_LOG10E clj

\(\log_{10}{e}\)

M_LOG2_E clj

\(\ln{2}\)

M_LOG2E clj

\(\log_{2}{e}\)

M_PI clj

\(\pi\)

M_PI_2 clj

\(\frac{\pi}{2}\)

M_PI_4 clj

\(\frac{\pi}{4}\)

M_SQRT1_2 clj

\(\frac{1}{\sqrt{2}}\)

M_SQRT2 clj

\(\sqrt{2}\)

M_SQRT3 clj

\(\sqrt{3}\)

M_SQRT_PI clj

\(\sqrt\pi\)

M_TWOPI clj

\(2\pi\)

MACHINE-EPSILON clj

Smallest machine number. Value is calculated during evaluation and may differ on different processors.

make-norm clj

(make-norm start stop)

(make-norm start stop dstart dstop)

Make norm function for given range. Resulting function accepts double value (with optional target [dstart,dstop] range) and returns double.

makepoly clj

(makepoly coeffs)

Create polynomial function for given coefficients

max clj macro

(max x)

(max x y)

(max x y & rest)

A primitive math version of max

mevalpoly clj macro

(mevalpoly x & coeffs)

Evaluate polynomial macro version in the form coeffs[0]+coeffs[1]*x+coeffs[2]*x^2+....

min clj macro

(min x)

(min x y)

(min x y & rest)

A primitive math version of min

minkowski clj

(minkowski x)

Minkowski's question mark function ?(x)

mlerp clj macro

(mlerp start stop t)

lerp as macro. For inline code. See also lerp, cos-interpolation, quad-interpolation or smooth-interpolation.

mnorm clj macro

(mnorm v start stop)

(mnorm v start1 stop1 start2 stop2)

Macro version of norm.

mod clj macro

(mod x y)

fastmath.java.PrimitiveMath/modulus function wrapped in macro.

muladd clj macro

(muladd x y z)

[x y z] -> (+ z (* x y)) or Math/fma for java 9+

nan? clj

(nan? v)

Check if number is NaN

near-zero? clj

(near-zero? x)

(near-zero? x abs-tol)

(near-zero? x abs-tol rel-tol)

Checks if given value is near zero with absolute (default: 1.0e-6) and/or relative (default 0.0) tolerance.

neg-inf? clj

(neg-inf? v)

Check if number is negatively infinite

neg? clj macro

(neg? x)

fastmath.java.PrimitiveMath/isNeg function wrapped in macro.

negative-zero? clj

(negative-zero? x)

Check if zero is negative, ie. -0.0

negmuladd clj macro

(negmuladd x y z)

[x y z] -> (+ z (* -1.0 x y)

next-double clj

(next-double v)

(next-double v delta)

Next double value. Optional value delta sets step amount.

norm clj

(norm v start stop)

(norm v start1 stop1 start2 stop2)

Normalize v from the range [start,stop] to the range [0,1] or map v from the range [start1,stop1] to the range [start2,stop2]. See also make-norm.

not-neg? clj macro

(not-neg? x)

fastmath.java.PrimitiveMath/isNNeg function wrapped in macro.

not-pos? clj macro

(not-pos? x)

fastmath.java.PrimitiveMath/isNPos function wrapped in macro.

not== clj macro

(not== x)

(not== x y)

(not== x y & rest)

A primitive math version of not==

odd? clj macro

(odd? x)

fastmath.java.PrimitiveMath/isOdd function wrapped in macro.

one? clj macro

(one? x)

fastmath.java.PrimitiveMath/isOne function wrapped in macro.

order clj

(order vs)

(order vs decreasing?)

Ordering permutation. See R docs

Order uses 0 based indexing.

PHI clj

Golden ratio \(\phi\)

PI clj

Value of \(\pi\)

pos-inf? clj

(pos-inf? v)

Check if number is positively infinite

pos? clj macro

(pos? x)

fastmath.java.PrimitiveMath/isPos function wrapped in macro.

pow clj macro

(pow x y)

net.jafama.FastMath/pow function wrapped in macro.

pow2 clj

(pow2 x)

Same as sq. \(x^2\)

pow3 clj

(pow3 x)

\(x^3\)

prev-double clj

(prev-double v)

(prev-double v delta)

Next double value. Optional value delta sets step amount.

qceil clj macro

(qceil x)

Fast version of ceil. Returns long. See: ceil.

qcos clj macro

(qcos x)

Fast and less accurate cos.

qdist clj

(qdist [x1 y1] [x2 y2])

(qdist x1 y1 x2 y2)

Quick version of Euclidean distance between points. qsqrt is used instead of sqrt.

qexp clj macro

(qexp x)

Quick and less accurate version of exp.

qfloor clj macro

(qfloor x)

Fast version of floor. Returns long. See: floor.

qlog clj macro

(qlog x)

Fast and less accurate version of log.

qpow clj macro

(qpow x y)

Fast and less accurate version of pow.

qround clj macro

(qround x)

Fast version of round. Returns long. See: rint, round.

qsin clj macro

(qsin x)

Fast and less accurate sin.

qsqrt clj macro

(qsqrt x)

Approximated sqrt using binary operations with error 1.0E-2.

quad-interpolation clj

(quad-interpolation start stop t)

Quad interpolation. See also lerp/mlerp, cos-interpolation or smooth-interpolation.

QUARTER_PI clj

Value of \(\frac{\pi}{4}\)

quot clj macro

(quot x y)

fastmath.java.PrimitiveMath/quotient function wrapped in macro.

rad-in-deg clj

\(\frac{180}{\pi}\)

radians clj

(radians deg)

Convert degrees into radians.

rank clj

(rank vs)

(rank vs ties)

(rank vs ties desc?)

Sample ranks. See R docs.

Rank uses 0 based indexing.

Possible tie strategies: :average, :first, :last, :random, :min, :max, :dense.

:dense is the same as in data.table::frank from R

rank1 clj

regularized-beta clj macro

(regularized-beta x y z)

Regularized Beta.

regularized-gamma-p clj macro

(regularized-gamma-p x y)

Regularized gamma P

regularized-gamma-q clj macro

(regularized-gamma-q x y)

Regularized gamma Q

rem clj macro

(rem x y)

fastmath.java.PrimitiveMath/remainder function wrapped in macro.

remainder clj macro

(remainder x y)

From FastMath doc: returns dividend - divisor * n, where n is the mathematical integer closest to dividend/divisor. Returned value in [-|divisor|/2,|divisor|/2]

rint clj

(rint x)

(rint x scale)

Round to double. See round, qround.

Rounding is done to a multiply of scale value (when provided).

round clj

(round x)

Round to long. See: rint, qround.

round-even clj

(round-even x)

Round evenly (like in round in R), IEEE / IEC rounding

round-up-pow2 clj

(round-up-pow2 v)

Round long to the next power of 2

rqsqrt clj macro

(rqsqrt x)

Inversed version of qsqrt. Quick and less accurate.

safe-sqrt clj

(safe-sqrt value)

Safe sqrt, for value <= 0 result is 0.

\( \left\{ \begin{array}{lr} 0 & : x \leq 0\\ \sqrt{x} & : x > 0 \end{array} \right. \)

sample clj

(sample f number-of-values)

(sample f number-of-values domain?)

(sample f domain-min domain-max number-of-values)

(sample f domain-min domain-max number-of-values domain?)

Sample function f and return sequence of values.

range-min defaults to 0.0, range-max to 1.0.

Range is inclusive.

When optional domain? is set to true (default: false) function returns pairs [x,(f x)].

sec clj

(sec v)

Secant

sech clj

(sech v)

Hyperbolic secant

seq->double-array clj

(seq->double-array vs)

Convert sequence to double array. Returns input if vs is double array already.

seq->double-double-array clj

(seq->double-double-array vss)

Convert sequence to double-array of double-arrays.

If sequence is double-array of double-arrays returns vss

sfrac clj

(sfrac v)

Fractional part, always returns values from -1.0 to 1.0 (exclusive). See frac for unsigned version.

sgn clj

(sgn value)

Return -1 when value is negative, 1 otherwise. See also signum.

\( \left\{ \begin{array}{lr} 1.0 & : x \geq 0\\ -1.0 & : x < 0\\ \end{array} \right. \)

Si clj

(Si x)

Integral of sin(t)/t from 0 to x

sigmoid clj

(sigmoid x)

Sigmoid function

signum clj

(signum value)

Return 1 if value is > 0, 0 if it is 0, -1 otherwise. See also sgn.

\( \left\{ \begin{array}{lr} 1.0 & : x > 0\\ -1.0 & : x < 0\\ 0.0 & : x = 0 \end{array} \right. \)

SILVER clj

Silver ratio \(\delta_S\)

sin clj macro

(sin x)

net.jafama.FastMath/sin function wrapped in macro.

sinc clj

(sinc v)

Sinc function.

sinh clj macro

(sinh x)

net.jafama.FastMath/sinh function wrapped in macro.

SIXTH clj

Value of \(\frac{1}{6}\)

slice-range clj

(slice-range cnt)

(slice-range start end cnt)

Slice range to get cnt number of points evenly distanced.

smooth-interpolation clj

(smooth-interpolation start stop t)

Smoothstep based interpolation. See also lerp/mlerp, quad-interpolation or cos-interpolation.

smooth-max clj

(smooth-max xs)

(smooth-max xs alpha)

(smooth-max xs alpha family)

Smooth maximum function.

A smooth function with alpha argument. When alpha goes to infinity, function returns maximum value of xs.

Family:

• :lse - LogSumExp (default)
• :boltzmann - Boltzmann operator, works for small alpha values
• :mellowmax
• :p-norm
• :smu - smooth maximum unit, epsilon = 1/alpha > 0

smoothstep clj

(smoothstep edge0 edge1 x)

GL smoothstep.

sq clj

(sq x)

Same as pow2. \(x^2\)

sqrt clj macro

(sqrt x)

\(\sqrt{x}\)

SQRT2 clj

\(\sqrt{2}\)

SQRT2_2 clj

\(\frac{\sqrt{2}}{2}\)

SQRT2PI clj

\(\sqrt{2\pi}\)

SQRT3 clj

\(\sqrt{3}\)

SQRT3_2 clj

\(\frac{\sqrt{3}}{2}\)

SQRT3_3 clj

\(\frac{\sqrt{3}}{3}\)

SQRT3_4 clj

\(\frac{\sqrt{3}}{4}\)

SQRT5 clj

\(\sqrt{5}\)

SQRT_HALFPI clj

\(\sqrt{\frac{1}{2}\pi}\)

SQRTPI clj

\(\sqrt{\pi}\)

sum-of-products clj

(sum-of-products a b c d)

Kahan's algorithm for (ab)+(cd) to avoid catastrophic cancellation.

tan clj macro

(tan x)

net.jafama.FastMath/tan function wrapped in macro.

tanh clj macro

(tanh x)

net.jafama.FastMath/tanh function wrapped in macro.

TAU clj

Alias for TWO_PI

THIRD clj

Value of \(\frac{1}{3}\)

THIRD_PI clj

Value of \(\frac{\pi}{3}\)

trigamma clj macro

(trigamma x)

Derivative of digamma.

trunc clj

(trunc v)

Truncate fractional part, keep sign. Returns double.

TWO_INV_PI clj

Value of \(\frac{2}{\pi}\)

TWO_PI clj

Value of \(2 {\pi}\)

TWO_THIRD clj

Value of \(\frac{2}{3}\)

ulp clj

(ulp v)

Unit in the Last Place, distance between next value larger than v and v

unsigned-bit-shift-right clj macro

(unsigned-bit-shift-right x y)

fastmath.java.PrimitiveMath/unsignedShiftRight function wrapped in macro.

unuse-primitive-operators clj

(unuse-primitive-operators)

Undoes the work of use-primitive-operators. This is idempotent.

use-primitive-operators clj

(use-primitive-operators)

(use-primitive-operators skip-set)

Replaces Clojure's arithmetic and number coercion functions with primitive equivalents. These are defined as macros, so they cannot be used as higher-order functions. This is an idempotent operation. Undo with unuse-primitive-operators.

valid-double? clj

(valid-double? v)

Check if number is invalid

vercos clj

(vercos v)

Vercosine

versin clj

(versin v)

Versine

wrap clj

(wrap [start stop] value)

(wrap start stop value)

Wrap overflowed value into the range, similar to ofWrap.

xexpx clj

(xexpx x)

x * exp(x)

xexpy clj

(xexpy x y)

x * exp(x)

xlog1py clj

(xlog1py x y)

x * log(1+y)

xlogx clj

(xlogx x)

x * log(x)

xlogy clj

(xlogy x y)

x * log(y)

zero? clj macro

(zero? x)

fastmath.java.PrimitiveMath/isZero function wrapped in macro.