fastmath.core — generateme/fastmath 1.0.1

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?

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

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.

• For random/noise functions check fastmath.random namespace.
• fastmath.vector contains vector (2,3,4 dim. + double array + clojure vector) protocol and implementations.
• fastmath.complex contains complex number operations.

* clj/s macro

(* x)

(* x y)

(* x y & rest)

A primitive math version of *

+ clj/s macro

(+ x)

(+ x y)

(+ x y & rest)

A primitive math version of +

- clj/s macro

(- x)

(- x y)

(- x y & rest)

A primitive math version of -

/ clj/s macro

(/ x)

(/ x y)

(/ x y & rest)

A primitive math version of /

< clj/s macro

(< x)

(< x y)

(< x y & rest)

A primitive math version of <

<< clj/s macro

(<< x y)

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

<= clj/s macro

(<= x)

(<= x y)

(<= x y & rest)

A primitive math version of <=

== clj/s macro

(== x)

(== x y)

(== x y & rest)

Equality. See also eq for function version.

> clj/s macro

(> x)

(> x y)

(> x y & rest)

A primitive math version of >

>= clj/s macro

(>= x)

(>= x y)

(>= x y & rest)

A primitive math version of >=

>> clj/s macro

(>> x y)

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

>>> clj/s macro

(>>> x y)

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

abs clj

(abs x)

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

acos clj/s macro

(acos x)

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

acosh clj/s 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.

asec clj

(asec v)

Arcsecant

asech clj

(asech v)

Area hyperbolic secant

asin clj/s macro

(asin x)

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

asinh clj/s macro

(asinh x)

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

atan clj/s macro

(atan x)

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

atan2 clj/s macro

(atan2 x y)

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

atanh clj/s macro

(atanh x)

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

bessel-j clj/s macro

(bessel-j x y)

Bessel J function value for given order and argument.

bit-and clj/s macro

(bit-and x)

(bit-and x y)

(bit-and x y & rest)

A primitive math version of bit-and

bit-not clj/s macro

(bit-not x)

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

bit-or clj/s macro

(bit-or x)

(bit-or x y)

(bit-or x y & rest)

A primitive math version of bit-or

bit-shift-left clj/s macro

(bit-shift-left x y)

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

bit-shift-right clj/s macro

(bit-shift-right x y)

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

bit-xor clj/s macro

(bit-xor x)

(bit-xor x y)

(bit-xor x y & rest)

A primitive math version of bit-xor

bool-and clj/s macro

(bool-and x)

(bool-and x y)

(bool-and x y & rest)

A primitive math version of bool-and

bool-not clj/s macro

(bool-not x)

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

bool-or clj/s macro

(bool-or x)

(bool-or x y)

(bool-or x y & rest)

A primitive math version of bool-or

bool-xor clj/s macro

(bool-xor x)

(bool-xor x y)

(bool-xor x y & rest)

A primitive math version of bool-xor

cbrt clj/s macro

(cbrt x)

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

ceil clj

(ceil x)

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

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.

constrain clj/s macro

(constrain value mn mx)

Clamp value to the range [mn,mx].

cos clj/s 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/s 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

dec clj/s 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.

digamma clj/s 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

E clj

Value of \(e\)

EPSILON clj

Very small number \(\varepsilon\)

eq clj

(eq a)

(eq a b)

(eq a b c)

(eq a b c d)

Primitive math equality function for doubles. See ==.

erf clj/s macro

(erf x)

(erf x y)

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

erfc clj/s macro

(erfc x)

Complementary error function.

even? clj/s macro

(even? x)

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

exp clj/s macro

(exp x)

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

floor clj

(floor x)

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

fpow clj/s 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/s macro

(gamma x)

Gamma function \(\Gamma(x)\)

GAMMA clj

Lanchos approximation g constant

gcd clj

(gcd a b)

HALF_PI clj

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

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.

iabs clj

(iabs x)

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

inc clj/s macro

(inc x)

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

inv-erf clj/s macro

(inv-erf x)

Inverse erf.

inv-erfc clj/s macro

(inv-erfc x)

Inverse erfc.

inv-gamma-1pm1 clj/s 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}}\)

itrunc clj

(itrunc v)

Truncate fractional part, keep sign. Returns long.

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/s 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/s macro

(log x)

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

log-beta clj/s macro

(log-beta x y)

Logarithm of Beta function.

log-gamma clj/s macro

(log-gamma x)

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

log-gamma-1p clj/s macro

(log-gamma-1p x)

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

log10 clj/s macro

(log10 x)

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

LOG10E clj

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

log1p clj/s macro

(log1p x)

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

log2 clj

(log2 x)

Logarithm with base 2.

\(\ln_2{x}\)

LOG2E clj

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

logb clj

(logb b x)

Logarithm with base b.

\(\ln_b{x}\)

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.

max clj/s macro

(max x)

(max x y)

(max x y & rest)

A primitive math version of max

min clj/s macro

(min x)

(min x y)

(min x y & rest)

A primitive math version of min

mlerp clj/s macro

(mlerp start stop t)

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

mod clj/s macro

(mod x y)

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

neg? clj/s macro

(neg? x)

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

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/s macro

(not== x)

(not== x y)

(not== x y & rest)

A primitive math version of not==

odd? clj/s macro

(odd? x)

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

PHI clj

Golden ratio \(\varphi\)

PI clj

Value of \(\pi\)

pos? clj/s macro

(pos? x)

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

pow clj/s 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)

Previous double value. Optional value delta sets step amount.

qceil clj/s macro

(qceil x)

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

qcos clj/s 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/s macro

(qexp x)

Quick and less accurate version of exp.

qfloor clj/s macro

(qfloor x)

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

qlog clj/s macro

(qlog x)

Fast and less accurate version of log.

qpow clj/s macro

(qpow x y)

Fast and less accurate version of pow.

qround clj/s macro

(qround x)

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

qsin clj/s macro

(qsin x)

Fast and less accurate sin.

qsqrt clj/s 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/s 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.

regularized-beta clj/s macro

(regularized-beta x y z)

Regularized Beta.

regularized-gamma-p clj/s macro

(regularized-gamma-p x y)

Regularized gamma P

regularized-gamma-q clj/s macro

(regularized-gamma-q x y)

Regularized gamma Q

rem clj/s macro

(rem x y)

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

remainder clj/s 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-up-pow2 clj

(round-up-pow2 v)

Round long to the next power of 2

rqsqrt clj/s 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 range-min range-max number-of-values)

Sample function f and return sequence of values.

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

Range is inclusive.

sec clj

(sec v)

Secant

sech clj

(sech v)

Hyperbolic secant

seq->double-array clj

(seq->double-array vs)

Convert sequence to double-array.

If sequence is double-array do not convert.

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 do not convert

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

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/s macro

(sin x)

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

sinc clj

(sinc v)

Sinc function.

sinh clj/s macro

(sinh x)

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

SIXTH clj

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

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

SQRT5 clj

\(\sqrt{5}\)

SQRTPI clj

\(\sqrt{\pi}\)

tan clj/s macro

(tan x)

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

tanh clj/s 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/s macro

(trigamma x)

Derivative of digamma.

trunc clj

(trunc v)

Truncate fractional part, keep sign. Returns double.

TWO_PI clj

Value of \(2 {\pi}\)

TWO_THIRD clj

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

unsigned-bit-shift-right clj/s 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)

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.

wrap clj

(wrap start stop value)

Wrap overflowed value into the range, similar to ofWrap.

zero? clj/s macro

(zero? x)

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