Module tkmath

Functions

• absd(Double a) : Double (tkmath) - Returns double precision absolute number
• absf(float a) : float (tkmath) - Returns single precision absolute number
• acoscd(Complexd a) : Complexd (tkmath) - Returns complex acos(a)
• acoscf(Complexf a) : Complexf (tkmath) - Returns complex acos(a)
• acosd(Double a) : Double (tkmath) - Calculate double precision acos(a)
• acosf(float a) : float (tkmath) - Calculate single precision acos(a)
• acoshcd(Complexd a) : Complexd (tkmath) - Returns complex acosh(a)
• acoshcf(Complexf a) : Complexf (tkmath) - Returns complex acosh(a)
• acoshd(Double a) : Double (tkmath) - Calculate double precision acosh(a)
• acoshf(float a) : float (tkmath) - Calculate single precision acosh(a)
• asincd(Complexd a) : Complexd (tkmath) - Returns complex asin(a)
• asincf(Complexf a) : Complexf (tkmath) - Returns complex asin(a)
• asind(Double a) : Double (tkmath) - Calculate double precision asin(a)
• asinf(float a) : float (tkmath) - Calculate single precision asin(a)
• asinhcd(Complexd a) : Complexd (tkmath) - Returns complex asinh(a)
• asinhcf(Complexf a) : Complexf (tkmath) - Returns complex asinh(a)
• asinhd(Double a) : Double (tkmath) - Calculate double precision asinh(a)
• asinhf(float a) : float (tkmath) - Calculate single precision asinh(a)
• atan2d(Double a, b) : Double (tkmath) - Calculate double precision atan(a/b), does not throw an exception when b is zero,
• atan2f(float a, b) : float (tkmath) - Calculate single precision atan(a/b), does not throw an exception when b is zero (but when a==b==0),
• atancd(Complexd a) : Complexd (tkmath) - Returns complex atan(a)
• atancf(Complexf a) : Complexf (tkmath) - Returns complex atan(a)
• atand(Double a) : Double (tkmath) - Calculate double precision atan(a)
• atanf(float a) : float (tkmath) - Calculate single precision atan(a)
• atanhcd(Complexd a) : Complexd (tkmath) - Returns complex atanh(a)
• atanhcf(Complexf a) : Complexf (tkmath) - Returns complex atanh(a)
• atanhd(Double a) : Double (tkmath) - Calculate double precision atanh(a)
• atanhf(float a) : float (tkmath) - Calculate single precision atanh(a)
• ceild(Double a) : Double (tkmath) - Returns next natural value to a
• ceilf(float a) : float (tkmath) - Returns next natural value to a
• complexd(Double a, b) : Complexd (tkmath) - Returns new instance with values x=a and y=b of (x+iy)
• complexf(float a, b) : Complexf (tkmath) - Returns new instance with values x=a and y=b of (x+iy)
• complexfPolar(float va, vb) : Complexf (tkmath) - Returns new instance with values r=va and a=vb of (re^ia)
• complexfPolar(Double va, vb) : Complexd (tkmath) - Returns new instance with values r=va and a=vb of (re^ia)
• coscd(Complexd a) : Complexd (tkmath) - Returns complex cos(a)
• coscf(Complexf a) : Complexf (tkmath) - Returns complex cos(a)
• cosd(Double a) : Double (tkmath) - Calculate double precision cos(a)
• cosf(float a) : float (tkmath) - Calculate single precision cos(a)
• coshcd(Complexd a) : Complexd (tkmath) - Returns complex cosh(a)
• coshcf(Complexf a) : Complexf (tkmath) - Returns complex cosh(a)
• coshd(Double a) : Double (tkmath) - Calculate double precision cosh(a)
• coshf(float a) : float (tkmath) - Calculate single precision cosh(a)
• exp10d(Double a) : Double (tkmath) - Returns 10^a
• exp10f(float a) : float (tkmath) - Returns 10^a
• exp2d(Double a) : Double (tkmath) - Returns 2^a
• exp2f(float a) : float (tkmath) - Returns 2^a
• expcd(Complexd a) : Complexd (tkmath) - Returns complex e^a
• expcf(Complexf a) : Complexf (tkmath) - Returns complex e^a
• expd(Double a) : Double (tkmath) - Returns e^a
• expf(float a) : float (tkmath) - Returns e^a
• f16_from_f32(float v) : int (tkmath) - Converts 32bit IEEE floating point value to 16bit float
• f32_from_f16(int v) : float (tkmath) - Converts 16bit float to 32bit IEEE floating point value
• floord(Double a) : Double (tkmath) - Returns previous natural value to a
• floorf(float a) : float (tkmath) - Returns previous natural value to a
• fx16_from_f16(int v) : int (tkmath) - Converts 16bit float to 32bit 16:16 fixed point value
• hypotd(Double a, b) : Double (tkmath) - Calculate double precision length of hypotenuse
• hypotf(float a, b) : float (tkmath) - Calculate single precision length of hypotenuse
• log10d(Double a) : Double (tkmath) - Returns log₁₀(a)
• log10f(float a) : float (tkmath) - Returns log₁₀(a)
• log2d(Double a) : Double (tkmath) - Returns log₂(a)
• log2f(float a) : float (tkmath) - Returns log₂(a)
• logcd(Complexd a) : Complexd (tkmath) - Returns complex log(a)
• logcf(Complexf a) : Complexf (tkmath) - Returns complex log(a)
• logd(Double a) : Double (tkmath) - Returns log(a)
• logf(float a) : float (tkmath) - Returns log(a)
• matrix2d(Double a, b, c, d) : Matrix2d (tkmath) - Initialize and return new instance of Matrix2d
• matrix2f(float va, vb, vc, vd) : Matrix2f (tkmath) - Initialise and return new instance of Matrix2f
• matrix2x3f(float a, b, c, d, e, f) : Matrix2x3f (tkmath) - Initialize and return new instance of Matrix2x3f
• matrix3d(Double va, vb, vc, vd, ve, vf, vg, vh, vi) : Matrix3d (tkmath) - Initialise and return new instance of Matrix3d
• matrix3f(float a, b, c, d, e, f, g, h, i) : Matrix3f (tkmath) - Initialize and return new instance of Matrix3f. The parameters are in matrix order (row(default) or column major).
• matrix4d(Object a) : Matrix4d (tkmath) - Initialize from an array and return new instance of Matrix4d
• matrix4f(Object a) : Matrix4f (tkmath) - Initialize from an array and return new instance of Matrix4f
• modd(Double a, b) : Double (tkmath) - Returns remainder of a/b
• modf(float a, b) : float (tkmath) - Returns remainder of a/b
• powcd(Complexd a, b) : Complexd (tkmath) - Returns complex a^b
• powcf(Complexf a, b) : Complexf (tkmath) - Returns complex a^b
• powd(Double a, b) : Double (tkmath) - Returns a^b
• powf(float a, b) : float (tkmath) - Returns a^b
• quaterniond(Double a, b, c, d) : Quaterniond (tkmath) - Init quaternion to a+ib+jc+kd and return new instance
• quaternionf(float a, b, c, d) : Quaternionf (tkmath) - Init quaternion to a+ib+jc+kd and return new instance
• relCmpd(Double a, b) : int (tkmath) - Do a fast relative comparison of Double values
• relCmpf(float a, b) : int (tkmath) - Do a fast relative comparison of float values
• relErrCmpd(Double a, b, err) : int (tkmath) - Does a relative comparison given a certain error range of Double values.
• relErrCmpf(float a, b, err) : int (tkmath) - Does a relative comparison given a certain error range of float values.
• roundd(Double a) : Double (tkmath) - Returns rounded value
• roundf(float a) : float (tkmath) - Returns rounded value
• sincd(Complexd a) : Complexd (tkmath) - Returns complex sin(a)
• sincf(Complexf a) : Complexf (tkmath) - Returns complex sin(a)
• sind(Double a) : Double (tkmath) - Calculate double precision sin(a)
• sinf(float a) : float (tkmath) - Calculate single precision sin(a)
• sinhcd(Complexd a) : Complexd (tkmath) - Returns complex sinh(a)
• sinhcf(Complexf a) : Complexf (tkmath) - Returns complex sinh(a)
• sinhd(Double a) : Double (tkmath) - Calculate double precision sinh(a)
• sinhf(float a) : float (tkmath) - Calculate single precision sinh(a)
• sqrtcd(Complexd a) : Complexd (tkmath) - Returns complex double precision √a
• sqrtcf(Complexf a) : Complexf (tkmath) - Returns complex single precision √a
• sqrtd(Double a) : Double (tkmath) - Returns √a
• sqrtf(float a) : float (tkmath) - Returns √a
• tancf(Complexf a) : Complexf (tkmath) - Returns complex tan(a)
• tancf(Complexd a) : Complexd (tkmath) - Returns complex tan(a)
• tand(Double a) : Double (tkmath) - Calculate double precision tan(a)
• tanf(float a) : float (tkmath) - Calculate single precision tan(a)
• tanhcd(Complexd a) : Complexd (tkmath) - Returns complex tanh(a)
• tanhcf(Complexf a) : Complexf (tkmath) - Returns complex tanh(a)
• tanhd(Double a) : Double (tkmath) - Calculate double precision tanh(a)
• tanhf(float a) : float (tkmath) - Calculate single precision tanh(a)
• vector2d(Double a, b) : Vector2d (tkmath) - Initialize and return new Vector2d instance with x=a and y=b
• vector2f(float a, b) : Vector2f (tkmath) - Initialise and return new Vector2f instance with x=a and y=b
• vector3d(Double a, b, c) : Vector3d (tkmath) - Initialise and return new Vector3d instance with x=a, y=b and z=c
• vector3f(float a, b, c) : Vector3f (tkmath) - Initialize and return new Vector3f instance with x=a, y=b and z=c
• vector4d(Double a, b, c, d) : Vector4d (tkmath) - Initialise and return new Vector4d instance with x=a, y=b, z=c and w=d
• vector4f(float x, y, z, w) : Vector4f (tkmath) - Initialise and return new Vector4f instance

