fastmath.core — generateme/fastmath 3.0.0-alpha4

High-performance mathematical functions and constants for Clojure, optimized for primitive double and long types.

Key features:

• Most functions are specialized for primitive types (double and long) and are inlined for performance.
• Primarily backed by the FastMath library and custom primitive implementations.
• Provides an option to replace clojure.core's standard numerical operators with primitive-specialized macros.

This namespace contains functions for:

• Basic arithmetic (+, -, *, /, etc.)
• Comparisons and predicates (==, <, zero?, pos?, etc.)
• Bitwise operations
• Trigonometric and hyperbolic functions
• Exponents, logarithms, and powers
• Floating-point specific operations (ulp, bits manipulation)
• Combinatorics (factorial, combinations)
• Distance calculations
• Interpolation and mapping
• Utility functions (gcd, lcm, error calculation, etc.)

Primitive Math Operators:

A set of inlined macros designed to replace selected clojure.core arithmetic, comparison, and bitwise operators for potential performance gains with primitive arguments. These macros operate on double and long primitives and generally return primitive values.

Replaced operators:

• * + - / > < >= <= == 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
• Additionally: << >> >>> not==

To enable these primitive operators in your namespace, call use-primitive-operators. To revert to the original clojure.core functions, call unuse-primitive-operators. Note that the fastmath.core versions are not a complete drop-in replacement due to their primitive-specific behavior (e.g., return types), and calling unuse-primitive-operators at the end of the namespace is recommended, especially in Clojure 1.12+.

* 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 $-\mathrm{e}$

-HALF_PI clj

Value of $\frac{\pi}{2}$

-PI clj

Value of $-\pi$

-QUARTER_PI clj

Value of $\frac{\pi}{4}$

-TAU clj

Value of $-2\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)

Absolute value.

absolute-error clj

(absolute-error v v-approx)

Absolute error between two values

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 up to selected number of digits (2 by default).

It can be innacurate due to the algorithm used. Use delta-eq instead.

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)

cubic root, cbrt(x)

ceil clj

(ceil x)

(ceil x scale)

Calculates the ceiling of a number.

With a scale argument, rounds to the nearest multiple of scale towards positive infinity.

See also: qceil.

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)

Divides a sequence of numerical data into number (default 6) overlapping intervals.

The intervals are constructed such that each contains a similar number of values from the sorted data, aiming to replicate the behavior of R's co.intervals() function. Invalid doubles (NaN, infinite) are removed from the input data before processing.

Arguments:

• data: A collection of numbers.
• number: The desired number of intervals (default 6, long).
• overlap: The desired overlap proportion between consecutive intervals (default 0.5, double).

Returns a sequence of intervals, where each interval is represented as a 2-element vector [lower-bound upper-bound].

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)

Divides a numerical range or a sequence of numbers into a specified number of equally spaced intervals.

Given data and breaks, the range is determined by the minimum and maximum finite values in data. Invalid doubles (NaN, infinite) are ignored. Given x1, x2, and breaks, the range is explicitly [x1, x2].

The function generates breaks + 1 equally spaced points within the range using slice-range, and then forms breaks intervals from these points.

The intervals are returned as a sequence of 2-element vectors [lower-bound upper-bound]. Specifically, if the generated points are p0, p1, ..., p_breaks, the intervals are formed as: [[(prev-double p0), p1], [p1, p2], ..., [p_breaks-1, p_breaks]].

This means intervals are generally closed on the right, [a, b], with the first interval's lower bound slightly adjusted downwards to ensure inclusion of the exact minimum value if necessary due to floating point precision.

Arguments:

• data: A collection of numbers (used to determine range).
• x1, x2: The start and end points of the range.
• breaks: The desired number of intervals (a positive long).

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 if two floating-point numbers a and b are approximately equal within given tolerances.

The check returns true if abs(a - b) is less than a combined tolerance, or if (== a b).

• 2-arity (delta-eq a b): Uses a default absolute tolerance of 1.0e-6.
• 3-arity (delta-eq a b abs-tol): Uses the provided absolute tolerance abs-tol.
• 4-arity (delta-eq a b abs-tol rel-tol): Uses both absolute and relative tolerances. The combined tolerance is max(abs-tol, rel-tol * max(abs(a), abs(b))).

This function is useful for comparing floating-point numbers where exact equality checks (==) may fail due to precision issues.

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

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 $\mathrm{e}$

EPSILON clj

$\varepsilon$, a small number

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

exp10 clj

(exp10 x)

exp10(x) = 10^x

exp2 clj

(exp2 x)

exp2(x) = 2^x

expexp clj

(expexp x)

exp(-exp(-x))

expm1 clj

(expm1 x)

exp(x)-1 for small x

exprel clj

(exprel x)

(exp(x)-1)/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)

Calculates the floor of a number.

