fastmath.core — generateme/fastmath 3.0.0-alpha1

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.

* clj

(*)

(* a)

(* a b)

(* a b c)

(* a b c d)

(* a b c d & r)

Primitive and inlined *.

+ clj

(+)

(+ a)

(+ a b)

(+ a b c)

(+ a b c d)

(+ a b c d & r)

Primitive and inlined +.

- clj

(- a)

(- a b)

(- a b c)

(- a b c d)

(- a b c d & r)

Primitive and inlined -.

-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

(/ a)

(/ a b)

(/ a b c)

(/ a b c d)

(/ a b c d & r)

Primitive and inlined /.

< clj

(< _)

(< a b)

(< a b & r)

Primitive math less-then function.

<< clj

(<< x shift)

Shift bits left

<= clj

(<= _)

(<= a b)

(<= a b & r)

Primitive math less-and-equal function.

== clj

(== _)

(== a b)

(== a b & r)

Primitive math equality function.

> clj

(> _)

(> a b)

(> a b & r)

Primitive math greater-than function.

>= clj

(>= _)

(>= a b)

(>= a b & r)

Primitive math greater-and-equal function.

>> clj

(>> x shift)

Shift bits right and keep most significant bit unchanged

>>> clj

(>>> x shift)

Shift bits right and set most significant bit to 0

abs clj

(abs x)

Primitive and inlined version of abs.

acos clj

(acos x)

acos(x)

acosh clj

(acosh x)

acosh(x)

acot clj

(acot x)

acot(x)

acoth clj

(acoth x)

Area hyperbolic cotangent

acovercos clj

(acovercos x)

Arc covercosine

acoversin clj

(acoversin x)

Arc coversine

acrd clj

(acrd x)

Inverse chord

acsc clj

(acsc x)

acsc(x)

acsch clj

(acsch v)

Area hyperbolic cosecant

aexcsc clj

(aexcsc x)

Arc excosecant

aexsec clj

(aexsec x)

Arc exsecant

ahacovercos clj

(ahacovercos x)

Arc hacovercosine

ahacoversin clj

(ahacoversin x)

Arc hacoversine

ahavercos clj

(ahavercos x)

Arc havecosine

ahaversin clj

(ahaversin x)

Arc haversine

approx clj

(approx v)

(approx v digits)

Round v to specified (default: 2) decimal places. Be aware of floating point 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 x)

asec(x)

asech clj

(asech x)

Area hyperbolic secant

asin clj

(asin x)

asin(x)

asinh clj

(asinh x)

asinh(x)

atan clj

(atan x)

atan(x)

atan2 clj

(atan2 x y)

atan2(x,y)

atanh clj

(atanh x)

atanh(x)

avercos clj

(avercos x)

Arc vecosine

aversin clj

(aversin x)

Arc versine

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

(bit-and x)

(bit-and x y)

(bit-and x y & r)

x ∧ y - bitwise AND

bit-and-not clj

(bit-and-not x)

(bit-and-not x y)

(bit-and-not x y & r)

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

bit-clear clj

(bit-clear x bit)

Clear bit (set to 0).

bit-flip clj

(bit-flip x bit)

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

bit-nand clj

(bit-nand x)

(bit-nand x y)

(bit-nand x y & r)

~(x ∧ y) - bitwise NAND

bit-nor clj

(bit-nor x)

(bit-nor x y)

(bit-nor x y & r)

~(x ∨ y) - bitwise NOR

bit-not clj

(bit-not x)

~x - bitwise NOT

bit-or clj

(bit-or x)

(bit-or x y)

(bit-or x y & r)

x ∨ y - bitwise OR

bit-set clj

(bit-set x bit)

Set bit (set to 1).

bit-shift-left clj

(bit-shift-left x shift)

Shift bits left

bit-shift-right clj

(bit-shift-right x shift)

Shift bits right and keep most significant bit unchanged

bit-test clj

(bit-test x bit)

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

bit-xnor clj

(bit-xnor x)

(bit-xnor x y)

(bit-xnor x y & r)

~(x⊕y) - bitwise XNOR

bit-xor clj

(bit-xor x)