Classes

• Complexd - This class represents a double precision complex number.
    Methods:
  • add(Complexd v) - add complex number v to this instance
  • div(Complexd v) - Divide this instance by complex v
  • getA() : Double - Get a property of re^ia
  • getAbs() : Double - Returns length of complex number
  • getAbsSqr() : Double - Returns squared length of complex number (faster than abs)
  • getPolarString() : String - Get string representation of complex number (re^ia)
  • getR() : Double - Get r property of re^ia
  • getString() : String - Get string representation of complex number (x+iy)
  • getX() : Double - Get x property of x+iy
  • getY() : Double - Get y property of x+iy
  • init(Double a, b) - Set value of instance to x=a and y=b (x+iy)
  • initf(float a, b) - Set value of instance to single precision x=a and y=b (x+iy)
  • initPolar(Double a, b) - Set value of instance to r=_a and a=_b (re^ia)
  • initPolarf(sF32 a, b) - Set value of instance to r=_a and a=_b (re^ia)
  • invert() - Invert this instance (v=1/v)
  • mul(Complexd v) - Multiply this instance with complex v
  • mulConj(Complexd v) : float - Multiply this instance with complex conjugated v, ((x₁+iy₁)*(x₂-iy₂))
  • muld(Double v) - Multiply this instance with scalar v
  • New(Double a, b) : Complexd - Returns new instance with values x=a and y=b of (x+iy)
  • NewPolar(Double va, vb) : Complexd - Returns new instance with values r=va anda a=vb of (re^ia)
  • setA(Double a) - Set a property of re^ia
  • setR(Double r) - Set r property of re^ia
  • setX(Double x) - Set x property of x+iy
  • setY(Double x) - Set y property of x+iy
  • sub(Complexd v) - substract complex number v from this instance
  • unit() - Set length of instance to 1
  • unitScale(Double s) - Set length of instance to s
  
  
• Complexf - This class represents a single precision complex number.
    Methods:
  • add(Complexf v) - add complex number v to this instance
  • div(Complexf v) - Divide this instance by complex v
  • getA() : float - Get a property of re^ia
  • getAbs() : float - Returns length of complex number
  • getAbsSqr() : float - Returns squared length of complex number (faster than abs)
  • getPolarString() : String - Get string representation of complex number (re^ia)
  • getR() : float - Get r property of re^ia
  • getString() : String - Get string representation of complex number (x+iy)
  • getX() : float - Get x property of x+iy
  • getY() : float - Get y property of x+iy
  • init(float a, b) - Set value of instance to x=a and y=b (x+iy)
  • initPolar(float a, b) - Set value of instance to r=_a and a=_b (re^ia)
  • invert() - Invert this instance (v=1/v)
  • mul(Complexf v) - Multiply this instance with complex v
  • mulConj(Complexf v) : float - Multiply this instance with complex conjugated v, ((x₁+iy₁)*(x₂-iy₂))
  • mulf(float v) - Multiply this instance with scalar v
  • New(float a, b) : Complexf - Returns new instance with values x=a and y=b of (x+iy)
  • NewPolar(float va, vb) : Complexf - Returns new instance with values r=va and a=vb of (re^ia)
  • setA(float a) - Set a property of re^ia
  • setR(float r) - Set r property of re^ia
  • setX(float x) - Set x property of x+iy
  • setY(float x) - Set y property of x+iy
  • sub(Complexf v) - substract complex number v from this instance
  • unit() - Set length of instance to 1
  • unitScale(float s) - Set length of instance to s
  
  
• Math - This class is mainly for importing the most commonly used math constants from math.h
    Methods:
  • getDblEpsilonUnits() : int - Returns current unit range for relative Double comparison, default is 100
  • getDblEpsilonZeroRange() : Double - Returns the epsilon range for relative zero Double comparison, default is 0.000000000001
  • getFltEpsilonUnits() : int - Returns current unit range for relative float comparison, default is 10
  • getFltEpsilonZeroRange() : float - Returns the epsilon range for relative zero float comparison, default is 0.000001
  • setDblEpsilonUnits(int u) - Set the relative unit range for relative Double comparison
  • setDblEpsilonZeroRange(Double a) - Set the relative tolerance for Double epsilon range checks
  • setFltEpsilonUnits(int u) - Set the relative unit range for relative float comparison
  • setFltEpsilonZeroRange(float a) - Set the relative tolerance for float epsilon range checks
  
    Constants:
  • float M_1_PI - 1/π=0.31830988618379067154f
  • float M_2_PI - 2/π=0.63661977236758134308f
  • float M_2_SQRTPI - 2/√π=1.12837916709551257390f
  • float M_E - e=2.7182818284590452354f
  • float M_LN10 - log(10)=2.30258509299404568402f
  • float M_LN2 - log(2)=0.69314718055994530942f
  • float M_LOG10E - log₁₀(e)=0.43429448190325182765f
  • float M_LOG2E - log₂(e)=1.4426950408889634074f
  • float M_PI - π=3.14159265358979323846f
  • float M_PI_2 - π/2=1.57079632679489661923f
  • float M_PI_4 - π/4=0.78539816339744830962f
  • float M_SQRT1_2 - 1/√2=0.70710678118654752440f
  • float M_SQRT2 - √2=1.41421356237309504880f
  
  