With a scale argument, rounds to the nearest multiple of scale towards negative infinity.

See also: qfloor.

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

$\gamma$, 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)

Groups values from a sequence coll into specified intervals.

The function partitions the values in coll based on which interval they fall into. Each interval is a 2-element vector [lower upper]. Values are included in an interval if they are strictly greater than the lower bound and less than or equal to the upper bound, using between-?.

Arguments:

• intervals: A sequence of 2-element vectors representing the intervals [lower upper].
• coll: A collection of numerical values to be grouped.

If intervals are not provided, the function first calculates overlapping intervals using co-intervals from the values in coll, and then groups the values into these generated intervals.

Returns a map where keys are the interval vectors and values are sequences of the numbers from coll that fall within that interval.

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)

Finds the smallest integer n such that 2^n >= |x|. See low-2-exp.

high-exp clj

(high-exp b x)

Finds the smallest integer n such that b^n >= |x|. See also low-exp.

hypot clj

(hypot x y)

(hypot x y z)

Calculates the Euclidean norm (distance from the origin) for 2 or 3 arguments.

It uses a numerically stable algorithm to avoid intermediate overflow or underflow.

See also hypot-sqrt for the direct calculation.

hypot-sqrt clj

(hypot-sqrt x y)

(hypot-sqrt x y z)

Calculates the Euclidean norm (distance from the origin) using a direct sqrt of sum of squares.

Note: This method can be less numerically stable than hypot for inputs with vastly different magnitudes.

iabs clj deprecated

(iabs x)

Absolute value, long version. See abs.

identity-double clj

(identity-double a)

Identity on double.

identity-long clj

(identity-long a)

Identity on long.

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

INV_LN2 clj

Value of $\frac{1}{\ln{2}}$

INV_LOG_HALF clj

Value of $\frac{1}{\ln{\frac{1}{2}}}$

INV_PI clj

Value of $\frac{1}{\pi}$

INV_SQRT2PI clj

Value of $\frac{1}{\sqrt{2\pi}}$

INV_SQRT_2 clj

Value of $\frac{1}{\sqrt{2}}$

INV_SQRTPI clj

Value of $\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 of 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

Value of $\ln{10}$

LN2 clj

Value of $\ln{2}$

LN2_2 clj

Value of $\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}{\mathrm{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}{\mathrm{e}}$

log2int clj

(log2int v)

Fast and integer version of log2, returns long

log2mexp clj

(log2mexp x)

log(2-exp(x))

LOG_HALF clj

Value of $\ln{\frac{1}{2}}$

LOG_PI clj

Value of $\ln{\pi}$

LOG_TWO_PI clj

Value of $\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)

Absolut value, 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)

Finds the greatest integer n such that 2^n <= |x|. See high-2-exp.

low-exp clj

(low-exp b x)

Finds the greatest integer n such that b^n <= |x|. See also high-exp.

M_1_PI clj

Value of $\frac{1}{\pi}$

M_2_PI clj

Value of $\frac{2}{\pi}$

M_2_SQRTPI clj

Value of $\frac{2}{\sqrt\pi}$

M_3PI_4 clj

Value of $\frac{3\pi}{4}$

M_E clj

Value of $\mathrm{e}$

M_INVLN2 clj

Value of $\frac{1}{\ln{2}}$

M_IVLN10 clj

Value of $\frac{1}{\ln{10}}$

M_LN10 clj

Value of $\ln{10}$

M_LN2 clj

Value of $\ln{2}$

M_LOG10E clj

Value of $\log_{10}{e}$

M_LOG2_E clj

Value of $\ln{2}$

M_LOG2E clj

Value of $\log_{2}{e}$

M_PI clj

Value of $\pi$

M_PI_2 clj

Value of $\frac{\pi}{2}$

M_PI_4 clj

Value of $\frac{\pi}{4}$

M_SQRT1_2 clj

Value of $\frac{1}{\sqrt{2}}$

M_SQRT2 clj

Value of $\sqrt{2}$

M_SQRT3 clj

Value of $\sqrt{3}$

M_SQRT_PI clj

Value of $\sqrt\pi$

M_TWOPI clj

Value of $2\pi$

MACHINE-EPSILON clj

ulp(1)/2

MACHINE-EPSILON10 clj

