Unit Neslib.FastMath

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Fast Math Library for Delphi.

You can set these conditional defines to modify the behavior of this library:

FM_COLUMN_MAJOR: Store matrices in column-major order. Be default, matrices are store in row-major order for compatibility with the Delphi RTL. However, for OpenGL applications, it makes more sense to store matrices in column- major order. Another side effect of this define is that the depth of camera matrices are clipped to -1..1 (common with OpenGL) instead of 0..1 (uses by the Delphi RTL).
FM_NOSIMD: Disable SIMD (SSE2, NEON, ARM64) optimizations and run all calculations using Pascal code only. You will generally only enable this define for (performance) testing, or when running on an old PC that does not have support for SSE2.

Overview

Classes, Interfaces, Objects and Records

Name	Description
record `TVector2`	A 2-dimensional vector.
record `TVector3`	A 3-dimensional vector.
record `TVector4`	A 4-dimensional vector.
record `TMatrix2`	A 2x2 matrix in row-major order (M[Row, Column]).
record `TMatrix3`	A 3x3 matrix in row-major order (M[Row, Column]).
record `TMatrix4`	A 4x4 matrix in row-major order (M[Row, Column]).
record `_TMatrix2Helper`	Adds common constants of type TMatrix2
record `_TMatrix3Helper`	Adds common constants of type TMatrix3
record `_TMatrix4Helper`	Adds common constants of type TMatrix4
record `TQuaternion`	A quaternion.
record `_TQuaternionHelper`	Adds common constants and functionality to TQuaternion
record `TIVector2`	A 2-dimensional vector that uses integer components instead of floating-point components.
record `_TVector2Helper`	Adds common constants of type TVector2
record `TIVector3`	A 3-dimensional vector that uses integer components instead of floating-point components.
record `_TVector3Helper`	Adds common constants of type TVector3
record `TIVector4`	A 4-dimensional vector that uses integer components instead of floating-point components.
record `_TVector4Helper`	Adds common constants of type TVector4

Functions and Procedures

function Vector2: TVector2; overload; inline;

function Vector2(const A: Single): TVector2; overload; inline;

function Vector2(const A1, A2: Single): TVector2; overload; inline;

function Vector2(const AVector: TVector3): TVector2; overload; inline;

function Vector2(const AVector: TVector4): TVector2; overload; inline;

function Vector3: TVector3; overload;

function Vector3(const A: Single): TVector3; overload;

function Vector3(const A1, A2, A3: Single): TVector3; overload;

function Vector3(const A1: TVector2; const A2: Single): TVector3; overload;

function Vector3(const A1: Single; const A2: TVector2): TVector3; overload;

function Vector3(const AVector: TVector4): TVector3; overload;

function Vector4: TVector4; overload;

function Vector4(const A: Single): TVector4; overload;

function Vector4(const A1, A2, A3, A4: Single): TVector4; overload;

function Vector4(const A1: TVector2; const A2, A3: Single): TVector4; overload;

function Vector4(const A1: Single; const A2: TVector2; const A3: Single): TVector4; overload;

function Vector4(const A1, A2: Single; const A3: TVector2): TVector4; overload;

function Vector4(const A1, A2: TVector2): TVector4; overload;

function Vector4(const A1: TVector3; const A2: Single): TVector4; overload;

function Vector4(const A1: Single; const A2: TVector3): TVector4; overload;

function Quaternion: TQuaternion; overload;

function Quaternion(const AX, AY, AZ, AW: Single): TQuaternion; overload;

function Quaternion(const AAxis: TVector3; const AAngleRadians: Single): TQuaternion; overload;

function Matrix2: TMatrix2; overload;

function Matrix2(const ADiagonal: Single): TMatrix2; overload;

function Matrix2(const ARow0, ARow1: TVector2): TMatrix2; overload;

function Matrix2(const A11, A12, A21, A22: Single): TMatrix2; overload;