• Matrix - Base class for all matrix objects
    Methods:
  • getColumnMajor() : boolean - Get current element order
  • setColumnMajor(boolean bEnabled) - Set element order (column major/row major)
  
  
• Matrix2d - This class represents a double precision 2x2 square matrix.
    Methods:
  • add(Matrix2d m) - Add another matrix m to this instance
  • det() : Double - Calculate determinant of matrix
  • getA() : Double - Get value of a element
  • getAbs() : Double - Calculate the Hilbert-Schmidt norm of the matrix
  • getAbsSqr() : Double - Calculate the squared Hilbert-Schmidt norm of the matrix
  • getB() : Double - Get value of b element
  • getC() : Double - Get value of c element
  • getCol(int c) : Vector2d - Get column c values
  • getD() : Double - Get value of d element
  • getRow(int r) : Vector2d - Get row r values
  • getString() : String - Get string representation of matrix ((a, b), (c, d))
  • init(Doubla a, Double b, c, d) - Initialize matrix
  • initCol(int c, Double a, b) - Initialize column 'col' of the matrix
  • initColV(int c, Vector2d v) - Initialize column 'col' of the matrix
  • initf(float a, b, c, d) - Initialize matrix
  • initIdentity() - Initialize with identity matrix.
  • initRotatef() - 
  • initRow(int r, Double a, b) - Initialize row r of matrix
  • initRowV(int r, Vector2d v) - Initialize row 'row' of the matrix
  • initScalef() - 
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix2d m) - Multiply this instance with matrix m (this * m)
  • muld(Double v) - Multiply this instance by scalar value v
  • mulRev(Matrix2d m) - Reverse-multiply matrix m by this instance (m * this)
  • mulv(Vector2d v) : Vector2d - Multiply this instance with a 2dim vector
  • New(Double a, b, c, d) : Matrix2d - Initialize and return new instance of Matrix2d
  • setA(Double v) - Set a element to v
  • setB(Double v) - Set b element to v
  • setC(Double v) - Set c element to v
  • setCol(int c, Vector2d v) - Set column c with values from v
  • setD(Double v) - Set d element to v
  • setRow(int r, Vector2d v) - Set row r with values from v
  • sub(Matrix2d m) - Substract another matrix m from this instance
  • transpose() - Transpose matrix
  • unit() - Normalise matrix with Hilbert-Schmidt norm
  • unitScale(Double v) - Normalise matrix with Hilbert-Schmidt norm and multiply with v afterwards
  
  
• Matrix2f - This class represents a single precision 2x2 square matrix.
    Methods:
  • add(Matrix2f m) - Add another matrix m to this instance
  • det() : float - Calculate determinant of matrix
  • getA() : float - Get value of a element
  • getAbs() : float - Calculate the Hilbert-Schmidt norm of the matrix
  • getAbsSqr() : float - Calculate the squared Hilbert-Schmidt norm of the matrix
  • getB() : float - Get value of b element
  • getC() : float - Get value of c element
  • getCol(int col) : Vector2f - Get column 'col' vector
  • getD() : float - Get value of d element
  • getRow(int row) : Vector2f - Get row 'row' vector
  • getString() : String - Get string representation of matrix ((a, b), (c, d))
  • init(float a, b, c, d) - Initialize matrix (in matrix order, default=row-major)
  • initColf(int col, float a, b) - Initialize matrix column from scalars
  • initColumnMajor(float a, b, c, d) - Initialize matrix (column-major arg order. swap args if matrix is in (default) row-major order).
  • initColv(int col, Vector2f v) - Initialise matrix column from vector or array-like object
  • initIdentity() - Initialize with identity matrix.
  • initRotatef() - 
  • initRowf(int row, float a, b) - Initialize matrix row from scalars
  • initRowMajor(float a, b, c, d) - Initialize matrix (row-major arg order. swap args if matrix is in (non-default) column-major order).
  • initRowV(int row, Vector2f v) - Initialize matrix row from vector or array-like object
  • initScalef() - 
  • initScalev() - 
  • initSkewXf() - a in radians (0..2PI)
  • initSkewYf() - a in radians (0..2PI)
  • initTranspose(float a, b, c, d) - Initialize matrix (swap arg row/column order).
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • isIdentity() - Check if this is an identity matrix (diagonal=1, other=0)
  • mul(Matrix2f m) - Multiply this instance by matrix m (this * m)
  • mulf(float v) - Multiply this instance by scalar value v
  • mulRev(Matrix2f m) - Reverse-multiply matrix m by this instance (m * this)
  • mulv(Vector2f v) : Vector2f - Multiply this instance by a 2dim vector
  • New(float va, vb, vc, vd) : Matrix2f - Initialize and return new instance of Matrix2f (args are in row-major order)
  • rotatef(float ang) - Multiply by rotation matrix (angle is in radiant measure)
  • scalef(float x, y, z) - Multiply by scale matrix
  • scalev(Vector2f v) - Multiply by scale matrix
  • setA(float v) - Set a element to v
  • setB(float v) - Set b element to v
  • setC(float v) - Set c element to v
  • setCol(int col, Vector2f v) - Initialize column 'col' with values from 'v'
  • setD(float v) - Set d element to v
  • setRow(int row, Vector2f v) - Initialize row 'row' with values from 'v'
  • sub(Matrix2f m) - Substract another matrix m from this instance
  • transpose() - Transpose matrix
  • unit() - Normalize matrix using Hilbert-Schmidt norm
  • unitScale(float s) - Normalise matrix using Hilbert-Schmidt norm and multiply by 's' afterwards
  
  
• Matrix2x3f - This class represents a single precision 2x3 square matrix.
    Methods:
  • add(Matrix2xf m) - Add another matrix m to this instance
  • getA() : float - Get value of a element
  • getAbs() : float - Calculate the Hilbert-Schmidt norm of the matrix
  • getAbsSqr() : float - Calculate the squared Hilbert-Schmidt norm of the matrix
  • getB() : float - Get value of b element
  • getC() : float - Get value of c element
  • getCol(int col) : Vector3f - Get column 'col' values
  • getD() : float - Get value of d element
  • getE() : float - Get value of e element
  • getF() : float - Get value of f element
  • getRow(int row) : Vector3f - Get row 'row' vector
  • getString() : String - Get string representation of matrix ((a, b, c), (d, e, f), (g, h, i))
  • init(float a, b, c, d, e, f) - Initialize matrix (in row-major order)
  • initColf(int col, float a, b, c) - Initialize matrix column from scalars
  • initColv(int col, Vector2f v) - Initialize matrix column from vector or array-like object
  • initIdentity() - Initialize with identity matrix.
  • initOrtho() - 
  • initRotatef() - 
  • initRow(int row, float a, b, c) - Initialize matrix row from scalars
  • initRowV(int row, Vector3f v) - Initialize matrix row from vector or array-like object
  • initScalef() - 
  • initScalev() - 
  • initSkewXf() - a in radians (0..2PI)
  • initSkewYf() - a in radians (0..2PI)
  • initTranslatef() - 
  • initTranslatev() - 
  • mul(Matrix2x3f m) - Multiply this instance by matrix m (this * m)
  • mulf(float f) - Multiply this instance by scalar value f
  • mulRev(Matrix2x3f m) - Reverse-multiply matrix m by this instance (m * this)
  • mulv(Vector2f v) : Vector2f - Multiply matrix by a vector
  • New(float a, b, c, d, e, f) : Matrix2x3f - Initialize and return new instance of Matrix2x3f
  • rotatef(float ang) - Multiply by rotation matrix (angle is in radian measure)
  • scalef(float x, y) - Multiply by scale matrix
  • scalev(Vector2f v) - Multiply by scale matrix
  • setA(float v) - Set a element to m11
  • setB(float v) - Set b element to m12
  • setC(float v) - Set c element to m13
  • setCol(int c, Vector3f v) - Set column 'col' with values from v
  • setD(float v) - Set d element to m21
  • setE(float v) - Set e element to m22
  • setF(float v) - Set f element to m23
  • setRow(int row, Vector3f v) - Initialize row 'row' with values from v
  • sub(Matrix2x3f m) - Substract another matrix m from this instance
  • translatef(float x, y) - Multiply by translation matrix
  • translatev(Vector2f v) - Multiply by translation matrix
  • unit() - Normalise matrix with Hilbert-Schmidt norm
  • unitScale(float s) - Normalise matrix using Hilbert-Schmidt norm and multiply by s afterwards
  
  