(bit-xor x y)

(bit-xor x y & r)

x⊕y - bitwise XOR

bits->double clj

(bits->double v)

Convert 64 bits to double

bool-not clj

(bool-not x)

Primitive boolean not

bool-xor clj

(bool-xor x y)

(bool-xor x y & r)

Primitive boolean xor

CATALAN_G clj

Catalan G

cb clj

(cb x)

\(x^3\)

cbrt clj

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

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

(copy-sign magnitude sign)

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

cos clj

(cos x)

cos(x)

cos-interpolation clj

(cos-interpolation start stop t)

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

cosh clj

(cosh x)

cosh(x)

cospi clj

(cospi x)

cos(pi*x)

cot clj

(cot x)

cot(x)

coth clj

(coth x)

Hyperbolic cotangent

cotpi clj

(cotpi x)

cot(pi*x)

covercos clj

(covercos x)

Covercosine

coversin clj

(coversin x)

Coversine

crd clj

(crd x)

Chord

csc clj

(csc x)

csc(x)

csch clj

(csch x)

Hyperbolic cosecant

cscpi clj

(cscpi x)

csc(pi*x)

cut clj

(cut data breaks)

(cut x1 x2 breaks)

Cut range or sequence into intervals

dec clj

(dec x)

Primitive and inlined dec

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.

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 & r)

Primitive math equality function.

even? clj

(even? x)

Primitive and inlined even?

excsc clj

(excsc x)

Excosecant

exp clj

(exp x)

exp(x) = e^x

expexp clj

(expexp x)

exp(-exp(-x))

expm1 clj

(expm1 x)

exp(x)-1 for small x

exsec clj

(exsec x)

Exsecant

factorial clj

(factorial n)

Factorial

factorial20 clj

(factorial20 n)

Factorial table up to 20!

falling-factorial clj

(falling-factorial n x)

Falling (descending) factorial.

falling-factorial-int clj

(falling-factorial-int n x)

Falling (descending) factorial for integer n.

fast* clj deprecated

(fast*)

(fast* a)

(fast* a b)

(fast* a b & r)

Primitive and inlined * as a function

fast+ clj deprecated

(fast+)

(fast+ a)

(fast+ a b)

(fast+ a b & r)

Primitive and inlined + as a function

fast- clj deprecated

(fast-)

(fast- a)

(fast- a b)

(fast- a b & r)

Primitive and inlined - as a function

fast-div clj deprecated

(fast-div)

(fast-div a)

(fast-div a b)

(fast-div a b & r)

Primitive and inlined / as a function

fast-identity clj deprecated

(fast-identity a)

Identity on double.

fast-max clj deprecated

(fast-max a)

(fast-max a b)

(fast-max a b & r)

Primitive and inlined max as a function

fast-min clj deprecated

(fast-min a)

(fast-min a b)

(fast-min a b & r)

Primitive and inlined min as a 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

(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

(fpow x exponent)

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

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

Hacovercosine

hacoversin clj

(hacoversin x)

Hacoversine

HALF_PI clj

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

havercos clj

(havercos x)

Havercosine

haversin clj

(haversin x)

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

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

iabs clj deprecated

(iabs x)

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

identity-double clj

(identity-double a)

Identity on double.

identity-long clj

(identity-long a)

Identity on double.

inc clj

(inc x)

Primitive and inlined inc

inf? clj

(inf? v)

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

integer? clj

(integer? v)

Check if given real number is an integer.

inv-factorial clj

(inv-factorial n)

Inverse of factorial, 1/n!

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{2\pi}}\)

INV_SQRT_2 clj

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

INV_SQRTPI clj

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

INV_TWO_PI clj

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

invalid-double? clj

(invalid-double? v)

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

itrunc clj

(itrunc v)

Truncate fractional part, keep sign. Returns long.

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

(ln x)

log(x)=ln(x)

LN10 clj

\(\ln{10}\)

LN2 clj

\(\ln{2}\)

LN2_2 clj

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

log clj

(log x)

(log base x)

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

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

log10 clj

(log10 x)

log_10(x)

LOG10E clj

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

log1mexp clj

(log1mexp x)

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