function Matrix2(const AMatrix: TMatrix3): TMatrix2; overload;

function Matrix2(const AMatrix: TMatrix4): TMatrix2; overload;

function Matrix3: TMatrix3; overload;

function Matrix3(const ADiagonal: Single): TMatrix3; overload;

function Matrix3(const ARow0, ARow1, ARow2: TVector3): TMatrix3; overload;

function Matrix3(const A11, A12, A13, A21, A22, A23, A31, A32, A33: Single): TMatrix3; overload;

function Matrix3(const AMatrix: TMatrix2): TMatrix3; overload;

function Matrix3(const AMatrix: TMatrix4): TMatrix3; overload;

function Matrix4: TMatrix4; overload;

function Matrix4(const ADiagonal: Single): TMatrix4; overload;

function Matrix4(const ARow0, ARow1, ARow2, ARow3: TVector4): TMatrix4; overload;

function Matrix4(const A11, A12, A13, A14, A21, A22, A23, A24, A31, A32, A33, A34, A41, A42, A43, A44: Single): TMatrix4; overload;

function Matrix4(const AMatrix: TMatrix2): TMatrix4; overload;

function Matrix4(const AMatrix: TMatrix3): TMatrix4; overload;

function IVector2: TIVector2; overload; inline;

function IVector2(const A: Integer): TIVector2; overload; inline;

function IVector2(const A1, A2: Integer): TIVector2; overload; inline;

function IVector3: TIVector3; overload;

function IVector3(const A: Integer): TIVector3; overload;

function IVector3(const A1, A2, A3: Integer): TIVector3; overload;

function IVector4: TIVector4; overload;

function IVector4(const A: Integer): TIVector4; overload;

function IVector4(const A1, A2, A3, A4: Integer): TIVector4; overload;

function Radians(const ADegrees: Single): Single; overload; inline;

function Radians(const ADegrees: TVector2): TVector2; overload;

function Radians(const ADegrees: TVector3): TVector3; overload;

function Radians(const ADegrees: TVector4): TVector4; overload;

function Degrees(const ARadians: Single): Single; overload; inline;

function Degrees(const ARadians: TVector2): TVector2; overload;

function Degrees(const ARadians: TVector3): TVector3; overload;

function Degrees(const ARadians: TVector4): TVector4; overload;

function Sin(const ARadians: Single): Single; overload; inline;

function Sin(const ARadians: TVector2): TVector2; overload; inline;

function Sin(const ARadians: TVector3): TVector3; overload; inline;

function Sin(const ARadians: TVector4): TVector4; overload; inline;

function Cos(const ARadians: Single): Single; overload; inline;

function Cos(const ARadians: TVector2): TVector2; overload; inline;

function Cos(const ARadians: TVector3): TVector3; overload; inline;

function Cos(const ARadians: TVector4): TVector4; overload; inline;

procedure SinCos(const ARadians: Single; out ASin, ACos: Single); overload;

procedure SinCos(const ARadians: TVector2; out ASin, ACos: TVector2); overload;

procedure SinCos(const ARadians: TVector3; out ASin, ACos: TVector3); overload;

procedure SinCos(const ARadians: TVector4; out ASin, ACos: TVector4); overload;

function Tan(const ARadians: Single): Single; overload; inline;

function Tan(const ARadians: TVector2): TVector2; overload; inline;

function Tan(const ARadians: TVector3): TVector3; overload; inline;

function Tan(const ARadians: TVector4): TVector4; overload; inline;

function ArcSin(const A: Single): Single; overload; inline;

function ArcSin(const A: TVector2): TVector2; overload; inline;

function ArcSin(const A: TVector3): TVector3; overload; inline;

function ArcSin(const A: TVector4): TVector4; overload; inline;

function ArcCos(const A: Single): Single; overload; inline;

function ArcCos(const A: TVector2): TVector2; overload; inline;