• Matrix3d - This class represents a single precision 3x3 square matrix.
    Methods:
  • add(Matrix3d m) - Add another matrix m to this instance
  • det() : Double - Calculate determinant of matrix
  • getA() : Double - Get value of a element
  • getAbs() : Double - Calculate the Hilbert-Schmidt norm of the matrix
  • getAbsSqr() : Double - Calculate the squared Hilbert-Schmidt norm of the matrix
  • getB() : Double - Get value of b element
  • getC() : Double - Get value of c element
  • getCol(int c) : Vector3d - Get column c values
  • getD() : Double - Get value of d element
  • getE() : Double - Get value of e element
  • getF() : Double - Get value of f element
  • getG() : Double - Get value of g element
  • getH() : Double - Get value of h element
  • getI() : Double - Get value of i element
  • getRow(int r) : Vector3d - Get row r values
  • getString() : String - Get string representation of matrix ((a, b, c), (d, e, f), (g, h, i))
  • init(Double va, vb, vc, vd, ve, vf, vg, vh, vi) - Initialise matrix
  • initCol(int c, Double va, vb, vc) - Initialise column c of matrix
  • initColV(int c, Vector3d v) - Initialise column c of matrix
  • initf(float va, vb, vc, vd, ve, vf, vg, vh, vi) - Initialise matrix
  • initIdentity() - Initialize with identity matrix.
  • initRow(int r, Double va, vb, vc) - Initialise row r of matrix
  • initRowV(int r, Vector3d v) - Initialise row r of matrix
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix3d m) - Multiply this instance by matrix m (this * m)
  • muld(Double v) - Multiply this instance by scalar value v
  • mulRev(Matrix3d m) - Reverse-multiply matrix m by this instance (m * this)
  • mulv(Vector3d v) : Vector3d - Multiply this instance by a 3d vector
  • New(Double va, vb, vc, vd, ve, vf, vg, vh, vi) : Matrix3d - Initialise and return new instance of Matrix3d
  • setA(Double v) - Set a element to v
  • setB(Double v) - Set b element to v
  • setC(Double v) - Set c element to v
  • setCol(int c, Vector3d v) - Set column c with values from v
  • setD(Double v) - Set d element to v
  • setE(Double v) - Set e element to v
  • setF(Double v) - Set f element to v
  • setG(Double v) - Set g element to v
  • setH(Double v) - Set h element to v
  • setI(Double v) - Set i element to v
  • setRow(int r, Vector3d v) - Set row r with values from v
  • sub(Matrix3d m) - Substract another matrix m from this instance
  • transpose() - Transpose matrix
  • unit() - Normalize matrix with Hilbert-Schmidt norm
  • unitScale(Double v) - Normalize matrix with Hilbert-Schmidt norm and multiply by v afterwards
  
  
