fastmath.core — generateme/fastmath 2.1.9-SNAPSHOT

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-not bit-shift-left bit-shift-right unsigned-bit-shift-right inc dec zero? neg? pos? min max even? odd? abs

And additionally:

• bool-and - and working on booleans
• bool-or - boolean or
• bool-xor - boolean xor
• bool-not - boolean not
• << - 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

acsc clj

(acsc v)

Arccosecant

acsch clj

(acsch v)

Area hyperbolic cosecant

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.

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-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-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-xor clj macro

(bit-xor x)

(bit-xor x y)

(bit-xor x y & rest)

A primitive math version of bit-xor

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

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).

Ci clj

(Ci x)

Integral of cos(t)/t from -x to inf

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()

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 arguemnt 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

csc clj

(csc v)

Cosecant

csch clj

(csch v)

Hyperbolic 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.

difference-of-products clj

(difference-of-products a b c d)

digamma clj macro

(digamma x)

Logarithmic derivative of \(\Gamma\).

dist clj

(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-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-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)

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.

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.

factorial20 clj

(factorial20 n)

Factorial table up to 20!

fast* clj

(fast* a b)

Primitive * for two arguments as function (not macro).

fast+ clj

(fast+ a b)

Primitive + for two arguments as function (not macro).

fast- clj

(fast- a b)

Primitive - for two arguments as function (not macro).

fast-identity clj

(fast-identity a)

Identity on double.

fast-max clj

(fast-max a b)

Primitive max for two arguments as function (not macro).

fast-min clj

(fast-min a b)

Primitive min for two arguments as function (not macro).

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.

HALF_PI clj

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

haversine clj

(haversine v)

(haversine [lat1 lon1] [lat2 lon2])

(haversine lat1 lon1 lat2 lon2)

Haversine formula

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-gamma-1pm1 clj macro

(inv-gamma-1pm1 x)

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

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

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-gamma clj macro

(log-gamma x)

Gamma function \(\ln\Gamma(x)\)

log-gamma-1p clj macro

(log-gamma-1p x)

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

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}\)

LOG_HALF clj

\(\ln{0.5}\)

LOG_PI clj

\(\ln{\pi}\)

LOG_TWO_PI clj

\(\ln{2 \pi}\)

logb clj

(logb b x)

Logarithm with base b.

\(\ln_b{x}\)

logexpm1 clj

(logexpm1 x)

log(exp(x)-1))

logI0 clj

(logI0 x)

Log of I0.

logistic clj

Alias for sigmoid

logit clj

(logit x)

Logit function

logmxp1 clj

(logmxp1 x)

log(x)-x+1

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

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

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.

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== 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 \(\varphi\)

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)

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

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)

Round to double. See round, qround.

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 range-min range-max number-of-values)

(sample f range-min range-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. \)

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.

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)

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}\)

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

wrap clj

(wrap start stop value)

Wrap overflowed value into the range, similar to ofWrap.

xlogx clj

(xlogx x)

x * log(x)

zero? clj macro

(zero? x)

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