function ArcCos(const A: TVector3): TVector3; overload; inline;

function ArcCos(const A: TVector4): TVector4; overload; inline;

function ArcTan(const A: Single): Single; overload; inline;

function ArcTan(const A: TVector2): TVector2; overload; inline;

function ArcTan(const A: TVector3): TVector3; overload; inline;

function ArcTan(const A: TVector4): TVector4; overload; inline;

function ArcTan2(const Y, X: Single): Single; overload; inline;

function ArcTan2(const Y, X: TVector2): TVector2; overload; inline;

function ArcTan2(const Y, X: TVector3): TVector3; overload; inline;

function ArcTan2(const Y, X: TVector4): TVector4; overload; inline;

function Sinh(const A: Single): Single; overload; inline;

function Sinh(const A: TVector2): TVector2; overload; inline;

function Sinh(const A: TVector3): TVector3; overload; inline;

function Sinh(const A: TVector4): TVector4; overload; inline;

function Cosh(const A: Single): Single; overload; inline;

function Cosh(const A: TVector2): TVector2; overload; inline;

function Cosh(const A: TVector3): TVector3; overload; inline;

function Cosh(const A: TVector4): TVector4; overload; inline;

function Tanh(const A: Single): Single; overload; inline;

function Tanh(const A: TVector2): TVector2; overload; inline;

function Tanh(const A: TVector3): TVector3; overload; inline;

function Tanh(const A: TVector4): TVector4; overload; inline;

function ArcSinh(const A: Single): Single; overload; inline;

function ArcSinh(const A: TVector2): TVector2; overload; inline;

function ArcSinh(const A: TVector3): TVector3; overload; inline;

function ArcSinh(const A: TVector4): TVector4; overload; inline;

function ArcCosh(const A: Single): Single; overload; inline;

function ArcCosh(const A: TVector2): TVector2; overload; inline;

function ArcCosh(const A: TVector3): TVector3; overload; inline;

function ArcCosh(const A: TVector4): TVector4; overload; inline;

function ArcTanh(const A: Single): Single; overload; inline;

function ArcTanh(const A: TVector2): TVector2; overload; inline;

function ArcTanh(const A: TVector3): TVector3; overload; inline;

function ArcTanh(const A: TVector4): TVector4; overload; inline;

function Power(const ABase, AExponent: Single): Single; overload; inline;

function Power(const ABase, AExponent: TVector2): TVector2; overload; inline;

function Power(const ABase, AExponent: TVector3): TVector3; overload;

function Power(const ABase, AExponent: TVector4): TVector4; overload;

function Exp(const A: Single): Single; overload; inline;

function Exp(const A: TVector2): TVector2; overload; inline;

function Exp(const A: TVector3): TVector3; overload;

function Exp(const A: TVector4): TVector4; overload;

function Ln(const A: Single): Single; overload; inline;

function Ln(const A: TVector2): TVector2; overload; inline;

function Ln(const A: TVector3): TVector3; overload;

function Ln(const A: TVector4): TVector4; overload;

function Exp2(const A: Single): Single; overload; inline;

function Exp2(const A: TVector2): TVector2; overload; inline;

function Exp2(const A: TVector3): TVector3; overload;

function Exp2(const A: TVector4): TVector4; overload;

function Log2(const A: Single): Single; overload; inline;

function Log2(const A: TVector2): TVector2; overload; inline;

function Log2(const A: TVector3): TVector3; overload;

function Log2(const A: TVector4): TVector4; overload;

function Sqrt(const A: Single): Single; overload;

function Sqrt(const A: TVector2): TVector2; overload;

function Sqrt(const A: TVector3): TVector3; overload;

function Sqrt(const A: TVector4): TVector4; overload;

function InverseSqrt(const A: Single): Single; overload;

function InverseSqrt(const A: TVector2): TVector2; overload;

function InverseSqrt(const A: TVector3): TVector3; overload;