• Matrix3f - This class represents a single precision 3x3 square matrix.
    Methods:
  • add(Matrix3f m) - Add another matrix m to this instance
  • det() : float - Calculate determinant of matrix
  • getA() : float - Get value of a element
  • getAbs() : float - Calculate the Hilbert-Schmidt norm of the matrix
  • getAbsSqr() : float - Calculate the squared Hilbert-Schmidt norm of the matrix
  • getB() : float - Get value of b element
  • getC() : float - Get value of c element
  • getCol(int col) : Vector3f - Get column 'col' values
  • getD() : float - Get value of d element
  • getE() : float - Get value of e element
  • getF() : float - Get value of f element
  • getG() : float - Get value of g element
  • getH() : float - Get value of h element
  • getI() : float - Get value of i element
  • getRow(int row) : Vector3f - Get row 'row' vector
  • getString() : String - Get string representation of matrix ((a, b, c), (d, e, f), (g, h, i))
  • init(float a, b, c, d, e, f, g, h, i) - Initialize matrix. The parameters are in matrix order (row(default) or column major).
  • initCol(int col, float a, b, c) - Initialize matrix column from scalars
  • initColumnMajor(float a, b, c, d, e, f, g, h, i) - Initialize matrix (column-major arg order. swap args if matrix is in row-major order).
  • initColv(int col, Vector3f v) - Initialize matrix column from vector or array-like object
  • initEulerXYX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerXYZ(float a, b, c) - Initialize with euler rotation matrix
  • initEulerXZX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerXZY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYXY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYXZ(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYZX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYZY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZXY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZXZ(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZYX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZYZ(float a, b, c) - Initialize with euler rotation matrix
  • initIdentity() - Initialize with identity matrix.
  • initRotatef(float x, y) - same as initEulerXYZ()
  • initRotatev(Vector3f v) - same as initEulerXYZ(v.x, v.y, v.z)
  • initRowf(int row, float a, b, c) - Initialize matrix row from scalars
  • initRowMajor(float a, b, c, d, e, f, g, h, i) - Initialize matrix (row-major arg order. swap args if matrix is in column-major order).
  • initRowv(int row, Vector3f v) - Initialize matrix row from vector or array-like object
  • initScalef() - 
  • initScalev(float x, y) - 
  • initTranslatef(float x, y) - 
  • initTranslatev() - 
  • initTranspose(float a, b, c, d, e, f, g, h, i) - Initialize matrix (swap arg row/column order).
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • isIdentity() - Check if this is an identity matrix (diagonal=1, other=0)
  • mul(Matrix3f m) - Multiply this instance by matrix m
  • mulf(float f) - Multiply this instance by scalar value f
  • mulv(Vector3f v) : Vector3f - Multiply this instance by a 3dim vector
  • New(float a, b, c, d, e, f, g, h, i) : Matrix3f - Initialize and return new instance of Matrix3f. The parameters are in matrix order (row(default) or column major).
  • rotatef(float x, y, z) - Multiply by X=>Y=>Z rotation matrix (radian angles)
  • rotatev(Vector3f v) - Multiply by v.x=>v.y=>v.z rotation matrix (radian angles)
  • scalef(float x, y, z) - Multiply by scale matrix
  • scalev(Vector3f v) - Multiply by scale matrix
  • setA(float v) - Set a element to v
  • setB(float v) - Set b element to v
  • setC(float v) - Set c element to v
  • setCol(int c, Vector3f v) - Set column 'col' with values from v
  • setD(float v) - Set d element to v
  • setE(float v) - Set e element to v
  • setF(float v) - Set f element to v
  • setG(float v) - Set g element to v
  • setH(float v) - Set h element to v
  • setI(float v) - Set i element to v
  • setRow(int row, Vector3f v) - Initialize row 'row' with values from v
  • sub(Matrix3f m) - Substract another matrix m from this instance
  • translatef(float x, y) - Multiply by translation matrix
  • translatev(Vector2f v) - Multiply by translation matrix
  • transpose() - Transpose matrix
  • unit() - Normalise matrix with Hilbert-Schmidt norm
  • unitScale(float s) - Normalise matrix using Hilbert-Schmidt norm and multiply by s afterwards
  
  
• Matrix4d - This class represents a double precision 4x4 square matrix.
    Methods:
  • add(Matrix4d m) - Add another matrix m to this instance
  • BuildEulerXYX4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with XYX convention
  • BuildEulerXYZ4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with XYZ convention
  • BuildEulerXZX4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with XZX convention
  • BuildEulerXZY4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with XZY convention
  • BuildEulerYXY4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with YXY convention
  • BuildEulerYXZ4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with YXZ convention
  • BuildEulerYZX4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with YZX convention
  • BuildEulerYZY4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with YZY convention
  • BuildEulerZXY4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with ZXY convention
  • BuildEulerZXZ4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with ZXZ convention
  • BuildEulerZYX4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with ZYX convention
  • BuildEulerZYZ4d(Double a, b, c) : Matrix4d - Build an euler rotation matrix with ZYZ convention
  • BuildLookAtMatrix4d(Vector3d eye, center, up) : Matrix4d - Build a look at matrix
  • BuildPerspectiveMatrix4d(Double fov, aspect, zNear, zFar) : Matrix4d - Builds a perspective matrix
  • BuildRotateMatrix4d(Double angle, Vector3d axis) : Matrix4d - Build a rotation matrix
  • BuildTranslateMatrix4d(Vector3d t) : Matrix4d - Build a translation matrix
  • det() : Double - Calculate determinant of matrix
  • getA() : Double - Get value of a element
  • getAbs() : Double - Calculate the Hilbert-Schmidt norm of the matrix
  • getAbsSqr() : Double - Calculate the squared Hilbert-Schmidt norm of the matrix
  • getB() : Double - Get value of b element
  • getC() : Double - Get value of c element
  • getCol(int col) : Vector4d - Get column 'col' values
  • getD() : Double - Get value of d element
  • getE() : Double - Get value of e element
  • getF() : Double - Get value of f element
  • getG() : Double - Get value of g element
  • getH() : Double - Get value of h element
  • getI() : Double - Get value of i element
  • getJ() : Double - Get value of j element
  • getK() : Double - Get value of k element
  • getL() : Double - Get value of l element
  • getM() : Double - Get value of m element
  • getN() : Double - Get value of n element
  • getO() : Double - Get value of o element
  • getP() : Double - Get value of p element
  • getRow(int row) : Vector4d - Get row 'row'
  • getString() : String - Get string representation of matrix ((a, b, c, d), (e, f, g, h), (i, j, k, l), (m, n, o, p))
  • init(Double a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) - Initialize matrix
  • initCol(int col, Double a, b, c, d) - Initialize column 'col'
  • initColV(int col, Vector4d v) - Initialize column 'col'
  • initEulerXYX(Double a, b, c) - Initialize with euler roation matrix
  • initEulerXYZ(Double a, b, c) - Initialize with euler roation matrix
  • initEulerXZX(Double a, b, c) - Initialize with euler roation matrix
  • initEulerXZY(Double a, b, c) - Initialize with euler roation matrix
  • initEulerYXY(Double a, b, c) - Initialize with euler roation matrix
  • initEulerYXZ(Double a, b, c) - Initialize with euler roation matrix
  • initEulerYZX(Double a, b, c) - Initialize with euler roation matrix
  • initEulerYZY(Double a, b, c) - Initialize with euler roation matrix
  • initEulerZXY(Double a, b, c) - Initialize with euler roation matrix
  • initEulerZXZ(Double a, b, c) - Initialize with euler roation matrix
  • initEulerZYX(Double a, b, c) - Initialize with euler roation matrix
  • initEulerZYZ(Double a, b, c) - Initialize with euler roation matrix
  • initf(float a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) - Initialize matrix
  • initIdentity() - Initialize with identity matrix.
  • initRow(int row, Double a, b, c, d) - Initialize row 'row'
  • initRowV(int row, Vector4d v) - Initialize row 'row'
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix4d m) - Multiply this instance by matrix m
  • mulf(Double v) - Multiply this instance with scalar value v
  • mulRev(Matrix4d m) - Reverse-multiply matrix m by this instance (m * this)
  • mulv(Vector4d v) : Vector4d - Multiply this instance with a 4dim vector
  • New(Object a) : Matrix4d - Initialize from an array and return new instance of Matrix4d
  • setA(Double v) - Set a element to v
  • setB(Double v) - Set b element to v
  • setC(Double v) - Set c element to v
  • setCol(int col, Vector4d v) - Set column 'col' with values from v
  • setD(Double v) - Set d element to v
  • setE(Double v) - Set e element to v
  • setF(Double v) - Set f element to v
  • setG(Double v) - Set g element to v
  • setH(Double v) - Set h element to v
  • setI(Double v) - Set i element to v
  • setJ(Double v) - Set j element to v
  • setK(Double v) - Set k element to v
  • setL(Double v) - Set l element to v
  • setM(Double v) - Set m element to v
  • setN(Double v) - Set n element to v
  • setO(Double v) - Set o element to v
  • setP(Double v) - Set p element to v
  • setRow(int r, Vector4d v) - Set row r with values from v
  • sub(Matrix4d m) - Substract another matrix m from this instance
  • transpose() - Transpose matrix
  • unit() - Normalise matrix using Hilbert-Schmidt norm
  • unitScale(Double s) - Normalise matrix using Hilbert-Schmidt norm and multiply by s afterwards
  
  
• Matrix4f - This class represents a single precision 4x4 square matrix.
    Methods:
  • add(Matrix4f m) - Add another matrix m to this instance
  • BuildEulerXYX4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with XYX convention
  • BuildEulerXYZ4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with XYZ convention
  • BuildEulerXZX4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with XZX convention
  • BuildEulerXZY4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with XZY convention
  • BuildEulerYXY4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with YXY convention
  • BuildEulerYXZ4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with YXZ convention
  • BuildEulerYZX4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with YZX convention
  • BuildEulerYZY4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with YZY convention
  • BuildEulerZXY4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with ZXY convention
  • BuildEulerZXZ4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with ZXZ convention
  • BuildEulerZYX4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with ZYX convention
  • BuildEulerZYZ4f(float a, b, c) : Matrix4f - Build an euler rotation matrix with ZYZ convention
  • BuildLookAtMatrix4f(Vector3f eye, center, up) : Matrix4f - Build a look at matrix
  • BuildPerspectiveMatrix4f(float fov, aspect, zNear, zFar) : Matrix4f - Builds a perspective matrix
  • BuildRotateMatrix4f(float angle, Vector3f axis) : Matrix4f - Build a rotation matrix
  • BuildScaleMatrix4f(Vector3f scale) : Matrix4f - Build a scale matrix
  • BuildTranslateMatrix4f(Vector3f t) : Matrix4f - Build a translation matrix
  • det() : float - Calculate determinant of matrix
  • extractPlanes(Vector4f retN, retF, retL, retR, retT, retB) - Extract normalized planes from projection matrix (e.g. for view-frustum culling)
  • frustum(float left, right, bottom, top, znear, zfar) - Multiply by frustum matrix
  • frustumFovXY(float left, right, bottom, top, aspect, fovX, fovY, znear, zfar) - Multiply by frustum matrix (fields of view are in degrees)
  • getA() : float - Get value of a element
  • getAbs() : float - Calculate the Hilbert-Schmidt norm of the matrix
  • getAbsSqr() : float - Calculate the squared Hilbert-Schmidt norm of the matrix
  • getB() : float - Get value of b element
  • getC() : float - Get value of c element
  • getCol(int c) : Vector4f - Get column c values
  • getD() : float - Get value of d element
  • getE() : float - Get value of e element
  • getF() : float - Get value of f element
  • getG() : float - Get value of g element
  • getH() : float - Get value of h element
  • getI() : float - Get value of i element
  • getJ() : float - Get value of j element
  • getK() : float - Get value of k element
  • getL() : float - Get value of l element
  • getM() : float - Get value of m element
  • getN() : float - Get value of n element
  • getO() : float - Get value of o element
  • getP() : float - Get value of p element
  • getQuaternionf() : Quaternionf - Tries to find a Quaternion representation of the matrix if possible
  • getRC(int row, col) - Get element at (row, column)
  • getRow(int r) : Vector4f - Get row r values
  • getString() : String - Get string representation of matrix ((a, b, c, d), (e, f, g, h), (i, j, k, l), (m, n, o, p))
  • init(float a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) - Initialize matrix (in native order, default is row-major)
  • initColf(int col, float a, b, c, d) - Initialize matrix column from scalars
  • initColumnMajor(float a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) - Initialize matrix (args are in column major (OpenGL) order, convert to matrix order as required)
  • initColv(int c, Vector4f v) - Initialize matrix column from vector or array-like object
  • initEulerXYX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerXYZ(float a, b, c) - Initialize with euler rotation matrix
  • initEulerXZX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerXZY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYXY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYXZ(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYZX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerYZY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZXY(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZXZ(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZYX(float a, b, c) - Initialize with euler rotation matrix
  • initEulerZYZ(float a, b, c) - Initialize with euler rotation matrix
  • initFrustum() - 
  • initFrustumFov() - (field of view is in degrees)
  • initFrustumFovXY(float left, right, bottom, top, aspect, fovX, fovY, znear, zfar) - (field of view is in degrees)
  • initIdentity() - Initialize with identity matrix.
  • initLookAt() - Init look-at matrix
  • initOrtho() - 
  • initPerspective() - Init perspective matrix
  • initRotate() - Init rotation matrix (rotate about axis vector)
  • initRotatef() - Init X=>Y=>Z rotation matrix (initEulerXYZ())
  • initRotatev() - Init v.x=>v.y=>v.z rotation matrix (initEulerXYZ())
  • initRowf(int row, float a, b, c, d) - Initialize matrix row from scalars
  • initRowMajor(float a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) - Initialize matrix (args are in row major order, convert to matrix order as required)
  • initRowv(int row, Vector4f v) - Initialize matrix row from vector or array-like object
  • initScalef() - 
  • initScalev() - 
  • initSkewXf() - a in radians (0..2PI)
  • initSkewYf() - a in radians (0..2PI)
  • initTranslatef() - 
  • initTranslatev() - 
  • initTranspose(float a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) - Initialize matrix (flip row/column major order, default is row-major)
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • isIdentity() - Check if this is an identity matrix (diagonal=1, other=0)
  • lookAt(Object eye, center, up) - Multiply by look-at matrix
  • mul(Matrix4f m) - Multiply this instance with matrix m (this * m)
  • mulf(float s) - Multiply this instance with scalar value s
  • mulRev(Matrix4f m) - Reverse-multiply matrix m by this instance (m * this)
  • mulv(Vector4f v) : Vector4f - Multiply this instance with a 4dim vector
  • mulvRev(Vector4f v) : Vector4f - Multiply this transposed instance with a 4dim vector
  • New(Object o) : Matrix4f - Initialize from an array and return new instance of Matrix4f
  • ortho(float left, right, bottom, top, znear, zfar) - Multiply by orthogonal matrix
  • perspective(float fov, aspect, znear, zfar) - Multiply by perspective matrix
  • rotate(float angle, Object axis) - Multiply by rotation matrix
  • rotatef(float x, y, z) - Multiply by X=>Y=>Z rotation matrix (radian angles)
  • rotatev(Vector3f v) - Multiply by v.x=>v.y=>v.z rotation matrix (radian angles)
  • scalef(float x, y, z) - Multiply by scale matrix
  • scalev(Vector3f v) - Multiply by scale matrix
  • set(int row, col, float v) - Set element at (row, column) to v
  • setA(float v) - Set a element to v
  • setB(float v) - Set b element to v
  • setC(float v) - Set c element to v
  • setCol(int c, Vector4f v) - Set column c with values from v
  • setD(float v) - Set d element to v
  • setE(float v) - Set e element to v
  • setF(float v) - Set f element to v
  • setG(float v) - Set g element to v
  • setH(float v) - Set h element to v
  • setI(float v) - Set i element to v
  • setJ(float v) - Set j element to v
  • setK(float v) - Set k element to v
  • setL(float v) - Set l element to v
  • setM(float v) - Set m element to v
  • setN(float v) - Set n element to v
  • setO(float v) - Set o element to v
  • setP(float v) - Set p element to v
  • setRow(int r, Vector4f v) - Set row r with values from v
  • sub(Matrix4f m) - Substract another matrix m from this instance
  • translatef(float x, y, z) - Multiply by translation matrix
  • translatev(Vector3f v) - Multiply by translation matrix
  • transpose() - Transpose matrix
  • unit() - Normalise matrix with Hilbert-Schmidt norm
  • unitScale(float v) - Normalise matrix with Hilbert-Schmidt norm and scale by v afterwards
  
  
• Quaterniond - This class represents a single precision quaternion of the form a+ib+jc+kd.
    Methods:
  • add(Quaterniond v) - add quaternion v to this instance
  • conjMul(Quaterniond v) - Multiply this conjugated instance with quaternion v (Grassmann product)
  • dot(Quaterniond v) : Double - Calculate dot product (inner product) of this instance and quaternion v
  • getAbs() : Double - Return the absolute value of this instance
  • getAbsSqr() : Double - Return the squared length of this instance
  • getAngle() : Double - Calculate quaternion angle
  • getI() : Double - Get imaginery i value
  • getJ() : Double - Get imaginery j value
  • getK() : Double - Get imaginery k value
  • getMatrix4d() : Matrix4d - Get 4x4 matrix representation of quaternion
  • getPureUnit() : Quaterniond - Returns pure unit quaternion from instance
  • getR() : Double - Get Real value
  • getRadius() : Double - Calculate quaternion radius (_getAbs)
  • getString() : String - Get string representation of quaternion number (a+ib+jc+kd)
  • getV() : Vector3d - Get vector value
  • init(Double a, b, c, d) - Init quaternion to a+ib+jc+kd
  • initf(float a, b, c, d) - Init quaternion to a+ib+jc+kd
  • invert() - Calculate the reciprocal value 1/q
  • mul(Quaterniond v) - Multiply this instance with quaternion v (Grassmann product)
  • mulConj(Quaterniond v) - Multiply this instance with conjugated quaternion v (Grassmann product)
  • mulf(Double v) - Multiply this instance with scalar v
  • New(Double a, b, c, d) : Quaterniond - Init quaternion to a+ib+jc+kd and return new instance
  • outer(Quaterniond v) : Quaterniond - Calculate the outer product of this instance and quaternion v
  • setAngle(Double a) - Set new quaternion angle
  • setI(Double a) - Set imaginery i part to a
  • setJ(Double a) - Set imaginery j part to a
  • setK(Double a) - Set imagnery k part to a
  • setPureUnit(Quaterniond v) - Set new pure unit vector of quaternion
  • setR(Double a) - Set real part to a
  • setRadius(Double a) - Set new quaternion radius
  • setV(Vector3d v) - Set vector part to v
  • sub(Quaterniond v) - substract quaternion v from this instance
  • unit() - Set length of quaternion to 1
  • unitScale(Double s) - Set length of quaternion to s
  
  
• Quaternionf - This class represents a single precision quaternion of the form a+ib+jc+kd.
    Methods:
  • add(Quaternionf v) - add quaternion v to this instance
  • conjMul(Quaternionf v) - Multiply this conjugated instance with quaternion v (Grassmann product)
  • dot(Quaternionf v) : float - Calculate dot product (inner product) of this instance and quaternion v
  • getAbs() : float - Return the absolute value of this instance
  • getAbsSqr() : float - Return the squared length of this instance
  • getAngle() : float - Calculate quaternion angle
  • getI() : float - Get imaginery i value
  • getJ() : float - Get imaginery j value
  • getK() : float - Get imaginery k value
  • getMatrix4f() : Matrix4f - Get 4x4 matrix representation of quaternion
  • getPureUnit() : Quaternionf - Returns pure unit quaternion from instance
  • getR() : float - Get Real value
  • getRadius() : float - Calculate quaternion radius (_getAbs)
  • getRotateMatrix4f() : Matrix4f - Get 4x4 rotation matrix representation of quaternion q*conj q
  • getString() : String - Get string representation of quaternion number (a+ib+jc+kd)
  • getV() : Vector3f - Get vector value
  • init(float a, b, c, d) - Init quaternion to a+ib+jc+kd
  • invert() - Calculate the reciprocal value 1/q
  • mul(Quaternionf v) - Multiply this instance with quaternion v (Grassmann product)
  • mulConj(Quaternionf v) - Multiply this instance with conjugated quaternion v (Grassmann product)
  • mulf(float v) - Multiply this instance with scalar v
  • New(float a, b, c, d) : Quaternionf - Init quaternion to a+ib+jc+kd and return new instance
  • outer(Quaternionf v) : Quaternionf - Calculate the outer product of this instance and quaternion v
  • setAngle(float a) - Set new quaternion angle
  • setI(float a) - Set imaginery i part to a
  • setJ(float a) - Set imaginery j part to a
  • setK(float a) - Set imagnery k part to a
  • setPureUnit(Quaternionf v) - Set new pure unit vector of quaternion
  • setR(float a) - Set real part to a
  • setRadius(float a) - Set new quaternion radius
  • setV(Vector3f v) - Set vector part to v
  • sub(Quaternionf v) - substract quaternion v from this instance
  • unit() - Set length of quaternion to 1
  • unitScale(float s) - Set length of quaternion to s
  
  
• Vector2d - This class represents a double precision 2 dimensional coordinate vector.
    Methods:
  • add(Vector2d v) - Add another vector v to this instance
  • dot(Vector2d v) : Double - Calculate dot product from this instance and v
  • getAbs() : Double - Return length of vector
  • getAbsSqr() : Double - Return squared length of vector
  • getString() : String - Get string representation (x, y) of vector
  • getX() : Double - Get value of x element
  • getY() : Double - Get value of y element
  • init(Double a, b) - Initialize values to x=a and y=b
  • initf(float a, b) - Initialize with single precision values to x=a and x=b
  • initScaled(Vector2d v, Double s) - Initialize values to s*v
  • mul(Vector2d v) - Multiply the x element of this instance by the x element of v and do the same with the y element
  • muld(Double v) - Multiply this instance by scalar value v
  • New(Double a, b) : Vector2d - Initialize and return new Vector2d instance with x=a and y=b
  • setX(Double a) - Set x element to a
  • setY(Double a) - Set y element to a
  • sub(Vector2d v) - Substract another vector v from this instance
  • tensor(Vector2d v) : Matrix2d - Create resulting matrix of tensor product from this instance and v
  • unit() - Set length to 1
  • unitScale(Double s) - Set length to s
  
  
• Vector2f - This class represents a single precision 2 dimensional coordinate vector.
    Methods:
  • add(Vector2f v) - Add another vector v to this instance
  • add2f(float tx, ty) - Translate x / y components
  • addf(float v) - Add scalar value to all components
  • bilinearQuadPos() - Calc interpolated quad position from normalized (0..1) coordinates (0;0=left/top)
  • clamp(float l) - Clamp to length
  • cross(Vector2f v) : float - Returns the z component of the orthogonal vector of the cross product
  • distanceToPlane(Vector2f q, n) : float - Calc distance of vertex to plane defined by Vector2f q (on plane) and plane normal n
  • distanceToSphere(Vector2f p, float radius) : float - Calc distance of vertex to sphere defined by Vector2f p (sphere center) and sphere radius.
  • dot(Vector2f v) : float - Calculate dot product from this instance and v
  • getAbs() : float - Return length of vector
  • getAbsSqr() : float - Return squared length of vector
  • getAngle() : float - Returns angular direction (in radians) (0=north/0;1)
  • getString() : String - Get string representation (x, y) of vector
  • getX() : float - Get value of x element
  • getY() : float - Get value of y element
  • getYX() : float - Get yx vector
  • init(float x, y) - Initialize vector from scalars
  • initAngle() - Initializes vector from angle (in radians) (0=north/0;1)
  • initScalef(Vector2f v, float s) - Initialise values to s*v
  • intersect(Vector2f v, float s) - Returns intersection point in 'this'
  • isWithinSphere(Vector2f p, float radiusSquared) : boolean - Check if vertex is located within sphere defined by Vector2f p (sphere center) and squared sphere radius 'radiusSquared'.
  • lerp(Vector2f o) - Linear interpolate to another vector
  • mul(Vector2f v) - Multiply the x element of this instance by the x element of v and do the same with the y element
  • mul2f(float sx, sy) - Scale x / y components
  • mulf(float s) - Multiply this instance by scalar value s
  • New(float x, y) : Vector2f - Initialize and return new Vector2f instance
  • rotateCCW90() - Rotate 90 degrees counter-clock-wise (x = -y, y = x)
  • rotateCW90() - Rotate 90 degrees clock-wise (x = y, y = -x)
  • setX(float a) - Set x element to a
  • setY(float a) - Set y element to a
  • sub(Vector2f v) - Substract another vector v from this instance
  • tensor(Vector2f v) : Matrix2f - Create resulting matrix of tensor product from this instance and v
  • transform(Matrix m) - Multiply matrix by this vector.
  • unit() - Scale vector to length 1 if possible
  • unitScale(float s) - Set length to s
  
  
• Vector3d - This class represents a double precision 3 dimensional coordinate vector.
    Methods:
  • add(Vector3d v) - Add another vector v to this instance
  • cross(Vector3d v) : Vector3d - Calculate cross product from this instance and v
  • dot(Vector3d v) : Double - Calculate scalar dot product from this instance and v
  • getAbs() : Double - Return length of vector
  • getAbsSqr() : Double - Return squared length of vector
  • getString() : String - Get string representation of vector (x, y, z)
  • getX() : Double - Get value of x element
  • getY() : Double - Get value of y element
  • getZ() : Double - Get value of z element
  • init(Double a, b, c) - Initialise values to x=a, y=b and z=c
  • initf(float a, b, c) - Initialise values to single precision x=a, y=b and z=c
  • initScaled(Vector3d v, Double s) - Initialise vector to s*v
  • mul(Vector3d v) - Multiply the x element of this instance by the x element of v and do the same with the y and z element
  • muld(Double v) - Multiply this instance by scalar value v
  • New(Double a, b, c) : Vector3d - Initialise and return new Vector3d instance with x=a, y=b and z=c
  • setX(Double a) - Set x element to a
  • setY(Double a) - Set y element to a
  • setZ(Double a) - Set z element to a
  • sub(Vector3d v) - Substract another vector v from this instance
  • tensor(Vector3d v) : Matrix3d - Create resulting matrix of tensor product from this instance and v
  • triple(Vector3d b, c) : Double - Calculate triple product this.dot(b.cross(c)) (a*(bxc))
  • unit() - Set length to 1
  • unitScale(Double s) - Set length to s
  
  
• Vector3f - This class represents a single precision 3 dimensional coordinate vector.
    Methods:
  • add(Vector3f v) - Add another vector v to this instance
  • add3f(float tx, ty, tz) - Translate x / y / z components
  • addf(float v) - Add scalar value to all components
  • bilinearQuadPos() - Calc interpolated quad position from normalized (0..1) coordinates (0;0=left/top)
  • clamp(float l) - Clamp to length
  • cross(Vector3f v) : Vector3f - Calculate cross product from this instance and v
  • distanceToPlane(Vector3f q, n) : float - Calc distance of vertex to plane defined by Vector3f q (on plane) and plane normal n
  • distanceToSphere(Vector3f p, float radius) : float - Calc distance of vertex to sphere defined by Vector3f p (sphere center) and sphere radius.
  • divz() - Divide by Z and return (2D) Vector2f
  • dot(Vector3f v) : float - Calculate scalar dot product from this instance and v
  • getAbs() : float - Return length of vector
  • getAbsSqr() : float - Return squared length of vector
  • getString() : String - Get string representation of vector (x, y, z)
  • getX() : float - Get value of x element
  • getXy() : float - Get xy vector
  • getXz() : float - Get xz vector
  • getY() : float - Get value of y element
  • getYx() : float - Get yx vector
  • getZ() : float - Get value of z element
  • init(float x, y, z) - Initialize vector from scalars
  • initScalef(Vector3f v, float s) - Initialize vector to s*v
  • intersectPlane(Vector3f q, n, p1, p2) : boolean - Calc intersection between line (p1->p2) and plane (q,n).
  • isWithinSphere(Vector3f p, float radiusSquared) : boolean - Check if vertex is located within sphere defined by Vector3f p (sphere center) and squared sphere radius 'radiusSquared'.
  • lerp(Vector3f o) - Linear interpolate to another vector
  • mul(Vector3f v) - Multiply the x element of this instance by the x element of v and do the same with the y and z element
  • mul3f(float sx, sy, sz) - Scale x / y / z components
  • mulf(float v) - Multiply this instance by scalar value v
  • New(float x, y, z) : Vector3f - Initialize and return new Vector3f instance
  • setX(float a) - Set x element to a
  • setY(float a) - Set y element to a
  • setZ(float a) - Set z element to a
  • sub(Vector3f v) - Substract another vector v from this instance
  • tensor(Vector3f v) : Matrix3f - Create resulting matrix of tensor product from this instance and v
  • transform(Matrix m) - Multiply matrix by this vector.
  • triple(Vector3f b, c) : float - Calculate triple product this.dot(b.cross(c)) (a*(bxc))
  • unit() - Scale vector to length 1 if possible
  • unitScale(float s) - Set length to s
  • unitSphere() - Map to point on sphere 
  
  
• Vector4d - This class represents a double precision 4 dimensional euclidean space vector.
    Methods:
  • add(Vector4d v) - Add another vector v to this instance
  • dot(Vector4d v) : Double - Calculate scalar dot product from this instance and v
  • getAbs() : Double - Return length of vector
  • getAbsSqr() : Double - Return squared length of vector
  • getString() : String - Get string representation of vector (x, y, z, w)
  • getW() : Double - Get value of w element
  • getX() : Double - Get value of x element
  • getY() : Double - Get value of y element
  • getZ() : Double - Get value of z element
  • init(Double a, b, c, d) - Initialise values to x=a, y=b, z=c and w=d
  • initf(float a, b, c, d) - Initialise values to single precision x=a, y=b, z=c and w=d
  • initScaled(Vector4d v, Double s) - Initialise vector to s*v
  • mul(Vector4d v) - Multiply the x element of this instance by the x element of v and do the same with the y, z and w elements
  • muld(Double v) - Multiply this instance by scalar value v
  • New(Double a, b, c, d) : Vector4d - Initialise and return new Vector4d instance with x=a, y=b, z=c and w=d
  • setW(Double a) - Set w element to a
  • setX(Double a) - Set x element to a
  • setY(Double a) - Set y element to a
  • setZ(Double a) - Set z element to a
  • sub(Vector4d v) - Substract another vector v from this instance
  • tensor(Vector4d v) : Matrix4f - Create resulting matrix of tensor product from this instance and v
  • unit() - Set length to 1
  • unitScale(Double s) - Set length to s
  
  
• Vector4f - This class represents a single precision 4 dimensional euclidean space vector.
    Methods:
  • add(Vector4f v) - Add vector or array-like object
  • addf(float v) - Add scalar value to all components
  • bilinearQuadPos() - Calc interpolated quad position from normalized (0..1) coordinates (0;0=left/top)
  • clamp(float l) - Clamp to length
  • distanceToPlane(Vector4f q, n) : float - Calc distance of vertex to plane defined by Vector4f q (on plane) and plane normal n
  • distanceToSphere(Vector4f p, float radius) : float - Calc distance of vertex to sphere defined by Vector4f p (sphere center) and sphere radius.
  • divw() - Divide by W and return Vector3f
  • divz() - Divide by Z and return Vector2f
  • dot(Vector4f v) : float - Calculate scalar dot product from this instance and v
  • getAbs() : float - Return length of vector
  • getAbsSqr() : float - Return squared length of vector
  • getString() : String - Get string representation of vector (x, y, z, w)
  • getW() : float - Get value of w element
  • getX() : float - Get value of x element
  • getXy() : float - Get xy Vector2f
  • getXyz() : float - Get xyz Vector3f
  • getXz() : float - Get xz Vector2f
  • getY() : float - Get value of y element
  • getYz() : float - Get yz Vector2f
  • getZ() : float - Get value of z element
  • init(float x, y, z, w) - Initialize vector from scalars
  • initScalef(Vector4f v, float s) - Initialise vector to s*v
  • intersectPlane(Vector4f q, n, p1, p2) : boolean - Calc intersection between line (p1->p2) and plane (q,n).
  • isWithinSphere(Vector4f p, float radiusSquared) : boolean - Check if vertex is located within sphere defined by Vector4f p (sphere center) and squared sphere radius 'radiusSquared'.
  • lerp(Vector4f o) - Linear interpolate to another vector
  • mul(Vector4f v) - Multiply the x element of this instance by the x element of v and do the same with the y, z and w elements
  • mulf(float v) - Multiply this instance by scalar value v
  • New(float x, y, z, w) : Vector4f - Initialize and return new Vector4f instance
  • project() - Convert clip to window coordinates
  • rotate(Matrix4f m) - Multiply matrix by this vector and replace this vector by the result
  • setW(float a) - Set w element to a
  • setX(float a) - Set x element to a
  • setY(float a) - Set y element to a
  • setZ(float a) - Set z element to a
  • sub(Vector4f v) - Substract vector or array-like object
  • tensor(Vector4f v) : Matrix4f - Create resulting matrix of tensor product from this instance and v
  • transform(Matrix4f m) - Multiply matrix by this vector
  • unit() - Set length to 1
  • unitScale(float s) - Set length to s