fastmath.vector — generateme/fastmath 3.0.0-alpha4

Provides mathematical vector operations for various vector types, inspired by libraries like Processing and openFrameworks.

Supported vector representations include:

• Fixed-size custom types: Vec2 (2D), Vec3 (3D), Vec4 (4D), and ArrayVec (N-dimensional wrapper around double[]).
• Built-in array type: double arrays ([D).
• Variable-size Clojure collections: persistent vectors ([]) and sequences (ISeq).
• Numbers: Treated as 1D vectors.

Most operations are defined via the [[VectorProto]] protocol, which is extended for all supported types.

These vector types also implement standard Clojure/Java protocols like Seqable, Indexed, IFn, Counted, Associative, IReduce, ILookup, etc., enabling them to be used flexibly as sequences, arrays, or functions.

abs clj

(abs v)

Absolute value of vector elements

acos clj

(acos vector)

Applies acos to vector elements.

acosh clj

(acosh vector)

Applies acosh to vector elements.

acot clj

(acot vector)

Applies acot to vector elements.

acoth clj

(acoth vector)

Applies acoth to vector elements.

acsc clj

(acsc vector)

Applies acsc to vector elements.

acsch clj

(acsch vector)

Applies acsch to vector elements.

add clj

(add v)

(add v1 v2)

Sum of two vectors.

aligned? clj

(aligned? v1 v2)

(aligned? v1 v2 tol)

Checks if two vectors are aligned, meaning they point in approximately the same direction. This is determined by checking if the angle between them (calculated using angle-between) is less than the specified tolerance.

Defaults to an absolute tolerance of 1.0e-6.

angle-between clj

(angle-between v1 v2)

Returns the angle between two vectors in radians.

The angle is always positive and lies between 0 and π. Returns 0 if either vector is zero.

applyf clj deprecated

Same as fmap. Deprecated.

approx clj

(approx v)

(approx v d)

Rounds to d (default: 2) decimal places

array->vec2 clj

(array->vec2 arr)

Converts doubles array to Vec2

array->vec3 clj

(array->vec3 arr)

Converts doubles array to Vec3

array->vec4 clj

(array->vec4 arr)

Converts doubles array to Vec4

array-vec clj

(array-vec xs)

Creates ArrayVec type based on provided sequence xs.

as-vec clj

(as-vec v)

(as-vec v xs)

Creates vector from sequence as given type. If there is no sequence fill with 0.0.

asec clj

(asec vector)

Applies asec to vector elements.

asech clj

(asech vector)

Applies asech to vector elements.

asin clj

(asin vector)

Applies asin to vector elements.

asinh clj

(asinh vector)

Applies asinh to vector elements.

atan clj

(atan vector)

Applies atan to vector elements.

atanh clj

(atanh vector)

Applies atanh to vector elements.

average clj

(average v)

(average v weights)

Mean or weighted average of the vector

average-vectors clj

(average-vectors vs)

(average-vectors init vs)

Average / centroid of vectors. Input: initial vector (optional), list of vectors

axis-rotate clj

(axis-rotate v angle axis)

(axis-rotate v angle axis pivot)

Rotates vector. Only for Vec3 types

base-from clj

(base-from v)

List of perpendicular vectors (basis). Works only for Vec2 and Vec3 types.

cb clj

(cb vector)

Applies cb to vector elements.

cbrt clj

(cbrt vector)

Applies cbrt to vector elements.

ceil clj

(ceil vector)

Applies ceil to vector elements.

clamp clj

(clamp v)

(clamp v mn mx)

Clamps the elements of vector v element-wise between a minimum (mn) and maximum (mx) value.

In the single-arity version [v], elements are clamped between 0.0 and Double/MAX_VALUE.

cos clj

(cos vector)

Applies cos to vector elements.

cosh clj

(cosh vector)

Applies cosh to vector elements.

cot clj

(cot vector)

Applies cot to vector elements.

coth clj

(coth vector)

Applies coth to vector elements.

cross clj

(cross v1 v2)

Cross product

csc clj

(csc vector)

Applies csc to vector elements.

csch clj

(csch vector)

Applies csch to vector elements.

degrees clj

(degrees vector)

Applies degrees to vector elements.

delta-eq clj

(delta-eq v1 v2)

(delta-eq v1 v2 abs-tol)

(delta-eq v1 v2 abs-tol rel-tol)

Equality with given absolute (and/or relative) toleance.

dhash-code clj

(dhash-code a)

(dhash-code state a)

double hashcode

differences clj

(differences v)

(differences v diffs)

(differences v diffs lag)

Computes the lagged differences of a vector or sequence.

This function calculates the difference between elements separated by a fixed distance (lag) and can apply this operation diffs times.

It supports multiple arities:

• [v]: Computes the 1st difference with lag 1 (default: diffs=1, lag=1).
• [v diffs]: Computes the diffs-th difference with lag 1 (default: lag=1).
• [v diffs lag]: Computes the diffs-th difference with the specified lag.

Returns a sequence of the computed differences.

dist clj

(dist v1 v2)

Euclidean distance between vectors

dist-abs clj

(dist-abs v1 v2)

Manhattan distance between vectors

dist-ang clj

(dist-ang v1 v2)

Angular distance

dist-canberra clj

(dist-canberra v1 v2)

Canberra distance

dist-cheb clj

(dist-cheb v1 v2)

Chebyshev distance between 2d vectors

dist-discrete clj

(dist-discrete v1 v2)

(dist-discrete v1 v2 eps)

Computes the discrete distance between two vectors v1 and v2.

This is the number of positions where the corresponding elements are considered different. With an optional absolute tolerance eps, elements at index i are considered different if |v1_i - v2_i| > eps.

Returns the count of differing elements.

dist-emd clj

(dist-emd v1 v2)

Earth Mover's Distance

dist-sq clj

(dist-sq v1 v2)

Squared Euclidean distance between vectors

distances clj

div clj

(div v1)

(div v1 v)

Vector division or reciprocal.

dot clj

(dot v1 v2)

Dot product of two vectors.

econstrain clj

(econstrain v mn mx)

Element-wise constrain

edelta-eq clj

(edelta-eq v1 v2)

(edelta-eq v1 v2 abs-tol)

(edelta-eq v1 v2 abs-tol rel-tol)

Element-wise equality with given absolute (and/or relative) toleance.

ediv clj

(ediv v1 v2)

Element-wise division of two vectors.

einterpolate clj

(einterpolate v1 v2 v)

(einterpolate v1 v2 v f)

Interpolates vector selement-wise, optionally set interpolation fn (default: lerp)

emn clj

(emn v1 v2)

Element-wise min from two vectors.

emult clj

(emult v1)

(emult v1 v2)

Element-wise vector multiplication (Hadamard product).

emx clj

(emx v1 v2)

Element-wise max from two vectors.

exp clj

(exp vector)

Applies exp to vector elements.

expm1 clj

(expm1 vector)

Applies expm1 to vector elements.

faceforward clj

(faceforward n v)

Flips vector n if dot(n, v) is negative. Returns n if dot(n, v) is non-negative. Useful for ensuring consistent vector orientation, such as making a normal vector face towards a reference vector v.

floor clj

(floor vector)

Applies floor to vector elements.

fmap clj

(fmap v f)

Applies function to all vector values (like map but returns the same type).

frac clj

(frac vector)

Applies frac to vector elements.

from-polar clj

(from-polar v)

From polar coordinates (2d, 3d only)

generate-vec2 clj

(generate-vec2 f)

(generate-vec2 f1 f2)

Generates Vec2 with fn(s)

generate-vec3 clj

(generate-vec3 f)

(generate-vec3 f1 f2 f3)

Generates Vec3 with fn(s)

generate-vec4 clj

(generate-vec4 f)

(generate-vec4 f1 f2 f3 f4)

Generates Vec4 with fn(s)

heading clj

(heading v)

Angle between vector and unit vector [1,0,...]

interpolate clj

(interpolate v1 v2 t)

(interpolate v1 v2 t f)

Interpolates vectors, optionally set interpolation fn (default: lerp)

is-near-zero? clj

(is-near-zero? v)

(is-near-zero? v abs-tol)

(is-near-zero? v abs-tol rel-tol)

Equality to zero 0 with given absolute (and/or relative) toleance.

is-zero? clj

(is-zero? v)

Is vector zero?

lerp clj

(lerp v1 v2 t)

Linear interpolation of vectors

limit clj

(limit v len)

Limits length of the vector by given value

ln clj

(ln vector)

Applies ln to vector elements.

log clj

(log vector)

Applies log to vector elements.

log10 clj

(log10 vector)

Applies log10 to vector elements.

log1mexp clj

(log1mexp vector)

Applies log1mexp to vector elements.

log1p clj

(log1p vector)

Applies log1p to vector elements.

log1pexp clj

(log1pexp vector)

Applies log1pexp to vector elements.

log1pmx clj

(log1pmx vector)

Applies log1pmx to vector elements.

log1psq clj

(log1psq vector)

Applies log1psq to vector elements.

log2 clj

(log2 vector)

Applies log2 to vector elements.

logexpm1 clj

(logexpm1 vector)

Applies logexpm1 to vector elements.

logit clj

(logit vector)

Applies logit to vector elements.

logmeanexp clj

(logmeanexp v)

Calculates the numerically stable log of the mean of the exponential of each element in vector v.

This is equivalent to log(mean(exp(v_i))) for all elements v_i in v. It provides a numerically stable way to compute log(sum(exp(v_i))) - log(count(v)) by shifting values to prevent overflow during exponentiation.

Often used in machine learning and statistical contexts where dealing with large values inside exponentials is common.

Returns a double value.

logmxp1 clj

(logmxp1 vector)

Applies logmxp1 to vector elements.

logsoftmax clj

(logsoftmax v)

(logsoftmax v t)

Calculates the element-wise natural logarithm of the softmax function for the given vector v.

The standard log-softmax of an element $v_i$ is $\log(\operatorname{softmax}(v)_i)$, which is mathematically equivalent to $v_i - \log(\sum_j \exp(v_j))$. This function provides a numerically stable implementation of this calculation, particularly useful for avoiding overflow and underflow issues when dealing with large or small exponential values.

It supports two arities:

• [v]: Computes the standard log-softmax using the numerically stable form.
• [v t]: Computes the temperature-scaled log-softmax. Elements are divided by the temperature t before applying the log-softmax formula, i.e., $\frac{v_i}{t} - \log(\sum_j \wxp(\fac{v_j}{t}))$. The temperature influences the shape of the corresponding softmax output distribution: $t > 1$ softens it, $t < 1$ sharpens it.

Log-softmax is frequently used in numerical computations, especially in machine learning (e.g., as part of the cross-entropy loss function) for its superior numerical properties.

Returns a new vector of the same type and dimension as the input.

logsumexp clj

(logsumexp v)

Calculates the LogSumExp of the vector v.

This is the numerically stable computation of log(sum(exp(x_i))) for all elements x_i in v. It is often used to prevent overflow when exponentiating large numbers, especially in machine learning and statistics.

Returns a double value.

mag clj

(mag v)

Returns length of the vector.

magsq clj

(magsq v)

Returns length of the vector squared.

make-vector clj

(make-vector dims)

(make-vector dims xs)

Returns fixed size vector for given number of dimensions.

Proper type is used.

maxdim clj

(maxdim v)

Index of maximum value.

mindim clj

(mindim v)

Index of minimum value.

mn clj

(mn v)

Minimum value of vector elements

mult clj

(mult v)

(mult v x)

Multiplies vector by number x.

mx clj

(mx v)

Maximum value of vector elements

near-zero? clj

(near-zero? v)

(near-zero? v abs-tol)

(near-zero? v abs-tol rel-tol)

Equality to zero 0 with given absolute (and/or relative) toleance.

nonzero-count clj

(nonzero-count v)

Counts non zero velues in vector

normalize clj

(normalize v)

Returns a new vector with the same direction as v but with a magnitude of 1.

If v is a zero vector (magnitude is zero), returns a zero vector of the same type.

orthogonal-polynomials clj

(orthogonal-polynomials xs)

Generates a sequence of orthogonal vectors by evaluating orthogonal polynomials at the points specified in the input sequence xs.

The output vectors represent the values of orthogonal polynomials evaluated at the elements of xs. Orthogonality is defined with respect to the discrete inner product based on summation over the points in xs.

The sequence starts with the vector for the polynomial of degree 1 and includes vectors up to degree (count xs) - 1.

This function is useful for constructing orthogonal bases for polynomial approximation or regression on discrete data.

orthonormal-polynomials clj

(orthonormal-polynomials xs)

Generates a sequence of orthonormal vectors by evaluating orthogonal polynomials at the points specified in the input sequence xs and normalizing the resulting vectors.

The sequence starts with the vector for the polynomial of degree 1 and includes vectors up to degree (count xs) - 1. Orthogonality (and thus orthonormality after normalization) is with respect to the discrete inner product based on summation over the points in xs.

This function produces an orthonormal basis suitable for polynomial approximation or regression on discrete data points defined by xs, derived from the orthogonal basis computed by orthogonal-polynomials.

permute clj

(permute v idxs)

Permutes vector elements with given indices.

perpendicular clj

(perpendicular v)

(perpendicular v1 v2)

Perpendicular vector. Only for Vec2 and Vec3 types.

pow clj

(pow v exponent)

Applies power to a vector elements.

pow10 clj

(pow10 vector)

Applies pow10 to vector elements.

prod clj

(prod)

(prod v)

Product of elements

project clj

(project v1 v2)

Calculates the vector projection of v1 onto v2. The projection is a vector along the direction of v2 that represents the component of v1 in that direction.

radians clj

(radians vector)

Applies radians to vector elements.

real-vector clj

(real-vector v)

Converts to Apache Commons Math RealVector

reciprocal clj

(reciprocal v)

Reciprocal of elements.

relative-angle-between clj

(relative-angle-between v1 v2)

Returns the difference between the heading of v2 and the heading of v1. The heading is the angle relative to the positive primary axis ([1,0,...]). For 2D vectors, this is the difference between their polar angles.

Returns value from $-2\pi$ to $2\pi$.

See also angle-between (absolute angle between vectors) and heading.

rint clj

(rint vector)

Applies rint to vector elements.

rotate clj

(rotate v angle)

(rotate v angle-x angle-y angle-z)

Rotates vector. Only for Vec2 and Vec3 types.

round clj

(round vector)

Applies round to vector elements.

safe-sqrt clj

(safe-sqrt vector)

Applies safe-sqrt to vector elements.

sec clj

(sec vector)

Applies sec to vector elements.

sech clj

(sech vector)

Applies sech to vector elements.

seq->vec2 clj

(seq->vec2 xs)

Converts any seq to Vec2

seq->vec3 clj

(seq->vec3 xs)

Converts any seq to Vec3

seq->vec4 clj

(seq->vec4 xs)

Converts any seq to Vec4

set-mag clj

(set-mag v len)

Sets length of the vector.

sfrac clj

(sfrac vector)

Applies sfrac to vector elements.

sgn clj

(sgn vector)

Applies sgn to vector elements.

shift clj

(shift v)

(shift v x)

Adds a value to every vector element.

sigmoid clj

(sigmoid vector)

Applies sigmoid to vector elements.

signum clj

(signum vector)

Applies signum to vector elements.

sim-cos clj

(sim-cos v1 v2)

Cosine similarity

sin clj

(sin vector)

Applies sin to vector elements.

sinc clj

(sinc vector)

Applies sinc to vector elements.

sinh clj

(sinh vector)

Applies sinh to vector elements.

size clj

(size v)

Returns elements count of the vector.

softmax clj

(softmax v)

(softmax v t)

Calculates the softmax function for the given vector v.

The softmax function transforms a vector of arbitrary real values into a probability distribution, where each element is a value between 0 and 1, and all elements sum to 1.

It has two arities:

• [v]: Computes the standard softmax: softmax(v)_i = exp(v_i) / sum_j(exp(v_j)).
• [v t]: Computes the temperature-scaled softmax: softmax(v)_i = exp(v_i / t) / sum_j(exp(v_j / t)). The t parameter (temperature, defaults to 1) controls the shape of the output distribution; higher temperatures produce softer, more uniform distributions, while lower temperatures produce sharper distributions closer to a one-hot encoding.

The implementation uses a numerically stable approach (by shifting values based on the vector's maximum) to prevent overflow when exponentiating large numbers.

Returns a new vector of the same type and dimension as the input.

sq clj

(sq vector)

Applies sq to vector elements.

sqrt clj

(sqrt vector)

Applies sqrt to vector elements.

sub clj

(sub v)

(sub v1 v2)

Subtraction of two vectors.

sum clj

(sum)

(sum v)

Sum of elements

tan clj

(tan vector)

Applies tan to vector elements.

tanh clj

(tanh vector)

Applies tanh to vector elements.

to-polar clj

(to-polar v)

To polar coordinates (2d, 3d only), first element is length, the rest angle.

to-vec clj deprecated

Same as vec->Vec. Deprecated.

transform clj

(transform v o vx vy)

(transform v o vx vy vz)

Transforms vector.

Maps point to a coordinate system defined by origin, vx, vy and vz (as bases).

Only for Vec2 and Vec3 types.

triple-product clj

(triple-product a b c)

a o (b x c)

trunc clj

(trunc vector)

Applies trunc to vector elements.

vec->array clj

(vec->array v)

Converts to double array

vec->RealVector clj

(vec->RealVector v)

Converts to Apache Commons Math RealVector

vec->seq clj

(vec->seq v)

Converts to sequence (same as seq)

vec->Vec clj

(vec->Vec v)

Converts to Clojure primitive vector Vec.

vec2 clj

(vec2)

(vec2 [x y])

(vec2 x y)

Creates 2d vector.

vec3 clj

(vec3)

(vec3 [x y z])

(vec3 v z)

(vec3 x y z)

Creates Vec2 vector

vec4 clj

(vec4)

(vec4 [x y z w])

(vec4 v w)

(vec4 v z w)

(vec4 x y z w)

Creates Vec4 vector

xlogx clj

(xlogx vector)

Applies xlogx to vector elements.

zero-count clj

(zero-count v)

Counts zeros in vector

zero? clj

(zero? v)

Is vector zero?