Core

Collection of type hinted math macros and functions. Partially backed by Java static functions and exposed as macros. They are prepared to accept primitive long or double arguments and return long or double only.

There is a possibility to replace clojure.core functions with a selection of fastmath.core macros. Call:

• (m/use-primitive-operators) to replace functions with macros
• (m/unuse-primitive-operators) to revert replacement.

Be aware that there are some differences and fastmath.core versions shoudn’t be treated as a drop-in replacement for clojure.core versions. Also, since Clojure 1.12, always call unuse-primitive-operators at the end of the namespace.

Here is the complete list of replaced functions:

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

(require '[fastmath.core :as m])

Basic operations

Basic math operations.

When used in an expression oprations are inlined and can accept mixture of long and double values. If all values are of long primitive type, long is returned, double otherwise.

When used in higher order function, double is returned always. To operate on long primitive type, reach for long- versions.

Defined functions

• +, -, *, /, quot
• inc, dec
• min, max, smooth-max
• rem, mod, remainder, wrap
• abs

long versions

• long-add, long-sub, long-mult, long-div, long-quot
• long-inc, long-dec
• long-min, long-max
• long-rem, long-quot, long-mod
• long-abs

Arithmetics

• addition, incrementation
• subtraction, decrementation
• multiplication
• division

Division differences

Please note that there some differences between division in fastmath and clojure.core

• when called with one argument (double or long) m// always returns reciprocal (clojure.core// returns a ratio)
• when called on long arguments, m// is a long division (clojure.core// returns a ratio)
• m// for two long arguments is equivalent to m/quot

Examples

Addition

(m/+) ;; => 0.0
(m/+ 1 2 3 4) ;; => 10
(m/+ 1.0 2.5 3 4) ;; => 10.5
(reduce m/+ [1 2 3]) ;; => 6.0

(m/long-add) ;; => 0
(m/long-add 1 2 3 4) ;; => 10
(m/long-add 1.0 2.5 3 4) ;; => 10
(reduce m/long-add [1 2 3.5]) ;; => 6

Subtraction

[(m/- 1) (m/- 1.0)] ;; => [-1 -1.0]
(m/- 1 2 3 4) ;; => -8
(m/- 1.0 2.5 3 4) ;; => -8.5
(reduce m/- [1 2 3]) ;; => -4.0

(m/long-sub 1) ;; => -1
(m/long-sub 1 2 3 4) ;; => -8
(m/long-sub 1.0 2.5 3 4) ;; => -8
(reduce m/long-sub [1 2 3.5]) ;; => -4

Multiplication

(m/*) ;; => 1.0
(m/* 1 2 3 4) ;; => 24
(m/* 1.0 2.5 3 4) ;; => 30.0
(reduce m/* [1 2 3]) ;; => 6.0

(m/long-mult) ;; => 1
(m/long-mult 1 2 3 4) ;; => 24
(m/long-mult 1.0 2.5 3 4) ;; => 24
(reduce m/long-mult [1 2 3.5]) ;; => 6

Division

[(m// 2) (m// 2) (/ 2)] ;; => [0.5 0.5 1/2]
(m// 1 2 3 4) ;; => 0
(m// 1.0 2.5 3 4) ;; => 0.03333333333333333
(reduce m// [1 2 3]) ;; => 0.16666666666666666
(m/quot 10.5 -3) ;; => -3.0

(m/long-div 2) ;; => 0.5
(m/long-div 100 5 3) ;; => 6
(m/long-div 100.5 2.5 3) ;; => 16
(reduce m/long-div [100 2 3.5]) ;; => 16
(m/long-quot 10 -3) ;; => -3

Increment and decrement

(m/inc 4) ;; => 5
(m/inc 4.5) ;; => 5.5
(m/dec 4) ;; => 3
(m/dec 4.5) ;; => 3.5
(map m/inc [1 2 3.5 4.5]) ;; => (2.0 3.0 4.5 5.5)

(m/long-inc 4) ;; => 5
(m/long-inc 4.5) ;; => 5
(m/long-dec 4) ;; => 3
(m/long-dec 4.5) ;; => 3
(map m/long-inc [1 2 3.5 4.5]) ;; => (2 3 4 5)

Remainders

• rem and mod are the same as in clojure.core,
• remainder returns \(dividend - divisor * n\), where \(n\) is the mathematical integer closest to \(\frac{dividend}{divisor}\). Returned value is inside the \([\frac{-|divisor|}{2},\frac{|divisor|}{2}]\) range.
• wrap wraps the value to be within given interval (right open) \([a,b)\) `

Examples

(m/mod 10 4) ;; => 2
(m/mod -10.25 4.0) ;; => 1.75
(m/mod 10.25 -4.0) ;; => -1.75
(m/mod -10.25 -4.0) ;; => -2.25
(m/rem 10 4) ;; => 2
(m/rem -10.25 4.0) ;; => -2.25
(m/rem 10.25 -4.0) ;; => 2.25
(m/rem -10.25 -4.0) ;; => -2.25
(m/remainder 10 4) ;; => 2.0
(m/remainder -10.25 4.0) ;; => 1.75
(m/remainder 10.25 -4.0) ;; => -1.75
(m/remainder -10.25 -4.0) ;; => 1.75
(m/wrap -1.25 1.25 1.0) ;; => 1.0
(m/wrap -1.25 1.25 1.35) ;; => -1.15
(m/wrap -1.25 1.25 -1.25) ;; => -1.25
(m/wrap -1.25 1.25 1.25) ;; => -1.25
(m/wrap [-1.25 1.25] -1.35) ;; => 1.15

Min, max, abs

Examples

(m/min 1 2 -3) ;; => -3
(m/min 1.0 2 -3) ;; => -3.0
(m/max 1 2 -3) ;; => 2
(m/max 1.0 2 -3) ;; => 2.0
(m/abs -3) ;; => 3
(m/long-abs -3) ;; => 3
(m/abs -3.5) ;; => 3.5
(m/long-abs -3.5) ;; => 3

Smooth maximum

Smooth maximum is a family of functions \(\max_\alpha(xs)\) for which \(\lim_{\alpha\to\infty}\max_\alpha(xs)=\max(xs)\).

Five types of smooth maximum are defined (see wikipedia for formulas):

• :lse - LogSumExp (default)
• :boltzmann - Boltzmann operator, works for small alpha values
• :mellowmax
• :p-norm
• :smu - smooth maximum unit, \(\epsilon=\frac{1}{\alpha}\)

:lse, :boltzmann and :mellowmax are also smooth minimum for negative \(\alpha\) values.

The following plots show value of the smooth max for different \(\alpha\) and set of the numbers equal to [-3.5 -2 -1 0.1 3 4]. Blue dashed horizontal lines are minimum (-3.5) and maximum values (4.0).

The following plots are defined only for positive \(\alpha\).

Examples

(m/smooth-max [-3.5 -2 -1 0.1 3 4] 4.0 :lse) ;; => 4.004537523710555
(m/smooth-max [-3.5 -2 -1 0.1 3 4] -4.0 :lse) ;; => -3.500630381944282
(m/smooth-max [-3.5 -2 -1 0.1 3 4] 4.0 :boltzmann) ;; => 3.9820131397304284
(m/smooth-max [-3.5 -2 -1 0.1 3 4] -4.0 :boltzmann) ;; => -3.496176019710726
(m/smooth-max [-3.5 -2 -1 0.1 3 4] 4.0 :mellowmax) ;; => 3.5565976564035413
(m/smooth-max [-3.5 -2 -1 0.1 3 4] -4.0 :mellowmax) ;; => -3.0526905146372685
(m/smooth-max [-3.5 -2 -1 0.1 3 4] 4.0 :p-norm) ;; => 4.738284340366858
(m/smooth-max [-3.5 -2 -1 0.1 3 4] 4.0 :smu) ;; => 4.060190281957045

fma

Fused multiply-add \(fma(a,b,c)=a+b*c\) is the operation implemented with better accuracy in Java 9+ and as one instruction (see more here and here). When Java 8 is used fma is replaced with direct a+b*c formula.

Defined functions

• fma, muladd, negmuladd
• difference-of-products, sum-of-products

\[\operatorname{fma}(a,b,c)=\operatorname{muladd}(a,b,c)=a+bc\] \[\operatorname{negmuladd}(a,b,c)=\operatorname{fma}(-a,b,c)\]

difference-of-products (dop) and sum-of-products (sop) are using Kahan’s algorithm to avoid catastrophic cancellation.

\[\operatorname{dop}(a,b,c,d)=ab-cd=\operatorname{fma}(a,b,-cd)+\operatorname{fma}(-c,d,cd)\] \[\operatorname{sop}(a,b,c,d)=ab+cd=\operatorname{fma}(a,b,cd)+\operatorname{fma}(c,d,-cd)\]

The following example shows that \(x^2-y^2\) differs from the best floating point approximation which is equal 1.8626451518330422e-9.

(let [x (m/inc (m/pow 2 -29))
      y (m/inc (m/pow 2 -30))]
  {:proper-value (m/difference-of-products x x y y)
   :wrong-value (m/- (m/* x x) (m/* y y))})

{:proper-value 1.8626451518330422E-9, :wrong-value 1.862645149230957E-9}

Examples

(m/fma 3 4 5) ;; => 17.0
(m/muladd 3 4 5) ;; => 17.0
(m/negmuladd 3 4 5) ;; => -7.0
(m/difference-of-products 3 3 4 4) ;; => -7.0
(m/sum-of-products 3 3 4 4) ;; => 25.0

Rounding

Various rounding functions.

• floor, ceil and rint accept additional argument, scale, which allows to round to the nearest multiple of scale.
• round returns long while rint returns double
• approx rounds number to the given number of digits, uses bigdec
• trunc returns integer part of a number, frac returns fractional part
• trunc returns double while itrunc returns long
• sfrac keeps sign of the argument
• qfloor, qceil and qround are implemented using casting to long

Defined functions

• floor, ceil
• round, round-even, rint, approx, trunc, itrunc
• qfloor, qceil, qround
• frac, sfrac
• round-up-pow2

Examples

(map m/floor [-10.5 10.5]) ;; => (-11.0 10.0)
(m/floor 10.5 4.0) ;; => 8.0
(map m/ceil [-10.5 10.5]) ;; => (-10.0 11.0)
(m/ceil 10.5 4.0) ;; => 12.0
(map m/rint [-10.51 -10.5 -10.49 10.49 10.5 10.51]) ;; => (-11.0 -10.0 -10.0 10.0 10.0 11.0)
(m/rint 10.5 4.0) ;; => 12.0
(m/rint 10.591 0.1) ;; => 10.600000000000001
(map m/round [-10.51 -10.5 -10.49 10.49 10.5 10.51]) ;; => (-11 -10 -10 10 11 11)
(map m/round-even [-10.51 -10.5 -10.49 10.49 10.5 10.51]) ;; => (-11 -10 -10 10 10 11)
(map m/qfloor [-10.5 10.5]) ;; => (-11 10)
(map m/qceil [-10.5 10.5]) ;; => (-10 11)
(map m/qround [-10.51 -10.5 -10.49 10.49 10.5 10.51]) ;; => (-11 -11 -10 10 11 11)
(map m/trunc [-10.591 10.591]) ;; => (-10.0 10.0)
(map m/itrunc [-10.591 10.591]) ;; => (-10 10)
(m/approx 10.591) ;; => 10.59
(m/approx 10.591 1) ;; => 10.6
(m/approx 10.591 0) ;; => 11.0
(m/approx -10.591) ;; => -10.59
(m/approx -10.591 1) ;; => -10.6
(m/approx -10.591 0) ;; => -11.0
(map m/frac [-10.591 10.591]) ;; => (0.5909999999999993 0.5909999999999993)
(map m/sfrac [-10.591 10.591]) ;; => (-0.5909999999999993 0.5909999999999993)
(map m/round-up-pow2 (range 10)) ;; => (0 1 2 4 4 8 8 8 8 16)

The difference between rint and round. round is bounded by minimum and maximum long values.

(m/rint 1.23456789E30) ;; => 1.23456789E30
(m/round 1.23456789E30) ;; => 9223372036854775807

Sign

Sign of the number.

Defined functions

• signum and sgn
• copy-sign

\[\operatorname{signum}(x)=\begin{cases} -1 & x<0 \\ 1 & x>0 \\ 0 & x=0 \end{cases}\]

\[\operatorname{sgn}(x)=\begin{cases} -1 & x<0 \\ 1 & x\geq 0 \end{cases}\]

copy-sign sets the sign of the second argument to the first. Please note that -0.0 is negative and 0.0 is positive.

\[\operatorname{copy-sign}(x,y)=\begin{cases} |x| & y>0 \lor y=0.0\\ -|x| & y<0 \lor y=-0.0 \end{cases}\]

Examples

(m/signum -2.5) ;; => -1.0
(m/signum 2.5) ;; => 1.0
(m/sgn -2.5) ;; => -1.0
(m/sgn 2.5) ;; => 1.0
(m/signum 0) ;; => 0.0
(m/sgn 0) ;; => 1.0
(m/copy-sign 123 -10) ;; => -123.0
(m/copy-sign -123 10) ;; => 123.0
(m/copy-sign 123 -0.0) ;; => -123.0
(m/copy-sign -123 0.0) ;; => 123.0

Predicates

Trigonometry

Power and logarithms

Bitwise operations

Floating point

Other

GCD and LCM

Combinatorics

Rank and order

Sampling

Interpolation and mapping

Constants

Reference

fastmath.core

Collection of basic math functions and constants.

Contains:

• Basic math functions
• Predicates
• Bitwise operations
• Trigonometry
• Log/power
• Floating point format operations
• Factorial, combinations, gcd/lcd
• Additional functions: sampling, rank, lerp

Almost all math functions are backed by FastMath library. Almost all operates on primitive double and returns double or long and are inlined.

#### Primitive math operators

Inlined function operating on double/longs as a replacement of Clojure numerical tower: * + - / > < >= <= == 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

To turn on primitive math on your namespace call use-primitive-operators. To turn off and revert original versions call unuse-primitive-operators which is recomended when Clojure 1.12+ is used.

*

• (*)
• (* a)
• (* a b)
• (* a b c)
• (* a b c d)
• (* a b c d & r)

Primitive and inlined *.

source

---

+

• (+)
• (+ a)
• (+ a b)
• (+ a b c)
• (+ a b c d)
• (+ a b c d & r)

Primitive and inlined +.

source

---

-

• (- a)
• (- a b)
• (- a b c)
• (- a b c d)
• (- a b c d & r)

Primitive and inlined -.

source

---

-E ^_CONST

-E = -2.718281828459045

Value of \(-e\)

source

---

-HALF_PI ^_CONST

-HALF_PI = -1.5707963267948966

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

source

---

-PI ^_CONST

-PI = -3.141592653589793

Value of \(-\pi\)

source

---

-QUARTER_PI ^_CONST

-QUARTER_PI = -0.7853981633974483

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

source

---

-TAU ^_CONST

-TAU = -6.283185307179586

Alias for TWO_PI-

source

---

-THIRD_PI ^_CONST

-THIRD_PI = 1.0471975511965976

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

source

---

-TWO_PI ^_CONST

-TWO_PI = -6.283185307179586

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

source

---

/

• (/ a)
• (/ a b)
• (/ a b c)
• (/ a b c d)
• (/ a b c d & r)

Primitive and inlined /.

source

---

<

• (< _)
• (< a b)
• (< a b & r)

Primitive math less-then function.

source

---

<<

• (<< x shift)

Shift bits left

source

---

<=

• (<= _)
• (<= a b)
• (<= a b & r)

Primitive math less-and-equal function.

source

---

==

• (== _)
• (== a b)
• (== a b & r)

Primitive math equality function.

source

---

>

• (> _)
• (> a b)
• (> a b & r)

Primitive math greater-than function.

source

---

>=

• (>= _)
• (>= a b)
• (>= a b & r)

Primitive math greater-and-equal function.

source

---

>>

• (>> x shift)

Shift bits right and keep most significant bit unchanged

source

---

>>>

• (>>> x shift)

Shift bits right and set most significant bit to 0

source

---

CATALAN_G ^_CONST

CATALAN_G = 0.915965594177219

Catalan G

source

---

E ^_CONST

E = 2.718281828459045

Value of \(e\)

source

---

EPSILON ^_CONST

EPSILON = 1.0E-10

Very small number \(\varepsilon\)

source

---

FOUR_INV_PI ^_CONST

FOUR_INV_PI = 1.2732395447351628

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

source

---

GAMMA ^_CONST

GAMMA = 0.5772156649015329

Euler-Mascheroni constant

source

---

HALF_PI ^_CONST

HALF_PI = 1.5707963267948966

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

source

---

INV_FOUR_PI ^_CONST

INV_FOUR_PI = 0.07957747154594767

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

source

---

INV_LN2 ^_CONST

INV_LN2 = 1.4426950408889634

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

source

---

INV_LOG_HALF ^_CONST

INV_LOG_HALF = -1.4426950408889634

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

source

---

INV_PI ^_CONST

INV_PI = 0.3183098861837907

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

source

---

INV_SQRT2PI ^_CONST

INV_SQRT2PI = 0.3989422804014327

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

source

---

INV_SQRTPI ^_CONST

INV_SQRTPI = 0.5641895835477563

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

source

---

INV_SQRT_2 ^_CONST

INV_SQRT_2 = 0.7071067811865475

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

source

---

INV_TWO_PI ^_CONST

INV_TWO_PI = 0.15915494309189535

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

source

---

LANCZOS_G ^_CONST

LANCZOS_G = 4.7421875

Lanchos approximation g constant

source

---

LN10 ^_CONST

LN10 = 2.302585092994046

\(\ln{10}\)

source

---

LN2 ^_CONST

LN2 = 0.6931471805599453

\(\ln{2}\)

source

---

LN2_2 ^_CONST

LN2_2 = 0.34657359027997264

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

source

---

LOG10E ^_CONST

LOG10E = 0.4342944819032518

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

source

---

LOG2E ^_CONST

LOG2E = 1.4426950408889634

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

source

---

LOG_HALF ^_CONST

LOG_HALF = -0.6931471805599453

\(\ln{0.5}\)

source

---

LOG_PI ^_CONST

LOG_PI = 1.1447298858494002

\(\ln{\pi}\)

source

---

LOG_TWO_PI ^_CONST

LOG_TWO_PI = 1.8378770664093453

\(\ln{2 \pi}\)

source

---

MACHINE-EPSILON ^_CONST

MACHINE-EPSILON = 1.1102230246251565E-16

ULP(1)/2. Half of the smallest difference between 1.0 and next possible double floating point number.

source

---

MACHINE-EPSILON10 ^_CONST

MACHINE-EPSILON10 = 1.1102230246251565E-15

5*ULP(1)

source

---

M_1_PI ^_CONST

M_1_PI = 0.3183098861837907

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

source

---

M_2_PI ^_CONST

M_2_PI = 0.6366197723675814

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

source

---

M_2_SQRTPI ^_CONST

M_2_SQRTPI = 1.1283791670955126

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

source

---

M_3PI_4 ^_CONST

M_3PI_4 = 2.356194490192345

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

source

---

M_E ^_CONST

M_E = 2.718281828459045

\(e\)

source

---

M_INVLN2 ^_CONST

M_INVLN2 = 1.4426950408889634

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

source

---

M_IVLN10 ^_CONST

M_IVLN10 = 0.43429448190325176

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

source

---

M_LN10 ^_CONST

M_LN10 = 2.302585092994046

\(\ln{10}\)

source

---

M_LN2 ^_CONST

M_LN2 = 0.6931471805599453

\(\ln{2}\)

source

---

M_LOG10E ^_CONST

M_LOG10E = 0.4342944819032518

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

source

---

M_LOG2E ^_CONST

M_LOG2E = 1.4426950408889634

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

source

---

M_LOG2_E ^_CONST

M_LOG2_E = 0.6931471805599453

\(\ln{2}\)

source

---

M_PI ^_CONST

M_PI = 3.141592653589793

\(\pi\)

source

---

M_PI_2 ^_CONST

M_PI_2 = 1.5707963267948966

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

source

---

M_PI_4 ^_CONST

M_PI_4 = 0.7853981633974483

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

source

---

M_SQRT1_2 ^_CONST

M_SQRT1_2 = 0.7071067811865475

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

source

---

M_SQRT2 ^_CONST

M_SQRT2 = 1.4142135623730951

\(\sqrt{2}\)

source

---

M_SQRT3 ^_CONST

M_SQRT3 = 1.7320508075688772

\(\sqrt{3}\)

source

---

M_SQRT_PI ^_CONST

M_SQRT_PI = 1.7724538509055159

\(\sqrt\pi\)

source

---

M_TWOPI ^_CONST

M_TWOPI = 6.283185307179586

\(2\pi\)

source

---

ONE_SIXTH ^_CONST

ONE_SIXTH = 0.16666666666666666

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

source

---

ONE_THIRD ^_CONST

ONE_THIRD = 0.3333333333333333

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

source

---

PHI ^_CONST

PHI = 1.618033988749895

Golden ratio \(\phi\)

source

---

PI ^_CONST

PI = 3.141592653589793

Value of \(\pi\)

source

---

QUARTER_PI ^_CONST

QUARTER_PI = 0.7853981633974483

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

source

---

SILVER ^_CONST

SILVER = 2.414213562373095

Silver ratio \(\delta_S\)

source

---

SIXTH ^_CONST

SIXTH = 0.16666666666666666

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

source

---

SQRT2 ^_CONST

SQRT2 = 1.4142135623730951

\(\sqrt{2}\)

source

---

SQRT2PI ^_CONST

SQRT2PI = 2.5066282746310002

\(\sqrt{2\pi}\)

source

---

SQRT2_2 ^_CONST

SQRT2_2 = 0.7071067811865476

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

source

---

SQRT3 ^_CONST

SQRT3 = 1.7320508075688772

\(\sqrt{3}\)

source

---

SQRT3_2 ^_CONST

SQRT3_2 = 0.8660254037844386

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

source

---

SQRT3_3 ^_CONST

SQRT3_3 = 0.5773502691896257

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

source

---

SQRT3_4 ^_CONST

SQRT3_4 = 0.4330127018922193

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

source

---

SQRT5 ^_CONST

SQRT5 = 2.23606797749979

\(\sqrt{5}\)

source

---

SQRTPI ^_CONST

SQRTPI = 1.7724538509055159

\(\sqrt{\pi}\)

source

---

SQRT_2_PI ^_CONST

SQRT_2_PI = 0.7978845608028654

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

source

---

SQRT_HALFPI ^_CONST

SQRT_HALFPI = 1.2533141373155001

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

source

---

TAU ^_CONST

TAU = 6.283185307179586

Alias for TWO_PI

source

---

THIRD ^_CONST

THIRD = 0.3333333333333333

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

source

---

THIRD_PI ^_CONST

THIRD_PI = 1.0471975511965976

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

source

---

TWO_INV_PI ^_CONST

TWO_INV_PI = 0.6366197723675814

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

source

---

TWO_PI ^_CONST

TWO_PI = 6.283185307179586

Value of \(2 {\pi}\)

source

---

TWO_THIRD ^_CONST

TWO_THIRD = 0.6666666666666666

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

source

---

TWO_THIRDS ^_CONST

TWO_THIRDS = 0.6666666666666666

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

source

---

abs

• (abs x)

Primitive and inlined version of abs.

source

---

acos

• (acos x)

acos(x)

source

---

acosh

• (acosh x)

acosh(x)

source

---

acot

• (acot x)

acot(x)

source

---

acoth

• (acoth x)

Area hyperbolic cotangent

source

---

acovercos

• (acovercos x)

Arc covercosine

source

---

acoversin

• (acoversin x)

Arc coversine

source

---

acrd

• (acrd x)

Inverse chord

source

---

acsc

• (acsc x)

acsc(x)

source

---

acsch

• (acsch v)

Area hyperbolic cosecant

source

---

aexcsc

• (aexcsc x)

Arc excosecant

source

---

aexsec

• (aexsec x)

Arc exsecant

source

---

ahacovercos

• (ahacovercos x)

Arc hacovercosine

source

---

ahacoversin

• (ahacoversin x)

Arc hacoversine

source

---

ahavercos

• (ahavercos x)

Arc havecosine

source

---

ahaversin

• (ahaversin x)

Arc haversine

source

---

approx

• (approx v)
• (approx v digits)

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

source

---

approx-eq

• (approx-eq a b)
• (approx-eq a b digits)

Checks equality approximately. See approx.

source

---

approx=

Alias for approx-eq

source

---

asec

• (asec x)

asec(x)

source

---

asech

• (asech x)

Area hyperbolic secant

source

---

asin

• (asin x)

asin(x)

source

---

asinh

• (asinh x)

asinh(x)

source

---

atan

• (atan x)

atan(x)

source

---

atan2

• (atan2 x y)

atan2(x,y)

source

---

atanh

• (atanh x)

atanh(x)

source

---

avercos

• (avercos x)

Arc vecosine

source

---

aversin

• (aversin x)

Arc versine

source

---

between-?

• (between-? [x y] v)
• (between-? x y v)

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

source

---

between?

• (between? [x y] v)
• (between? x y v)

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

source

---

bit-and

• (bit-and x)
• (bit-and x y)
• (bit-and x y & r)

x ∧ y - bitwise AND

source

---

bit-and-not

• (bit-and-not x)
• (bit-and-not x y)
• (bit-and-not x y & r)

x ∧ ~y - bitwise AND (with complement second argument)

source

---

bit-clear

• (bit-clear x bit)

Clear bit (set to 0).

source

---

bit-flip

• (bit-flip x bit)

Flip bit (set to 0 when 1 or to 1 when 0).

source

---

bit-nand

• (bit-nand x)
• (bit-nand x y)
• (bit-nand x y & r)

~(x ∧ y) - bitwise NAND

source

---

bit-nor

• (bit-nor x)
• (bit-nor x y)
• (bit-nor x y & r)

~(x ∨ y) - bitwise NOR

source

---

bit-not

• (bit-not x)

~x - bitwise NOT

source

---

bit-or

• (bit-or x)
• (bit-or x y)
• (bit-or x y & r)

x ∨ y - bitwise OR

source

---

bit-set

• (bit-set x bit)

Set bit (set to 1).

source

---

bit-shift-left

• (bit-shift-left x shift)

Shift bits left

source

---

bit-shift-right

• (bit-shift-right x shift)

Shift bits right and keep most significant bit unchanged

source

---

bit-test

• (bit-test x bit)

Test bit (return to true when 1 or false when 0).

source

---

bit-xnor

• (bit-xnor x)
• (bit-xnor x y)
• (bit-xnor x y & r)

~(x⊕y) - bitwise XNOR

source

---

bit-xor

• (bit-xor x)
• (bit-xor x y)
• (bit-xor x y & r)

x⊕y - bitwise XOR

source

---

bits->double

• (bits->double v)

Convert 64 bits to double

source

---

bool-not

• (bool-not x)

Primitive boolean not

source

---

bool-xor

• (bool-xor x y)
• (bool-xor x y & r)

Primitive boolean xor

source

---

cb

• (cb x)

\(x^3\)

source

---

cbrt

• (cbrt x)

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

source

---

ceil

• (ceil x)
• (ceil x scale)

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

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

source

---

cexpexp

• (cexpexp x)

1-exp(-exp(x))

source

---

cloglog

• (cloglog x)

log(-log(1-x))

source

---

cnorm

• (cnorm v start1 stop1 start2 stop2)
• (cnorm v start stop)

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

source

---

co-intervals

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

source

---

combinations

• (combinations n k)

Binomial coefficient (n choose k)

source

---

constrain ^_MACRO

• (constrain value mn mx)

Clamp value to the range [mn,mx].

source

---

copy-sign

• (copy-sign magnitude sign)

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

source

---

cos

• (cos x)

cos(x)

source

---

cos-interpolation

• (cos-interpolation start stop t)

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

source

---

cosh

• (cosh x)

cosh(x)

source

---

cospi

• (cospi x)

cos(pi*x)

source

---

cot

• (cot x)

cot(x)

source

---

coth

• (coth x)

Hyperbolic cotangent

source

---

cotpi

• (cotpi x)

cot(pi*x)

source

---

covercos

• (covercos x)

Covercosine

source

---

coversin

• (coversin x)

Coversine

source

---

crd

• (crd x)

Chord

source

---

csc

• (csc x)

csc(x)

source

---

csch

• (csch x)

Hyperbolic cosecant

source

---

cscpi

• (cscpi x)

csc(pi*x)

source

---

cut

• (cut data breaks)
• (cut x1 x2 breaks)

Cut range or sequence into intervals

source

---

dec

• (dec x)

Primitive and inlined dec

source

---

deg-in-rad ^_CONST

deg-in-rad = 0.017453292519943295

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

source

---

degrees

• (degrees rad)

Convert radians into degrees.

source

---

delta-eq

• (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.

source

---

delta=

Alias for delta-eq

source

---

difference-of-products

• (difference-of-products a b c d)

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

source

---

dist

• (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.

source

---

double-array->seq

Convert double array into sequence.

Alias for seq.

source

---

double-array-type

source

---

double-bits

• (double-bits v)

Returns double as 64-bits (long)

source

---

double-double-array->seq

• (double-double-array->seq res)

Convert double array of double arrays into sequence of sequences.

source

---

double-double-array-type

source

---

double-exponent

• (double-exponent v)

Extract exponent information from double

source

---

double-high-bits

• (double-high-bits v)

Returns high word from double as bits

source

---

double-low-bits

• (double-low-bits v)

Returns low word from double as bits

source

---

double-one-minus-epsilon ^_CONST

double-one-minus-epsilon = 0.9999999999999999

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

source

---

double-significand

• (double-significand v)

Extract significand from double

source

---

eq

• (eq _)
• (eq a b)
• (eq a b & r)

Primitive math equality function.

source

---

even?

• (even? x)

Primitive and inlined even?

source

---

excsc

• (excsc x)

Excosecant

source

---

exp

• (exp x)

exp(x) = e^x

source

---

expexp

• (expexp x)

exp(-exp(-x))

source

---

expm1

• (expm1 x)

exp(x)-1 for small x

source

---

exsec

• (exsec x)

Exsecant

source

---

factorial

• (factorial n)

Factorial

source

---

factorial20

• (factorial20 n)

Factorial table up to 20!

source

---

falling-factorial

• (falling-factorial n x)

Falling (descending) factorial.

source

---

falling-factorial-int

• (falling-factorial-int n x)

Falling (descending) factorial for integer n.

source

---

fast* ^_DEPRECATED

Deprecated: Use * instead

• (fast*)
• (fast* a)
• (fast* a b)
• (fast* a b & r)

Primitive and inlined * as a function

source

---

fast+ ^_DEPRECATED

Deprecated: Use + instead

• (fast+)
• (fast+ a)
• (fast+ a b)
• (fast+ a b & r)

Primitive and inlined + as a function

source

---

fast- ^_DEPRECATED

Deprecated: Use - instead

• (fast-)
• (fast- a)
• (fast- a b)
• (fast- a b & r)

Primitive and inlined - as a function

source

---

fast-div ^_DEPRECATED

Deprecated: Use / instead

• (fast-div)
• (fast-div a)
• (fast-div a b)
• (fast-div a b & r)

Primitive and inlined / as a function

source

---

fast-identity ^_DEPRECATED

Deprecated: Use identity-double instead

• (fast-identity a)

Identity on double.

source

---

fast-max ^_DEPRECATED

Deprecated: Use max instead

• (fast-max a)
• (fast-max a b)
• (fast-max a b & r)

Primitive and inlined max as a function

source

---

fast-min ^_DEPRECATED

Deprecated: Use min instead

• (fast-min a)
• (fast-min a b)
• (fast-min a b & r)

Primitive and inlined min as a function

source

---

floor

• (floor x)
• (floor x scale)

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

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

source

---

fma

• (fma x y z)

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

source

---

fpow

• (fpow x exponent)

Fast version of pow where exponent is integer.

source

---

frac

• (frac v)

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

source

---

gcd

• (gcd a b)

Fast binary greatest common divisor (Stein’s algorithm)

source

---

group-by-intervals

• (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.

source

---

hacovercos

• (hacovercos x)

Hacovercosine

source

---

hacoversin

• (hacoversin x)

Hacoversine

source

---

havercos

• (havercos x)

Havercosine

source

---

haversin

• (haversin x)
• (haversin [lat1 lon1] [lat2 lon2])
• (haversin lat1 lon1 lat2 lon2)

Haversine formula for value or lattitude and longitude pairs.

source

---

haversine

Haversine (haversin alias)

source

---

haversine-dist

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

Haversine distance d for r=1

source

---

high-2-exp

• (high-2-exp x)

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

source

---

high-exp

• (high-exp b x)

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

source

---

hypot

• (hypot x y)
• (hypot x y z)

Hypot. See also hypot-sqrt.

source

---

hypot-sqrt

• (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}\).

source

---

iabs ^_DEPRECATED

Deprecated: Use long-abs.

• (iabs x)

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

source

---

identity-double

• (identity-double a)

Identity on double.

source

---

identity-long

• (identity-long a)

Identity on double.

source

---

inc

• (inc x)

Primitive and inlined inc

source

---

inf?

• (inf? v)

Check if a number is an infinite (positive or negative).

source

---

integer?

• (integer? v)

Check if given real number is an integer.

source

---

inv-factorial

• (inv-factorial n)

Inverse of factorial, 1/n!

source

---

invalid-double?

• (invalid-double? v)

Check if a number is not finite double (NaN or ±Inf).

source

---

itrunc

• (itrunc v)

Truncate fractional part, keep sign. Returns long.

source

---

jvm-version ^_CONST

jvm-version = 21

source

---

lcm

• (lcm a b)

Fast binary least common multiplier.

source

---

lerp

• (lerp start stop t)

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

source

---

ln

• (ln x)

log(x)=ln(x)

source

---

log

• (log x)
• (log base x)

log(x)=ln(x) or logarithm with given base.

source

---

log-combinations

• (log-combinations n k)

Log of binomial coefficient (n choose k)

source

---

log-factorial

• (log-factorial x)

Log factorial, alias to log-gamma

source

---

log10

• (log10 x)

log_10(x)

source

---

log1mexp

• (log1mexp x)

log(1-exp(x)), x<0

source

---

log1p

• (log1p x)

log(1+x) for small x

source

---

log1pexp

• (log1pexp x)

log(1+exp(x))

source

---

log1pmx

• (log1pmx x)

log(1+x)-x

source

---

log1psq

• (log1psq x)

log(1+x^2))

source

---

log2

• (log2 x)

Logarithm with base 2.

\(\ln_2{x}\)

source

---

log2int

• (log2int v)

Fast and integer version of log2, returns long

source

---

log2mexp

• (log2mexp x)

log(2-exp(x))

source

---

logaddexp

• (logaddexp x y)

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

source

---

logb

• (logb b x)

Logarithm with base b.

\(\ln_b{x}\)

source

---

logcosh

• (logcosh x)

log(cosh(x))

source

---

logexpm1

• (logexpm1 x)

log(exp(x)-1))

source

---

logistic

Alias for sigmoid

source

---

logit

• (logit x)

Logit function

source

---

loglog

• (loglog x)

-log(-log(x))

source

---

logmxp1

• (logmxp1 x)

log(x)-x+1

source

---

logsubexp

• (logsubexp x y)

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

source

---

logsumexp

• (logsumexp xs)

log(exp(x1)+…+exp(xn))

source

---

long-abs

• (long-abs x)

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

source

---

long-add

• (long-add)
• (long-add a)
• (long-add a b)
• (long-add a b c)
• (long-add a b c d)
• (long-add a b c d & r)

Primitive and inlined +. Coerces arguments and returned value to a long.

source

---

long-dec

• (long-dec x)

Primitive and inlined dec coerced to a long

source

---

long-div

• (long-div a)
• (long-div a b)
• (long-div a b c)
• (long-div a b c d)
• (long-div a b c d & r)

Primitive and inlined /. Coerces to arguments and returned value to a long.

source

---

long-inc

• (long-inc x)

Primitive and inlined inc coerced to a long

source

---

long-max

• (long-max a)
• (long-max a b)
• (long-max a b c)
• (long-max a b c d)
• (long-max a b c d & r)

Primitive and inlined max. Coerces arguments and returned values to longs.

source

---

long-min

• (long-min a)
• (long-min a b)
• (long-min a b c)
• (long-min a b c d)
• (long-min a b c d & r)

Primitive and inlined min. Coerces arguments and returned values to longs.

source

---

long-mod

• (long-mod x y)

Primitive and inlined mod coerced to longs

source

---

long-mult

• (long-mult)
• (long-mult a)
• (long-mult a b)
• (long-mult a b c)
• (long-mult a b c d)
• (long-mult a b c d & r)

Primitive and inlined *. Coerces arguments and returned value to a long.

source

---

long-quot

• (long-quot x y)

Primitive and inlined quot coerced to longs

source

---

long-rem

• (long-rem x y)

Primitive and inlined rem coerced to longs

source

---

long-sub

• (long-sub a)
• (long-sub a b)
• (long-sub a b c)
• (long-sub a b c d)
• (long-sub a b c d & r)

Primitive and inlined -. Coerces arguments and returned value to a long.

source

---

low-2-exp

• (low-2-exp x)

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

source

---

low-exp

• (low-exp b x)

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

source

---

make-norm

• (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.

source

---

max

• (max a)
• (max a b)
• (max a b c)
• (max a b c d)
• (max a b c d & r)

Primitive and inlined max.

source

---

min

• (min a)
• (min a b)
• (min a b c)
• (min a b c d)
• (min a b c d & r)

Primitive and inlined min.

source

---

mlerp ^_MACRO

• (mlerp start stop t)

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

source

---

mnorm ^_MACRO

• (mnorm v start stop)
• (mnorm v start1 stop1 start2 stop2)

Macro version of norm.

source

---

mod

• (mod x y)

Primitive and inlined mod

source

---

muladd

• (muladd x y z)

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

source

---

nan?

• (nan? v)

Check if a number is a NaN

source

---

near-zero?

• (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.

source

---

neg-inf?

• (neg-inf? v)

Check if a number is negatively infinite.

source

---

neg?

• (neg? x)

Primitive and inlined neg?

source

---

negative-zero?

• (negative-zero? x)

Check if zero is negative, ie. -0.0

source

---

negmuladd

• (negmuladd x y z)

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

source

---

next-double

• (next-double v)
• (next-double v delta)

Next double value. Optional value delta sets step amount.

source

---

norm

• (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.

source

---

not-neg?

• (not-neg? x)

Primitive and inlined not-neg? (x>=0.0)

source

---

not-pos?

• (not-pos? x)

Primitive and inlined not-pos? (x<=0.0)

source

---

not==

• (not== _)
• (not== a b)
• (not== a b & r)

Not equality. For more than two arguments, pairwise not equality is checked.

(not== 1 2 1) === (and (not= 1 2) (not= 2 1))

source

---

odd?

• (odd? x)

Primitive and inlined odd?

source

---

one?

• (one? x)

Primitive and inlined one? (x==1.0)

source

---

order

• (order vs)
• (order vs decreasing?)

Ordering permutation. See R docs

Order uses 0 based indexing.

source

---

pos-inf?

• (pos-inf? v)

Check if a number is positively infinite.

source

---

pos?

• (pos? x)

Primitive and inlined pos?

source

---

pow

• (pow x exponent)

Power of a number

source

---

pow2

• (pow2 x)

Same as sq. \(x^2\)

source

---

pow3

• (pow3 x)

\(x^3\)

source

---

prev-double

• (prev-double v)
• (prev-double v delta)

Next double value. Optional value delta sets step amount.

source

---

qceil

• (qceil x)

Fast version of ceil. Returns long.

source

---

qcos

• (qcos x)

Fast and less accurate cos(x)

source

---

qdist

• (qdist [x1 y1] [x2 y2])
• (qdist x1 y1 x2 y2)

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

source

---

qexp

• (qexp x)

Quick and less accurate version of exp.

source

---

qfloor

• (qfloor x)

Fast version of floor. Returns long.

source

---

qlog

• (qlog x)

Fast and less accurate version of log.

source

---

qpow

• (qpow x exponent)

Fast and less accurate version of pow.

source

---

qround

• (qround x)

Fast version of round. Returns long

source

---

qsin

• (qsin x)

Fast and less accurate sin(x)

source

---

qsqrt

• (qsqrt x)

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

source

---

quad-interpolation

• (quad-interpolation start stop t)

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

source

---

quot

• (quot x y)

Primitive and inlined quot

source

---

rad-in-deg ^_CONST

rad-in-deg = 57.29577951308232

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

source

---

radians

• (radians deg)

Convert degrees into radians.

source

---

rank

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

source

---

rank1

source

---

rem

• (rem x y)

Primitive and inlined rem

source

---

remainder

• (remainder dividend divisor)

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

source

---

rint

• (rint x)
• (rint x scale)

Round to double. See round, qround.

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

source

---

rising-factorial

• (rising-factorial n x)

Rising (Pochhammer) factorial.

source

---

rising-factorial-int

• (rising-factorial-int n x)

Rising (Pochhammer) factorial for integer n.

source

---

round

• (round x)

Round to long. See: rint, qround.

source

---

round-even

• (round-even x)

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

source

---

round-up-pow2

• (round-up-pow2 v)

Round long to the next power of 2

source

---

rqsqrt

• (rqsqrt x)

Reciprocal of qsqrt. Quick and less accurate.

source

---

safe-sqrt

• (safe-sqrt value)

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

$ \{ \[\begin{array}{lr} 0 & : x \leq 0\\\\ \sqrt{x} & : x > 0 \end{array}\]

\right. $

source

---

sample

• (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)].

source

---

sec

• (sec x)

sec(x)

source

---

sech

• (sech x)

Hyperbolic secant

source

---

secpi

• (secpi x)

sec(pi*x)

source

---

seq->double-array

• (seq->double-array vs)

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

source

---

seq->double-double-array

• (seq->double-double-array vss)

Convert sequence to double-array of double-arrays.

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

source

---

sfrac

• (sfrac v)

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

source

---

sgn

• (sgn value)

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

source

---

sigmoid

• (sigmoid x)

Sigmoid function

source

---

signum

• (signum value)

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

source

---

sin

• (sin x)

sin(x)

source

---

sinc

• (sinc v)

Sinc function.

source

---

sinh

• (sinh x)

sinh(x)

source

---

sinpi

• (sinpi x)

sin(pi*x)

source

---

slice-range

• (slice-range start end cnt)
• (slice-range cnt)

Slice range to get cnt number of points evenly distanced.

source

---

smooth-interpolation

• (smooth-interpolation start stop t)

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

source

---

smooth-max

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

source

---

smoothstep

• (smoothstep edge0 edge1 x)

GL smoothstep.

source

---

sq

• (sq x)

Same as pow2. \(x^2\)

source

---

sqrt

• (sqrt x)

\(\sqrt{x}\)

source

---

sum-of-products

• (sum-of-products a b c d)

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

source

---

tan

• (tan x)

tan(x)

source

---

tanh

• (tanh x)

tanh(x)

source

---

tanpi

• (tanpi x)

tan(pi*x)

source

---

trunc

• (trunc v)

Truncate fractional part, keep sign. Returns double.

source

---

ulp

• (ulp x)

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

source

---

unsigned-bit-shift-right

• (unsigned-bit-shift-right x shift)

Shift bits right and set most significant bit to 0

source

---

unuse-primitive-operators

• (unuse-primitive-operators)
• (unuse-primitive-operators skip-set)

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

source

---

use-primitive-operators

• (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.

source

---

valid-double?

• (valid-double? v)

Check if a number is finite double.

source

---

vercos

• (vercos x)

Vercosine

source

---

versin

• (versin x)

Versine

source

---

wrap

• (wrap [start stop] value)
• (wrap start stop value)

Wrap overflowed value into the range, similar to ofWrap.

source

---

xexpx

• (xexpx x)

x * exp(x)

source

---

xexpy

• (xexpy x y)

x * exp(x)

source

---

xlog1py

• (xlog1py x y)

x * log(1+y)

source

---

xlogx

• (xlogx x)

x * log(x)

source

---

xlogy

• (xlogy x y)

x * log(y)

source

---

xor

• (xor x y)
• (xor x y & r)

Primitive boolean xor

source

---

zero?

• (zero? x)

Primitive and inlined zero?

source

---

source: clay/core.clj