log1p clj

(log1p x)

log(1+x) for small x

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

loglog clj

(loglog x)

-log(-log(x))

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

long-abs clj

(long-abs x)

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

long-add clj

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

long-dec clj

(long-dec x)

Primitive and inlined dec coerced to a long

long-div clj

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

long-inc clj

(long-inc x)

Primitive and inlined inc coerced to a long

long-max clj

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

long-min clj

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

long-mod clj

(long-mod x y)

Primitive and inlined mod coerced to longs

long-mult clj

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

long-quot clj

(long-quot x y)

Primitive and inlined quot coerced to longs

long-rem clj

(long-rem x y)

Primitive and inlined rem coerced to longs

long-sub clj

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

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

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

MACHINE-EPSILON10 clj

5*ULP(1)

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

(max a)

(max a b)

(max a b c)

(max a b c d)

(max a b c d & r)

Primitive and inlined max.

min clj

(min a)

(min a b)

(min a b c)

(min a b c d)

(min a b c d & r)

Primitive and inlined min.

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

(mod x y)

Primitive and inlined mod

muladd clj

(muladd x y z)

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

nan? clj

(nan? v)

Check if a number is a 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 a number is negatively infinite.

neg? clj

(neg? x)

Primitive and inlined neg?

negative-zero? clj

(negative-zero? x)

Check if zero is negative, ie. -0.0

negmuladd clj

(negmuladd x y z)

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

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

(not-neg? x)

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

not-pos? clj

(not-pos? x)

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

not== clj

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

odd? clj

(odd? x)

Primitive and inlined odd?

one? clj

(one? x)

Primitive and inlined one? (x==1.0)

ONE_SIXTH clj

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

ONE_THIRD clj

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

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 a number is positively infinite.

pos? clj

(pos? x)

Primitive and inlined pos?

pow clj

(pow x exponent)

Power of a number

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

(qceil x)

Fast version of ceil. Returns long.

qcos clj

(qcos x)

Fast and less accurate cos(x)

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

(qexp x)

Quick and less accurate version of exp.

qfloor clj

(qfloor x)

Fast version of floor. Returns long.

qlog clj

(qlog x)

Fast and less accurate version of log.

qpow clj

(qpow x exponent)

Fast and less accurate version of pow.

qround clj

(qround x)

Fast version of round. Returns long

qsin clj

(qsin x)

Fast and less accurate sin(x)

qsqrt clj

(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

(quot x y)

Primitive and inlined quot

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

rem clj

(rem x y)

Primitive and inlined rem

remainder clj

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

rint clj

(rint x)

(rint x scale)

Round to double. See round, qround.

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

rising-factorial clj

(rising-factorial n x)

Rising (Pochhammer) factorial.

rising-factorial-int clj

(rising-factorial-int n x)

Rising (Pochhammer) factorial for integer n.

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

(rqsqrt x)

Reciprocal 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 x)

sec(x)

sech clj

(sech x)

Hyperbolic secant

secpi clj

(secpi x)

sec(pi*x)

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.

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.

SILVER clj

Silver ratio \(\delta_S\)

sin clj

(sin x)

sin(x)

sinc clj

(sinc v)

Sinc function.

sinh clj

(sinh x)

sinh(x)

sinpi clj

(sinpi x)

sin(pi*x)

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

(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_2_PI clj

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

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

(tan x)

tan(x)

tanh clj

(tanh x)

tanh(x)

tanpi clj

(tanpi x)

tan(pi*x)

TAU clj

Alias for TWO_PI

THIRD clj

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

THIRD_PI clj

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

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

TWO_THIRDS clj

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

ulp clj

(ulp x)

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

unsigned-bit-shift-right clj

(unsigned-bit-shift-right x shift)

Shift bits right and set most significant bit to 0

unuse-primitive-operators clj

(unuse-primitive-operators)

(unuse-primitive-operators skip-set)

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 a number is finite double.

vercos clj

(vercos x)

Vercosine

versin clj

(versin x)

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)

xor clj

(xor x y)

(xor x y & r)

Primitive boolean xor

zero? clj

(zero? x)

Primitive and inlined zero?