Skip to content

Vectors and Matrices

WalchAndreas edited this page Sep 6, 2017 · 13 revisions

Overview

Data types

Vector types start with a capital V, followed by the dimension (2, 3, or 4) and the element type (d, f, l, or i).

dim float64 float32 int64 int32
2 V2d V2f V2l V2i
3 V3d V3f V3l V3i
4 V4d V4f V4l V4i

Matrix types start with a capital M, followed by the number of rows (2, 3, or 4), the number of columns (2, 3, or 4) and the element type (d, f, l, or i). See the following table for all available types.

dim float64 float32 int64 int32
2x2 M22d M22f M22l M22i
2x3 M23d M23f M23l M23i
3x3 M33d M33f M33l M33i
3x4 M34d M34f M34l M34i
4x4 M44d M44f M44l M44i

Construction

Vectors

example value
V3d.Zero (0.0, 0.0, 0.0)
V3d.One (1.0, 1.0, 1.0)
V3d.XAxis (1.0, 0.0, 0.0)
V3d.YAxis (0.0, 1.0, 0.0)
V3d.ZAxis (0.0, 0.0, 1.0)
V4d.WAxis (0.0, 0.0, 0.0, 1.0)
V3d.IOI (1.0, 0.0, 1.0), where I is 1.0, and O is 0.0
V3d.NOP (-1.0, 0.0, 1.0), where P is +1.0, and N is -1.0
V3d() (0.0, 0.0, 0.0)
V3d(3.5) (3.5, 3.5, 3.5)
V2d(1.2, 3.4) (1.2, 3.4)
V3d(V2d(1.2, 3.4), 5.6) (1.2, 3.4, 5.6)
V3d.MaxValue (double.MaxValue, double.MaxValue, double.MaxValue)
V3d.MinValue (double.MinValue, double.MinValue, double.MinValue)
V3d.NegativeInfinity (double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)
V3d.PositiveInfinity (double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)
V3d.NaN (double.NaN, double.NaN, double.NaN)

Matrices

example description
M44d.Zero all elements zero
M44d.Identity identity matrix
M44d() all elements zero

Transformation Matrices

example description
M44d.Translation(dx, dy, dz) translation
M44d.Scale(s) uniform scale
M44d.Scale(sx, sy, sz) non-uniform scale
M44d.RotationX(angleInRadians) rotation around x-axis
M44d.RotationY(angleInRadians) rotation around y-axis
M44d.RotationZ(angleInRadians) rotation around z-axis
M44d.Rotation(axis, angleInRadians) rotation around specified axis
M44d.Rotation(yaw, pitch, roll) rotation given by yaw, pitch, and roll in radians
M44d.ShearXY(factorX, factorY) shear along x and y
M44d.ShearXZ(factorX, factorZ) shear along x and z
M44d.ShearYZ(factorY, factorZ) shear along y and z

Accessors

Vectors

let v = V4d(2.0, 4.0, 8.0, 1.0)

v.X     // 2.0
v.Y     // 4.0
v.Z     // 8.0
v.W     // 1.0

Matrices

Elements

M00 M01 M02 M03
M10 M11 M12 M13
M20 M21 M22 M23
M30 M31 M32 M33

Columns

C0 C1 C2 C3

Rows

R0
R1
R2
R3

Examples

let m = M33d(1.0, 2.0, 3.0,
             4.0, 5.0, 6.0,
             0.0, 0.0, 1.0)

m.M01   // 2.0
m.M12   // 6.0

m.R0  // V3d(1.0, 2.0, 3.0); row0
m.R1  // V3d(4.0, 5.0, 6.0); row1
m.C0  // V3d(1.0, 4.0, 0.0); column0
m.C2  // V3d(3.0, 6.0, 1.0); column1

Operations

Arithmetic Operators

a + b        // component-wise addition
a - b        // component-wise subtraction
a * b        // component-wise multiplication
a / b        // component-wise division
a % b        // component-wise modulo

Relational Operators

a == b               // component-wise comparison
a != b
a.AllSmaller(b)      // component-wise smaller-than (true if all comparisons are true)
a.AnySmaller(b)      // component-wise smaller-than (true if at least one comparison is true)
...                  // Smaller, SmallerEqual, Greater, GreaterEqual

Properties vs Methods