function InverseSqrt(const A: TVector4): TVector4; overload;

function FastSin(const ARadians: Single): Single; overload;

function FastSin(const ARadians: TVector2): TVector2; overload;

function FastSin(const ARadians: TVector3): TVector3; overload;

function FastSin(const ARadians: TVector4): TVector4; overload;

function FastCos(const ARadians: Single): Single; overload;

function FastCos(const ARadians: TVector2): TVector2; overload;

function FastCos(const ARadians: TVector3): TVector3; overload;

function FastCos(const ARadians: TVector4): TVector4; overload;

procedure FastSinCos(const ARadians: Single; out ASin, ACos: Single); overload;

procedure FastSinCos(const ARadians: TVector2; out ASin, ACos: TVector2); overload;

procedure FastSinCos(const ARadians: TVector3; out ASin, ACos: TVector3); overload;

procedure FastSinCos(const ARadians: TVector4; out ASin, ACos: TVector4); overload;

function FastTan(const ARadians: Single): Single; overload;

function FastTan(const ARadians: TVector2): TVector2; overload;

function FastTan(const ARadians: TVector3): TVector3; overload;

function FastTan(const ARadians: TVector4): TVector4; overload;

function FastArcTan2(const Y, X: Single): Single; overload;

function FastArcTan2(const Y, X: TVector2): TVector2; overload;

function FastArcTan2(const Y, X: TVector3): TVector3; overload;

function FastArcTan2(const Y, X: TVector4): TVector4; overload;

function FastPower(const ABase, AExponent: Single): Single; overload; inline;

function FastPower(const ABase, AExponent: TVector2): TVector2; overload; inline;

function FastPower(const ABase, AExponent: TVector3): TVector3; overload;

function FastPower(const ABase, AExponent: TVector4): TVector4; overload;

function FastExp(const A: Single): Single; overload;

function FastExp(const A: TVector2): TVector2; overload;

function FastExp(const A: TVector3): TVector3; overload;

function FastExp(const A: TVector4): TVector4; overload;

function FastLn(const A: Single): Single; overload;

function FastLn(const A: TVector2): TVector2; overload;

function FastLn(const A: TVector3): TVector3; overload;

function FastLn(const A: TVector4): TVector4; overload;

function FastLog2(const A: Single): Single; overload;

function FastLog2(const A: TVector2): TVector2; overload;

function FastLog2(const A: TVector3): TVector3; overload;

function FastLog2(const A: TVector4): TVector4; overload;

function FastExp2(const A: Single): Single; overload;

function FastExp2(const A: TVector2): TVector2; overload;

function FastExp2(const A: TVector3): TVector3; overload;

function FastExp2(const A: TVector4): TVector4; overload;

function Abs(const A: Single): Single; overload; inline;

function Abs(const A: TVector2): TVector2; overload; inline;

function Abs(const A: TVector3): TVector3; overload;

function Abs(const A: TVector4): TVector4; overload;

function Sign(const A: Single): Single; overload;

function Sign(const A: TVector2): TVector2; overload;

function Sign(const A: TVector3): TVector3; overload;

function Sign(const A: TVector4): TVector4; overload;

function Floor(const A: Single): Integer; overload; inline;

function Floor(const A: TVector2): TIVector2; overload;

function Floor(const A: TVector3): TIVector3; overload;

function Floor(const A: TVector4): TIVector4; overload;

function Trunc(const A: Single): Integer; overload; inline;

function Trunc(const A: TVector2): TIVector2; overload;

function Trunc(const A: TVector3): TIVector3; overload;

function Trunc(const A: TVector4): TIVector4; overload;

function Round(const A: Single): Integer; overload; inline;

function Round(const A: TVector2): TIVector2; overload;

function Round(const A: TVector3): TIVector3; overload;

function Round(const A: TVector4): TIVector4; overload;

function Ceil(const A: Single): Integer; overload; inline;