5ulp(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

mpow clj

(mpow x e m)

Calculates the modular exponentiation $(x^e \pmod m)$.

Computes the remainder of x raised to the power of e, when divided by m. Uses binary exponentiation.

x: Base (long). e: Exponent (long, non-negative). m: Modulus (long, positive).

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-zero? clj

(not-zero? x)

Primitive and inlined x<>0.0

not== clj

(not== _)

(not== a b)

(not== a b & r)

Not equality. For more than two arguments, returns true when all values are unique.

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

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

Computes the permutation of indices that would sort the input collection vs.

The result is a sequence of 0-based indices such that applying them to the original collection using (map #(nth vs %) result) yields a sorted sequence.

Arguments:

• vs: A collection of comparable values.
• decreasing?: Optional boolean (default false). If true, the indices permute for a descending sort.

Returns: A sequence of 0-based indices.

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

pow10 clj

(pow10 x)

x^10

pow2 clj

(pow2 x)

x^2, x*x

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

Assigns ranks to values in a collection, handling ties according to a specified strategy. Ranks are 0-based indices indicating the position of each element in the sorted collection.

Arguments:

• vs: A collection of comparable values.
• ties: The tie-breaking strategy (keyword, optional, default :average). Supported strategies:
  • :average: Assign the average rank to all tied values.
  • :first: Assign ranks based on their appearance order in the input.
  • :last: Assign ranks based on their appearance order in the input (reverse of :first).
  • :random: Assign random ranks to tied values.
  • :min: Assign the minimum rank to all tied values.
  • :max: Assign the maximum rank to all tied values.
  • :dense: Assign consecutive ranks without gaps (like data.table::frank in R).
• desc?: If true, rank in descending order (boolean, optional, default false).

Returns a sequence of rank values corresponding to the input elements.

rank1 clj

relative-error clj

(relative-error v v-approx)

Relative error between two values

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 a double value. 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 a long value. See: rint, qround.

round-even clj

(round-even x)

Round evenly, IEEE / IEC rounding

round-up-pow2 clj

(round-up-pow2 v)

Rounds a positive long integer up to the smallest power of 2 greater than or equal to the input value.

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.

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

Samples a function f by evaluating it at evenly spaced points within a numerical range.

Generates number-of-values points in the specified range [domain-min, domain-max] (inclusive) and applies f to each point.

Arguments:

• f: The function to sample. Should accept a single double argument.
• number-of-values: The total number of points to generate (a positive long).
• domain-min: The lower bound of the sampling range (a double). Defaults to 0.0.
• domain-max: The upper bound of the sampling range (a double). Defaults to 1.0.
• domain?: A boolean flag. If true, returns pairs [x, (f x)]. If false (default), returns just (f x).

Arities:

• [f number-of-values]: Samples f in [0.0, 1.0]. Returns (f x) values.
• [f number-of-values domain?]: Samples f in [0.0, 1.0]. Returns [x, (f x)] pairs if domain? is true, otherwise (f x) values.
• [f domain-min domain-max number-of-values]: Samples f in [domain-min, domain-max]. Returns (f x) values.
• [f domain-min domain-max number-of-values domain?]: Samples f in [domain-min, domain-max]. Returns [x, (f x)] pairs if domain? is true, otherwise (f x) values.

The points are generated linearly from domain-min to domain-max. If number-of-values is 1, it samples only the midpoint of the range.

Returns a sequence of double values or vectors [double, double] depending on domain?.

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)

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

sigmoid clj

(sigmoid x)

Sigmoid function

signum clj

(signum value)

Returns 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 data cnt)

(slice-range start end cnt)

Generates cnt evenly spaced points within a numerical range.

• (slice-range cnt): Generates cnt points in the range [0.0, 1.0].
• (slice-range data cnt): Generates cnt points in the range [(min data), (max data)].
• (slice-range start end cnt): Generates cnt points in the range [start, end].

The range is inclusive, meaning the first point is start and the last is end (unless cnt is 1). If cnt is 1, it returns a single value which is the midpoint (start + end) / 2 of the range. Returns a sequence of cnt double values.

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.

spow clj

(spow x exponent)

Symmetric power of a number (keeping a sign of the argument.

sq clj

(sq x)

x^2, x*x

sqrt clj

(sqrt x)

square root, sqrt(x)

SQRT2 clj

Value of $\sqrt{2}$

SQRT2_2 clj

Value of $\frac{\sqrt{2}}{2}$

SQRT2PI clj

Value of $\sqrt{2\pi}$

SQRT3 clj

Value of $\sqrt{3}$

SQRT3_2 clj

Value of $\frac{\sqrt{3}}{2}$

SQRT3_3 clj

Value of $\frac{\sqrt{3}}{3}$

SQRT3_4 clj

Value of $\frac{\sqrt{3}}{4}$

SQRT5 clj

Value of $\sqrt{5}$

SQRT_2_PI clj

Value of $\sqrt{\frac{2}{\pi}}$

SQRT_HALFPI clj

Value of $\sqrt{\frac{1}{2}\pi}$

SQRTPI clj

Value of $\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

Value of $2\pi$

THIRD clj

Value of $\frac{1}{3}$

THIRD_PI clj

Value of $\frac{\pi}{3}$

tpow clj

(tpow x exponent)

(tpow x exponent shift)

Calculates truncated power.

For x >= shift returns (x-shift)^exponent, 0.0 otherwise.

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?