Properties by default DO NOT change the underlying data (vector), whereas methods usually DO. E.g. v.Normalized returns a normalized copy of v but does not touch v itself, and v.Normalize() normalizes v itself (and returns this so one can chain method calls). ATTENTION: since all vector and matrix types are value types returning this returns a copy and DOES NOT reference the original struct.

Properties

v.Length
v.LengthSquared
v.Negated
v.Normalized
v.Reciprocal   // returns component-wise reciprocal (1/x)

Methods

v.Negate()
v.Normalize()
V3d.DotProduct(a, b)
V3d.CrossProduct(a, b)

Scalar/Vector

let v = V3d(1.0, 2.0, 4.0)

-v              // (-1.0, -2.0, -3.0)
v * 0.2         // (0.2, 0.4, 0.8)
0.2 * v         // (0.2, 0.4, 0.8)
v / 2.0         // (0.5, 1.0, 2.0)
2.0 / v         // (2.0, 1.0, 0.5)
v + 0.5         // (1.5, 2.5, 4.5)
0.5 + v         // (1.5, 2.5, 4.5)
v - 0.5         // (0.5, 1.5, 3.5)
0.5 - v         // (-0.5, -1.5, -3.5)

Vector/Vector

let u = V3d(10.0, 20.0, 40.0)
let v = V3d(5.0, 10.0, 20.0)

u + v           // (15.0, 30.0, 60.0)
u - v           // (5.0, 10.0, 20.0)
u * v           // (50.0, 200.0, 800.0)
u / v           // (2.0, 2.0, 2.0)

Dot product

let u = V3d(1.0, 0.0, 0.0)
let v = V3d(0.0, 1.0, 0.0)

u.Dot(v)        // 0.0
V3d.Dot(u, v)   // 0.0

Cross product

let u = V3d(1.0, 0.0, 0.0)
let v = V3d(0.0, 1.0, 0.0)

u.Cross(v)        // (0.0, 0.0, 1.0)
V3d.Cross(u, v)   // (0.0, 0.0, 1.0)

Normalization

let v = V2d(5.0, 0.0)

v.Normalized      // (1.0, 0.0)

Length and Norms

let v = V2d(3.0, 4.0)

v.Length          // 5.0
v.LengthSquared   // 25.0
v.Norm1           // 7.0; 1-norm or Manhattan-norm
v.Norm2           // 25.0; 2-norm or Euclidean-norm; same as a.Length
v.NormMax         // 4.0; maximum-norm
v.NormMin         // 3.0; minimum-norm

Abs, Floor, Ceil

let v = V3d(1.6, -2.3, 3.1)

v.Abs    // (1.6, 2.3, 3.1)
v.Floor  // (1.0, -3.0, 3.0)
v.Ceil   // (2.0, -2.0, 4.0)

Swizzle

let v = V3d(3.0, 4.0, 5.0)

v.YX              // V2d(4.0, 3.0))
v.XZIY            // V4d(3.0, 5.0, 1.0, 4.0)
v.XXX             // V3d(3.0, 3.0, 3.0)
v.XYO             // V3d(3.0, 4.0, 0.0)

Various

let v = V4d(2.0, 4.0, 8.0, 1.0)
let m = M33d(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.0, 0.0, 1.0)

m.Adjoint           // [[5, -2, -3], [-4, 1, 6], [0, 0, -3]]
m.Det               // -3.0
m.InvTransformDir   
m.InvTransformPos
m.InvTransformPosProj
m.Inverse           // [[-1.66..., 0.66..., 1], [1.33..., -0.33..., -2], [0, 0, 1]]
m.Invertible        // true
m.IsIdentity
m.IsOrthogonal
m.IsOrthonormal
m.LuInverse() 
m.QrInverse()
m.Norm1             // 22.0
m.Norm2             // 9.5916630466254382
m.NormMax           // 6.0
m.NormMin           // 0.0
m.Singular          // false
m.Trace             // 7.0
m.Transform
m.TransformDir
m.TransformPos
m.TransformPosProj
m.TransformPosProjFull
m.Transposed        // [[1, 4, 0], [2, 5, 0], [3, 6, 1]]
m.TransposedTransform
m.TransposedTransformDir
m.TransposedTransformPos
Clone this wiki locally
You can’t perform that action at this time.