function Ceil(const A: TVector2): TIVector2; overload;

function Ceil(const A: TVector3): TIVector3; overload;

function Ceil(const A: TVector4): TIVector4; overload;

function Frac(const A: Single): Single; overload; inline;

function Frac(const A: TVector2): TVector2; overload;

function Frac(const A: TVector3): TVector3; overload;

function Frac(const A: TVector4): TVector4; overload;

function FMod(const A, B: Single): Single; overload; inline;

function FMod(const A: TVector2; const B: Single): TVector2; overload;

function FMod(const A, B: TVector2): TVector2; overload;

function FMod(const A: TVector3; const B: Single): TVector3; overload;

function FMod(const A, B: TVector3): TVector3; overload; inline;

function FMod(const A: TVector4; const B: Single): TVector4; overload;

function FMod(const A, B: TVector4): TVector4; overload;

function ModF(const A: Single; out B: Integer): Single; overload; inline;

function ModF(const A: TVector2; out B: TIVector2): TVector2; overload;

function ModF(const A: TVector3; out B: TIVector3): TVector3; overload;

function ModF(const A: TVector4; out B: TIVector4): TVector4; overload;

function Min(const A, B: Single): Single; overload; inline;

function Min(const A: TVector2; const B: Single): TVector2; overload;

function Min(const A, B: TVector2): TVector2; overload;

function Min(const A: TVector3; const B: Single): TVector3; overload;

function Min(const A, B: TVector3): TVector3; overload;

function Min(const A: TVector4; const B: Single): TVector4; overload;

function Min(const A, B: TVector4): TVector4; overload;

function Max(const A, B: Single): Single; overload; inline;

function Max(const A: TVector2; const B: Single): TVector2; overload;

function Max(const A, B: TVector2): TVector2; overload;

function Max(const A: TVector3; const B: Single): TVector3; overload;

function Max(const A, B: TVector3): TVector3; overload;

function Max(const A: TVector4; const B: Single): TVector4; overload;

function Max(const A, B: TVector4): TVector4; overload;

function EnsureRange(const A, AMin, AMax: Single): Single; overload;

function EnsureRange(const A: TVector2; const AMin, AMax: Single): TVector2; overload;

function EnsureRange(const A, AMin, AMax: TVector2): TVector2; overload;

function EnsureRange(const A: TVector3; const AMin, AMax: Single): TVector3; overload;

function EnsureRange(const A, AMin, AMax: TVector3): TVector3; overload;

function EnsureRange(const A: TVector4; const AMin, AMax: Single): TVector4; overload;

function EnsureRange(const A, AMin, AMax: TVector4): TVector4; overload;

function Mix(const A, B, T: Single): Single; overload; inline;

function Mix(const A, B: TVector2; const T: Single): TVector2; overload; inline;

function Mix(const A, B, T: TVector2): TVector2; overload; inline;

function Mix(const A, B: TVector3; const T: Single): TVector3; overload;

function Mix(const A, B, T: TVector3): TVector3; overload;

function Mix(const A, B: TVector4; const T: Single): TVector4; overload;

function Mix(const A, B, T: TVector4): TVector4; overload;

function Step(const AEdge, A: Single): Single; overload; inline;

function Step(const AEdge: Single; const A: TVector2): TVector2; overload;

function Step(const AEdge, A: TVector2): TVector2; overload;

function Step(const AEdge: Single; const A: TVector3): TVector3; overload;

function Step(const AEdge, A: TVector3): TVector3; overload;

function Step(const AEdge: Single; const A: TVector4): TVector4; overload;

function Step(const AEdge, A: TVector4): TVector4; overload;

function SmoothStep(const AEdge0, AEdge1, A: Single): Single; overload; inline;

function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector2): TVector2; overload; inline;

function SmoothStep(const AEdge0, AEdge1, A: TVector2): TVector2; overload; inline;

function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector3): TVector3; overload; inline;

