fastmath.quaternion — generateme/fastmath 3.0.0-alpha2

-I clj

-J clj

-K clj

acos clj

(acos q)

acosh clj

(acosh q)

acot clj

(acot q)

acoth clj

(acoth q)

acsc clj

(acsc q)

acsch clj

(acsch q)

add clj

(add q1 q2)

Sum of two quaternions

arg clj

(arg quaternion)

Argument of quaternion, atan2(|vector(q)|, re(q))

asec clj

(asec q)

asech clj

(asech q)

asin clj

(asin q)

asinh clj

(asinh q)

atan clj

(atan q)

atanh clj

(atanh q)

complex->quaternion clj

(complex->quaternion z)

Create quaternion from complex number

conjugate clj

(conjugate quaternion)

Returns conjugate of quaternion

cos clj

(cos q)

cosh clj

(cosh q)

cot clj

(cot q)

coth clj

(coth q)

csc clj

(csc q)

csch clj

(csch q)

delta-eq clj

(delta-eq q1 q2)

(delta-eq q1 q2 accuracy)

Compare quaternions with given accuracy (10e-6 by default)

div clj

(div q1 q2)

Divide two quaternions

exp clj

(exp q)

from-angles clj

(from-angles [x y z])

(from-angles x y z)

Convert Tait–Bryan angles z-y′-x" to quaternion.

from-euler clj

(from-euler [roll pitch yaw])

(from-euler roll pitch yaw)

Convert Euler ZYX (body 3-2-1) representation to quaternion

Input should be 3d vector contating roll (x), pitch (y) and yaw (z) angles, or individual values.

• roll and yaw should be from [-pi, pi] range
• pitch should be from [-pi/2, pi/2] range

from-rotation-matrix clj

(from-rotation-matrix m)

Convert rotation 3x3 matrix to a quaternion

I clj

im-i clj

(im-i quaternion)

Return i imaginary part

im-j clj

(im-j quaternion)

Return j imaginary part

im-k clj

(im-k quaternion)

Return k imaginary part

imaginary? clj

(imaginary? quaternion)

Is q is a pure imaginary number?

inf? clj

(inf? quaternion)

Is infinitive?

J clj

K clj

log clj

(log q)

logb clj

(logb quaternion b)

log with base b

mult clj

(mult q1 q2)

Multiply two quaternions.

nan? clj

(nan? quaternion)

Is NaN?

neg clj

(neg quaternion)

Negation of quaternion.

norm clj

(norm quaternion)

Norm of the quaternion, length of the vector

normalize clj

(normalize quaternion)

Normalize quaternion

ONE clj

pow clj

(pow q p)

Quaternion power

qsgn clj

(qsgn q)

(qsgn re im-i im-j im-k)

sgn of the quaternion.

Returns 0 for 0+0i+0j+0k or calls m/sgn on real part otherwise.

quaternion clj

(quaternion a)

(quaternion scalar [i j k])

(quaternion a b c d)

Create quaternion from individual values or scalar and vector parts, reprezented as Vec4.

re clj

(re quaternion)

Returns scalar part of quaternion

real? clj

(real? quaternion)

Is q is a real number?

reciprocal clj

(reciprocal quaternion)

rotate clj

(rotate in rotq)

(rotate in angle u)

Rotate 3d in vector around axis u, the same as fastmath.vector/axis-rotate.

rotation-quaternion clj

(rotation-quaternion angle u)

Create rotation quaternion around vector u and angle alpha

scalar clj

(scalar quaternion)

Returns scalar part of quaternion, double

scale clj

(scale quaternion scale)

Scale the quaternion

sec clj

(sec q)

sech clj

(sech q)

sin clj

(sin q)

sinh clj

(sinh q)

slerp clj

(slerp q1 q2 t)

Interpolate quaternions

sq clj

(sq quaternion)

Square of quaternion.

sqrt clj

(sqrt q)

sub clj

(sub q1 q2)

Difference of two quaternions

tan clj

(tan q)

tanh clj

(tanh q)

to-angles clj

(to-angles q)

Convert quaternion to Tait–Bryan angles, z-y′-x".

to-euler clj

(to-euler q)

Convert quaternion to Euler ZYX (body 3-2-1). Quaternion will be normalized before calculations.

Output will contain roll (x), pitch (y) and yaw (z) angles.

to-rotation-matrix clj

(to-rotation-matrix q)

Convert quaternion to rotation 3x3 matrix

vector clj

(vector quaternion)

Returns vector part of quaternion, Vec3 type

ZERO clj

zero? clj

(zero? quaternion)

Is zero?