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
• floord(Double a) : Double (tkmath) - Returns previous natural value to a
• floorf(float a) : float (tkmath) - Returns previous natural value to a
• 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 va, vb, vc, vd) : Matrix2d (tkmath) - Initialise and return new instance of Matrix2d
• matrix2f(float va, vb, vc, vd) : Matrix2f (tkmath) - Initialise and return new instance of Matrix2f
• matrix3d(Double va, vb, vc, vd, ve, vf, vg, vh, vi) : Matrix3d (tkmath) - Initialise and return new instance of Matrix3d
• matrix3f(float va, vb, vc, vd, ve, vf, vg, vh, vi) : Matrix3f (tkmath) - Initialise and return new instance of Matrix3f
• matrix4d(Object o) : Matrix4d (tkmath) - Initialise from an array and return new instance of Matrix4d
• matrix4f(Object o) : Matrix4f (tkmath) - Initialise 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) - Initialise 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) - Initialise 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 a, b, c, d) : Vector4f (tkmath) - Initialise and return new Vector4f instance with x=a, y=b, z=c and w=d

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 va, Double vb, vc, vd) - Initialise matrix
  • initCol(int c, Double va, vb) - Initialise column c of matrix
  • initColV(int c, Vector2d v) - Initialise column c of matrix
  • initf(float va, vb, vc, vd) - Initialise matrix
  • initIdentity() - Initialize with identity matrix.
  • initRow(int r, Double va, vb) - Initialise row r of matrix
  • initRowV(int r, Vector2d v) - Initialise row r of matrix
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix2d m) - Multiply this instance with matrix m
  • muld(Double v) - Multiply this instance with scalar value v
  • mulv(Vector2d v) : Vector2d - Multiply this instance with a 2dim vector
  • New(Double va, vb, vc, vd) : Matrix2d - Initialise 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 c) : Vector2f - Get column c values
  • getD() : float - Get value of d element
  • getRow(int r) : Vector2f - Get row r values
  • getString() : String - Get string representation of matrix ((a, b), (c, d))
  • init(float va, vb, vc, vd) - Initialise matrix
  • initCol(int c, float va, vb) - Initialise column c of matrix
  • initColV(int c, Vector2f v) - Initialise column c of matrix
  • initIdentity() - Initialize with identity matrix.
  • initRow(int r, float va, vb) - Initialise row r of matrix
  • initRowV(int r, Vector2f v) - Initialise row r of matrix
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix2f m) - Multiply this instance with matrix m
  • mulf(float v) - Multiply this instance with scalar value v
  • mulv(Vector2f v) : Vector2f - Multiply this instance with a 2dim vector
  • New(float va, vb, vc, vd) : Matrix2f - Initialise and return new instance of Matrix2f
  • 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, Vector2f v) - Set column c with values from v
  • setD(float v) - Set d element to v
  • setRow(int r, Vector2f v) - Set row r with values from v
  • sub(Matrix2f m) - Substract another matrix m from this instance
  • transpose() - Transpose matrix
  • unit() - Normalise matrix with Hilbert-Schmidt norm
  • unitScale(float v) - Normalise matrix with Hilbert-Schmidt norm and multiply with v 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 with matrix m
  • muld(Double v) - Multiply this instance with scalar value v
  • mulv(Vector3d v) : Vector3d - Multiply this instance with a 3dim 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() - Normalise matrix with Hilbert-Schmidt norm
  • unitScale(Double v) - Normalise matrix with Hilbert-Schmidt norm and multiply with 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 c) : Vector3f - 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
  • getRow(int r) : Vector3f - Get row r values
  • getString() : String - Get string representation of matrix ((a, b, c), (d, e, f), (g, h, i))
  • init(float va, vb, vc, vd, ve, vf, vg, vh, vi) - Initialise matrix
  • initCol(int c, float va, vb, vc) - Initialise column c of matrix
  • initColV(int c, Vector3f v) - Initialise column c of matrix
  • initIdentity() - Initialize with identity matrix.
  • initRow(int r, float va, vb, vc) - Initialise row r of matrix
  • initRowV(int r, Vector3f v) - Initialise row r of matrix
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix3f m) - Multiply this instance with matrix m
  • mulf(float v) - Multiply this instance with scalar value v
  • mulv(Vector3f v) : Vector3f - Multiply this instance with a 3dim vector
  • New(float va, vb, vc, vd, ve, vf, vg, vh, vi) : Matrix3f - Initialise and return new instance of Matrix3f
  • 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 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
  • setRow(int r, Vector3f v) - Set row r with values from v
  • sub(Matrix3f m) - Substract another matrix m from this instance
  • transpose() - Transpose matrix
  • unit() - Normalise matrix with Hilbert-Schmidt norm
  • unitScale(float v) - Normalise matrix with Hilbert-Schmidt norm and multiply with v 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 move) : 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 c) : Vector4d - 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
  • 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 r) : Vector4d - 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(Double va, vb, vc, vd, ve, vf, vg, vh, vi, vj, vk, vl, vm, vn, vo, vp) - Initialise matrix
  • initCol(int c, Double va, vb, vc, vd) - Initialise column c of matrix
  • initColV(int c, Vector4d v) - Initialise column c of matrix
  • initEulerXYX(Double a, b, c) - Initialise with euler roation matrix
  • initEulerXYZ(Double a, b, c) - Initialise with euler roation matrix
  • initEulerXZX(Double a, b, c) - Initialise with euler roation matrix
  • initEulerXZY(Double a, b, c) - Initialise with euler roation matrix
  • initEulerYXY(Double a, b, c) - Initialise with euler roation matrix
  • initEulerYXZ(Double a, b, c) - Initialise with euler roation matrix
  • initEulerYZX(Double a, b, c) - Initialise with euler roation matrix
  • initEulerYZY(Double a, b, c) - Initialise with euler roation matrix
  • initEulerZXY(Double a, b, c) - Initialise with euler roation matrix
  • initEulerZXZ(Double a, b, c) - Initialise with euler roation matrix
  • initEulerZYX(Double a, b, c) - Initialise with euler roation matrix
  • initEulerZYZ(Double a, b, c) - Initialise with euler roation matrix
  • initf(float va, vb, vc, vd, ve, vf, vg, vh, vi, vj, vk, vl, vm, vn, vo, vp) - Initialise matrix
  • initIdentity() - Initialize with identity matrix.
  • initRow(int r, Double va, vb, vc, vd) - Initialise row r of matrix
  • initRowV(int r, Vector4d v) - Initialise row r of matrix
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix4d m) - Multiply this instance with matrix m
  • mulf(Double v) - Multiply this instance with scalar value v
  • mulv(Vector4d v) : Vector4d - Multiply this instance with a 4dim vector
  • New(Object o) : Matrix4d - Initialise 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 c, Vector4d 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
  • 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 with Hilbert-Schmidt norm
  • unitScale(Double v) - Normalise matrix with Hilbert-Schmidt norm and multiply with v 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
  • BuildTranslateMatrix4f(Vector3f move) : Matrix4f - Build a translation matrix
  • 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 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 va, vb, vc, vd, ve, vf, vg, vh, vi, vj, vk, vl, vm, vn, vo, vp) - Initialise matrix
  • initCol(int c, float va, vb, vc, vd) - Initialise column c of matrix
  • initColV(int c, Vector4f v) - Initialise column c of matrix
  • initEulerXYX(float a, b, c) - Initialise with euler rotation matrix
  • initEulerXYZ(float a, b, c) - Initialise with euler rotation matrix
  • initEulerXZX(float a, b, c) - Initialise with euler rotation matrix
  • initEulerXZY(float a, b, c) - Initialise with euler rotation matrix
  • initEulerYXY(float a, b, c) - Initialise with euler rotation matrix
  • initEulerYXZ(float a, b, c) - Initialise with euler rotation matrix
  • initEulerYZX(float a, b, c) - Initialise with euler rotation matrix
  • initEulerYZY(float a, b, c) - Initialise with euler rotation matrix
  • initEulerZXY(float a, b, c) - Initialise with euler rotation matrix
  • initEulerZXZ(float a, b, c) - Initialise with euler rotation matrix
  • initEulerZYX(float a, b, c) - Initialise with euler rotation matrix
  • initEulerZYZ(float a, b, c) - Initialise with euler rotation matrix
  • initIdentity() - Initialize with identity matrix.
  • initRotate(float angle, Vector3f dir) - Initialize with rotation matrix for rotation of angle around vector dir.
  • initRow(int r, float va, vb, vc, vd) - Initialise row r of matrix
  • initRowV(int r, Vector4f v) - Initialise row r of matrix
  • invert() - Calculate inversion of matrix, so that A*A^-1=U
  • mul(Matrix4f m) - Multiply this instance with matrix m
  • mulf(float v) - Multiply this instance with scalar value v
  • mulv(Vector4f v) : Vector4f - Multiply this instance with a 4dim vector
  • New(Object o) : Matrix4f - Initialise from an array and return new instance of Matrix4f
  • 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
  • setRC(int row, col, float v) - Set element at (row, column) to v
  • setRow(int r, Vector4f v) - Set row r with values from v
  • sub(Matrix4f m) - Substract another matrix m from this instance
  • 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) - Initialise values to x=a and y=b
  • initf(float a, b) - Initialise with single precision values to x=a and x=b
  • initScaled(Vector2d v, Double s) - Initialise values to s*v
  • mul(Vector2d v) - Multiply the x element of this instance with the x element of v and do the same with the y element
  • muld(Double v) - Multiply this instance with scalar value v
  • New(Double a, b) : Vector2d - Initialise 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
  • 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
  • getString() : String - Get string representation (x, y) of vector
  • getX() : float - Get value of x element
  • getY() : float - Get value of y element
  • init(float a, b) - Initialise values to x=a and y=b
  • initScalef(Vector2f v, float s) - Initialise values to s*v
  • mul(Vector2f v) - Multiply the x element of this instance with the x element of v and do the same with the y element
  • mulf(float v) - Multiply this instance with scalar value v
  • New(float a, b) : Vector2f - Initialise and return new Vector2f instance with x=a and y=b
  • 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
  • unit() - Set length to 1
  • 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 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 with the x element of v and do the same with the y and z element
  • muld(Double v) - Multiply this instance with 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
  • cross(Vector3f v) : Vector3f - Calculate cross product from this instance and v
  • dot(Vector3f v) : float - Calculate 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
  • getY() : float - Get value of y element
  • getZ() : float - Get value of z element
  • init(float a, b, c) - Initialise values to x=a, y=b and z=c
  • initScalef(Vector3f v, float s) - Initialise vector to s*v
  • mul(Vector3f v) - Multiply the x element of this instance with the x element of v and do the same with the y and z element
  • mulf(float v) - Multiply this instance with scalar value v
  • New(float a, b, c) : Vector3f - Initialise and return new Vector3f instance with x=a, y=b and z=c
  • 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
  • triple(Vector3f b, c) : float - Calculate triple product this.dot(b.cross(c)) (a*(bxc))  
  • unit() - Set length to 1
  • unitScale(float s) - Set length to s
  
  
• 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 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 with the x element of v and do the same with the y, z and w elements
  • muld(Double v) - Multiply this instance with 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 another vector v to this instance
  • dot(Vector4f v) : float - Calculate 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
  • getY() : float - Get value of y element
  • getZ() : float - Get value of z element
  • init(float a, b, c, d) - Initialise values to x=a, y=b, z=c and w=d
  • initScalef(Vector4f v, float s) - Initialise vector to s*v
  • mul(Vector4f v) - Multiply the x element of this instance with the x element of v and do the same with the y, z and w elements
  • mulf(float v) - Multiply this instance with scalar value v
  • New(float a, b, c, d) : Vector4f - Initialise and return new Vector4f instance with x=a, y=b, z=c and w=d
  • 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 another vector v from this instance
  • tensor(Vector4f v) : Matrix4f - Create resulting matrix of tensor product from this instance and v
  • unit() - Set length to 1
  • unitScale(float s) - Set length to s