function SmoothStep(const AEdge0, AEdge1, A: TVector3): TVector3; overload;

function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector4): TVector4; overload;

function SmoothStep(const AEdge0, AEdge1, A: TVector4): TVector4; overload;

function FMA(const A, B, C: Single): Single; overload; inline;

function FMA(const A, B, C: TVector2): TVector2; overload;

function FMA(const A, B, C: TVector3): TVector3; overload;

function FMA(const A, B, C: TVector4): TVector4; overload;

function OuterProduct(const C, R: TVector2): TMatrix2; overload;

function OuterProduct(const C, R: TVector3): TMatrix3; overload;

function OuterProduct(const C, R: TVector4): TMatrix4; overload;

procedure DisableFloatingPointExceptions;

procedure RestoreFloatingPointExceptions;

Types

PVector2 = ˆTVector2;

PVector3 = ˆTVector3;

PVector4 = ˆTVector4;

PMatrix2 = ˆTMatrix2;

PMatrix3 = ˆTMatrix3;

PMatrix4 = ˆTMatrix4;

PIVector2 = ˆTIVector2;

PIVector3 = ˆTIVector3;

PIVector4 = ˆTIVector4;

Constants

SINGLE_TOLERANCE = 0.000001;

Description

Functions and Procedures

function Vector2: TVector2; overload; inline;

Creates a 2D zero-vector.

Note: it is more efficient to use TVector2.Init instead.

function Vector2(const A: Single): TVector2; overload; inline;

Creates a 2D vector with the two elements (X and Y) set to A.

Note: it is more efficient to use TVector2.Init instead.

Parameters

A: the value to set the two elements to.

function Vector2(const A1, A2: Single): TVector2; overload; inline;

Creates a 2D vector with the two elements (X and Y) set to A1 and A2 respectively.

Note: it is more efficient to use TVector2.Init instead.

Parameters

A1: the value to set the first element to.
A2: the value to set the second element to.

function Vector2(const AVector: TVector3): TVector2; overload; inline;

Creates a 2D vector using the first to elements (X and Y) of a 3D vector.

Note: it is more efficient to use TVector2.Init instead.

Parameters

AVector: the source vector

function Vector2(const AVector: TVector4): TVector2; overload; inline;

Creates a 2D vector using the first two elements (X and Y) of a 4D vector.

Note: it is more efficient to use TVector2.Init instead.

Parameters

AVector: the source vector

function Vector3: TVector3; overload;

Creates a 3D zero-vector.

Note: it is more efficient to use TVector3.Init instead.

function Vector3(const A: Single): TVector3; overload;

Creates a 3D vector with the three elements (X, Y and Z) set to A.

Note: it is more efficient to use TVector3.Init instead.

Parameters

A: the value to set the three elements to.

function Vector3(const A1, A2, A3: Single): TVector3; overload;

Creates a 3D vector with the three elements (X, Y and Z) set to A1, A2 and A3 respectively.

Note: it is more efficient to use TVector3.Init instead.

Parameters

A1: the value to set the first element to.
A2: the value to set the second element to.
A3: the value to set the third element to.

function Vector3(const A1: TVector2; const A2: Single): TVector3; overload;

Creates a 3D vector with the first two elements from a 2D vector, and the third element from a scalar.

Note: it is more efficient to use TVector3.Init instead.

Parameters

A1: the vector to use for the first two elements.
A2: the value to set the third element to.

function Vector3(const A1: Single; const A2: TVector2): TVector3; overload;

Creates a 3D vector with the first element from a scaler, and the last two elements from a 2D vector.

Note: it is more efficient to use TVector3.Init instead.

Parameters

A1: the value to set the first element to.
A2: the vector to use for the last two elements.

function Vector3(const AVector: TVector4): TVector3; overload;

Creates a 3D vector using the first three elements (X, Y and Z) of a 4D vector.

Note: it is more efficient to use TVector3.Init instead.