mgl64

func (InferMatrixError) Error ¶

func (me InferMatrixError) Error() string

func (Mat2) Abs ¶

func (m Mat2) Abs() Mat2

Abs returns the element-wise absolute value of this matrix

func (Mat2) Add ¶

func (m1 Mat2) Add(m2 Mat2) Mat2

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat2) ApproxEqual ¶

func (m1 Mat2) ApproxEqual(m2 Mat2) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat2) ApproxEqualThreshold ¶

func (m1 Mat2) ApproxEqualThreshold(m2 Mat2, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat2) ApproxFuncEqual ¶

func (m1 Mat2) ApproxFuncEqual(m2 Mat2, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat2) At ¶

func (m Mat2) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat2) Col ¶

func (m Mat2) Col(col int) Vec2

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat2) Cols ¶

func (m Mat2) Cols() (col0, col1 Vec2)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat2) Det ¶

func (m Mat2) Det() float64

Det returns the determinant of a matrix. It is a measure of a square matrix's singularity and invertability, among other things. In this library, the determinant is hard coded based on pre-computed cofactor expansion, and uses no loops. Of course, the addition and multiplication must still be done.

func (Mat2) Diag ¶

func (m Mat2) Diag() Vec2

Diag is a basic operation on a square matrix that simply returns main diagonal (meaning all elements such that row==col).

func (Mat2) Index ¶

func (m Mat2) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat2) Inv ¶

func (m Mat2) Inv() Mat2

Inv computes the inverse of a square matrix. An inverse is a square matrix such that when multiplied by the original, yields the identity.

M_inv * M = M * M_inv = I

In this library, the math is precomputed, and uses no loops, though the multiplications, additions, determinant calculation, and scaling are still done. This can still be (relatively) expensive for a 4x4.

This function checks the determinant to see if the matrix is invertible. If the determinant is 0.0, this function returns the zero matrix. However, due to floating point errors, it is entirely plausible to get a false positive or negative. In the future, an alternate function may be written which takes in a pre-computed determinant.

func (Mat2) Mat3 ¶

func (m Mat2) Mat3() Mat3

func (Mat2) Mat4 ¶

func (m Mat2) Mat4() Mat4

func (Mat2) Mul ¶

func (m1 Mat2) Mul(c float64) Mat2

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat2) Mul2 ¶

func (m1 Mat2) Mul2(m2 Mat2) Mat2

Mul2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2) Mul2x1 ¶

func (m1 Mat2) Mul2x1(m2 Vec2) Vec2

Mul2x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2) Mul2x3 ¶

func (m1 Mat2) Mul2x3(m2 Mat2x3) Mat2x3

Mul2x3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2) Mul2x4 ¶

func (m1 Mat2) Mul2x4(m2 Mat2x4) Mat2x4

Mul2x4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2) Row ¶

func (m Mat2) Row(row int) Vec2

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat2) Rows ¶

func (m Mat2) Rows() (row0, row1 Vec2)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat2) Set ¶

func (m *Mat2) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat2) SetCol ¶

func (m *Mat2) SetCol(col int, v Vec2)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat2) SetRow ¶

func (m *Mat2) SetRow(row int, v Vec2)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat2) String ¶

func (m Mat2) String() string

Pretty prints the matrix

func (Mat2) Sub ¶

func (m1 Mat2) Sub(m2 Mat2) Mat2

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat2) Trace ¶

func (m Mat2) Trace() float64

Trace is a basic operation on a square matrix that simply sums up all elements on the main diagonal (meaning all elements such that row==col).

func (Mat2) Transpose ¶

func (m1 Mat2) Transpose() Mat2

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat2x3) Abs ¶

func (m Mat2x3) Abs() Mat2x3

Abs returns the element-wise absolute value of this matrix

func (Mat2x3) Add ¶

func (m1 Mat2x3) Add(m2 Mat2x3) Mat2x3

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat2x3) ApproxEqual ¶

func (m1 Mat2x3) ApproxEqual(m2 Mat2x3) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat2x3) ApproxEqualThreshold ¶

func (m1 Mat2x3) ApproxEqualThreshold(m2 Mat2x3, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat2x3) ApproxFuncEqual ¶

func (m1 Mat2x3) ApproxFuncEqual(m2 Mat2x3, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat2x3) At ¶

func (m Mat2x3) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat2x3) Col ¶

func (m Mat2x3) Col(col int) Vec2

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat2x3) Cols ¶

func (m Mat2x3) Cols() (col0, col1, col2 Vec2)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat2x3) Index ¶

func (m Mat2x3) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat2x3) Mul ¶

func (m1 Mat2x3) Mul(c float64) Mat2x3

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat2x3) Mul3 ¶

func (m1 Mat2x3) Mul3(m2 Mat3) Mat2x3

Mul3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x3) Mul3x1 ¶

func (m1 Mat2x3) Mul3x1(m2 Vec3) Vec2

Mul3x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x3) Mul3x2 ¶

func (m1 Mat2x3) Mul3x2(m2 Mat3x2) Mat2

Mul3x2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x3) Mul3x4 ¶

func (m1 Mat2x3) Mul3x4(m2 Mat3x4) Mat2x4

Mul3x4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x3) Row ¶

func (m Mat2x3) Row(row int) Vec3

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat2x3) Rows ¶

func (m Mat2x3) Rows() (row0, row1 Vec3)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat2x3) Set ¶

func (m *Mat2x3) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat2x3) SetCol ¶

func (m *Mat2x3) SetCol(col int, v Vec2)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat2x3) SetRow ¶

func (m *Mat2x3) SetRow(row int, v Vec3)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat2x3) String ¶

func (m Mat2x3) String() string

Pretty prints the matrix

func (Mat2x3) Sub ¶

func (m1 Mat2x3) Sub(m2 Mat2x3) Mat2x3

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat2x3) Transpose ¶

func (m1 Mat2x3) Transpose() Mat3x2

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat2x4) Abs ¶

func (m Mat2x4) Abs() Mat2x4

Abs returns the element-wise absolute value of this matrix

func (Mat2x4) Add ¶

func (m1 Mat2x4) Add(m2 Mat2x4) Mat2x4

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat2x4) ApproxEqual ¶

func (m1 Mat2x4) ApproxEqual(m2 Mat2x4) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat2x4) ApproxEqualThreshold ¶

func (m1 Mat2x4) ApproxEqualThreshold(m2 Mat2x4, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat2x4) ApproxFuncEqual ¶

func (m1 Mat2x4) ApproxFuncEqual(m2 Mat2x4, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat2x4) At ¶

func (m Mat2x4) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat2x4) Col ¶

func (m Mat2x4) Col(col int) Vec2

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat2x4) Cols ¶

func (m Mat2x4) Cols() (col0, col1, col2, col3 Vec2)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat2x4) Index ¶

func (m Mat2x4) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat2x4) Mul ¶

func (m1 Mat2x4) Mul(c float64) Mat2x4

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat2x4) Mul4 ¶

func (m1 Mat2x4) Mul4(m2 Mat4) Mat2x4

Mul4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x4) Mul4x1 ¶

func (m1 Mat2x4) Mul4x1(m2 Vec4) Vec2

Mul4x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x4) Mul4x2 ¶

func (m1 Mat2x4) Mul4x2(m2 Mat4x2) Mat2

Mul4x2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x4) Mul4x3 ¶

func (m1 Mat2x4) Mul4x3(m2 Mat4x3) Mat2x3

Mul4x3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat2x4) Row ¶

func (m Mat2x4) Row(row int) Vec4

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat2x4) Rows ¶

func (m Mat2x4) Rows() (row0, row1 Vec4)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat2x4) Set ¶

func (m *Mat2x4) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat2x4) SetCol ¶

func (m *Mat2x4) SetCol(col int, v Vec2)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat2x4) SetRow ¶

func (m *Mat2x4) SetRow(row int, v Vec4)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat2x4) String ¶

func (m Mat2x4) String() string

Pretty prints the matrix

func (Mat2x4) Sub ¶

func (m1 Mat2x4) Sub(m2 Mat2x4) Mat2x4

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat2x4) Transpose ¶

func (m1 Mat2x4) Transpose() Mat4x2

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat3) Abs ¶

func (m Mat3) Abs() Mat3

Abs returns the element-wise absolute value of this matrix

func (Mat3) Add ¶

func (m1 Mat3) Add(m2 Mat3) Mat3

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat3) ApproxEqual ¶

func (m1 Mat3) ApproxEqual(m2 Mat3) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat3) ApproxEqualThreshold ¶

func (m1 Mat3) ApproxEqualThreshold(m2 Mat3, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat3) ApproxFuncEqual ¶

func (m1 Mat3) ApproxFuncEqual(m2 Mat3, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat3) At ¶

func (m Mat3) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat3) Col ¶

func (m Mat3) Col(col int) Vec3

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat3) Cols ¶

func (m Mat3) Cols() (col0, col1, col2 Vec3)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat3) Det ¶

func (m Mat3) Det() float64

Det returns the determinant of a matrix. It is a measure of a square matrix's singularity and invertability, among other things. In this library, the determinant is hard coded based on pre-computed cofactor expansion, and uses no loops. Of course, the addition and multiplication must still be done.

func (Mat3) Diag ¶

func (m Mat3) Diag() Vec3

Diag is a basic operation on a square matrix that simply returns main diagonal (meaning all elements such that row==col).

func (Mat3) Index ¶

func (m Mat3) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat3) Inv ¶

func (m Mat3) Inv() Mat3

Inv computes the inverse of a square matrix. An inverse is a square matrix such that when multiplied by the original, yields the identity.

M_inv * M = M * M_inv = I

In this library, the math is precomputed, and uses no loops, though the multiplications, additions, determinant calculation, and scaling are still done. This can still be (relatively) expensive for a 4x4.

This function checks the determinant to see if the matrix is invertible. If the determinant is 0.0, this function returns the zero matrix. However, due to floating point errors, it is entirely plausible to get a false positive or negative. In the future, an alternate function may be written which takes in a pre-computed determinant.

func (Mat3) Mat2 ¶

func (m Mat3) Mat2() Mat2

func (Mat3) Mat4 ¶

func (m Mat3) Mat4() Mat4

func (Mat3) Mul ¶

func (m1 Mat3) Mul(c float64) Mat3

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat3) Mul3 ¶

func (m1 Mat3) Mul3(m2 Mat3) Mat3

Mul3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3) Mul3x1 ¶

func (m1 Mat3) Mul3x1(m2 Vec3) Vec3

Mul3x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3) Mul3x2 ¶

func (m1 Mat3) Mul3x2(m2 Mat3x2) Mat3x2

Mul3x2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3) Mul3x4 ¶

func (m1 Mat3) Mul3x4(m2 Mat3x4) Mat3x4

Mul3x4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3) Row ¶

func (m Mat3) Row(row int) Vec3

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat3) Rows ¶

func (m Mat3) Rows() (row0, row1, row2 Vec3)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat3) Set ¶

func (m *Mat3) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat3) SetCol ¶

func (m *Mat3) SetCol(col int, v Vec3)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat3) SetRow ¶

func (m *Mat3) SetRow(row int, v Vec3)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat3) String ¶

func (m Mat3) String() string

Pretty prints the matrix

func (Mat3) Sub ¶

func (m1 Mat3) Sub(m2 Mat3) Mat3

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat3) Trace ¶

func (m Mat3) Trace() float64

Trace is a basic operation on a square matrix that simply sums up all elements on the main diagonal (meaning all elements such that row==col).

func (Mat3) Transpose ¶

func (m1 Mat3) Transpose() Mat3

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat3x2) Abs ¶

func (m Mat3x2) Abs() Mat3x2

Abs returns the element-wise absolute value of this matrix

func (Mat3x2) Add ¶

func (m1 Mat3x2) Add(m2 Mat3x2) Mat3x2

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat3x2) ApproxEqual ¶

func (m1 Mat3x2) ApproxEqual(m2 Mat3x2) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat3x2) ApproxEqualThreshold ¶

func (m1 Mat3x2) ApproxEqualThreshold(m2 Mat3x2, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat3x2) ApproxFuncEqual ¶

func (m1 Mat3x2) ApproxFuncEqual(m2 Mat3x2, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat3x2) At ¶

func (m Mat3x2) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat3x2) Col ¶

func (m Mat3x2) Col(col int) Vec3

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat3x2) Cols ¶

func (m Mat3x2) Cols() (col0, col1 Vec3)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat3x2) Index ¶

func (m Mat3x2) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat3x2) Mul ¶

func (m1 Mat3x2) Mul(c float64) Mat3x2

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat3x2) Mul2 ¶

func (m1 Mat3x2) Mul2(m2 Mat2) Mat3x2

Mul2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x2) Mul2x1 ¶

func (m1 Mat3x2) Mul2x1(m2 Vec2) Vec3

Mul2x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x2) Mul2x3 ¶

func (m1 Mat3x2) Mul2x3(m2 Mat2x3) Mat3

Mul2x3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x2) Mul2x4 ¶

func (m1 Mat3x2) Mul2x4(m2 Mat2x4) Mat3x4

Mul2x4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x2) Row ¶

func (m Mat3x2) Row(row int) Vec2

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat3x2) Rows ¶

func (m Mat3x2) Rows() (row0, row1, row2 Vec2)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat3x2) Set ¶

func (m *Mat3x2) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat3x2) SetCol ¶

func (m *Mat3x2) SetCol(col int, v Vec3)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat3x2) SetRow ¶

func (m *Mat3x2) SetRow(row int, v Vec2)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat3x2) String ¶

func (m Mat3x2) String() string

Pretty prints the matrix

func (Mat3x2) Sub ¶

func (m1 Mat3x2) Sub(m2 Mat3x2) Mat3x2

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat3x2) Transpose ¶

func (m1 Mat3x2) Transpose() Mat2x3

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat3x4) Abs ¶

func (m Mat3x4) Abs() Mat3x4

Abs returns the element-wise absolute value of this matrix

func (Mat3x4) Add ¶

func (m1 Mat3x4) Add(m2 Mat3x4) Mat3x4

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat3x4) ApproxEqual ¶

func (m1 Mat3x4) ApproxEqual(m2 Mat3x4) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat3x4) ApproxEqualThreshold ¶

func (m1 Mat3x4) ApproxEqualThreshold(m2 Mat3x4, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat3x4) ApproxFuncEqual ¶

func (m1 Mat3x4) ApproxFuncEqual(m2 Mat3x4, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat3x4) At ¶

func (m Mat3x4) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat3x4) Col ¶

func (m Mat3x4) Col(col int) Vec3

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat3x4) Cols ¶

func (m Mat3x4) Cols() (col0, col1, col2, col3 Vec3)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat3x4) Index ¶

func (m Mat3x4) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat3x4) Mul ¶

func (m1 Mat3x4) Mul(c float64) Mat3x4

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat3x4) Mul4 ¶

func (m1 Mat3x4) Mul4(m2 Mat4) Mat3x4

Mul4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x4) Mul4x1 ¶

func (m1 Mat3x4) Mul4x1(m2 Vec4) Vec3

Mul4x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x4) Mul4x2 ¶

func (m1 Mat3x4) Mul4x2(m2 Mat4x2) Mat3x2

Mul4x2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x4) Mul4x3 ¶

func (m1 Mat3x4) Mul4x3(m2 Mat4x3) Mat3

Mul4x3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat3x4) Row ¶

func (m Mat3x4) Row(row int) Vec4

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat3x4) Rows ¶

func (m Mat3x4) Rows() (row0, row1, row2 Vec4)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat3x4) Set ¶

func (m *Mat3x4) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat3x4) SetCol ¶

func (m *Mat3x4) SetCol(col int, v Vec3)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat3x4) SetRow ¶

func (m *Mat3x4) SetRow(row int, v Vec4)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat3x4) String ¶

func (m Mat3x4) String() string

Pretty prints the matrix

func (Mat3x4) Sub ¶

func (m1 Mat3x4) Sub(m2 Mat3x4) Mat3x4

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat3x4) Transpose ¶

func (m1 Mat3x4) Transpose() Mat4x3

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat4) Abs ¶

func (m Mat4) Abs() Mat4

Abs returns the element-wise absolute value of this matrix

func (Mat4) Add ¶

func (m1 Mat4) Add(m2 Mat4) Mat4

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat4) ApproxEqual ¶

func (m1 Mat4) ApproxEqual(m2 Mat4) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat4) ApproxEqualThreshold ¶

func (m1 Mat4) ApproxEqualThreshold(m2 Mat4, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat4) ApproxFuncEqual ¶

func (m1 Mat4) ApproxFuncEqual(m2 Mat4, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat4) At ¶

func (m Mat4) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat4) Col ¶

func (m Mat4) Col(col int) Vec4

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat4) Cols ¶

func (m Mat4) Cols() (col0, col1, col2, col3 Vec4)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat4) Det ¶

func (m Mat4) Det() float64

Det returns the determinant of a matrix. It is a measure of a square matrix's singularity and invertability, among other things. In this library, the determinant is hard coded based on pre-computed cofactor expansion, and uses no loops. Of course, the addition and multiplication must still be done.

func (Mat4) Diag ¶

func (m Mat4) Diag() Vec4

Diag is a basic operation on a square matrix that simply returns main diagonal (meaning all elements such that row==col).

func (Mat4) Index ¶

func (m Mat4) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat4) Inv ¶

func (m Mat4) Inv() Mat4

Inv computes the inverse of a square matrix. An inverse is a square matrix such that when multiplied by the original, yields the identity.

M_inv * M = M * M_inv = I

In this library, the math is precomputed, and uses no loops, though the multiplications, additions, determinant calculation, and scaling are still done. This can still be (relatively) expensive for a 4x4.

This function checks the determinant to see if the matrix is invertible. If the determinant is 0.0, this function returns the zero matrix. However, due to floating point errors, it is entirely plausible to get a false positive or negative. In the future, an alternate function may be written which takes in a pre-computed determinant.

func (Mat4) Mat2 ¶

func (m Mat4) Mat2() Mat2

func (Mat4) Mat3 ¶

func (m Mat4) Mat3() Mat3

func (Mat4) Mul ¶

func (m1 Mat4) Mul(c float64) Mat4

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat4) Mul4 ¶

func (m1 Mat4) Mul4(m2 Mat4) Mat4

Mul4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4) Mul4x1 ¶

func (m1 Mat4) Mul4x1(m2 Vec4) Vec4

Mul4x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4) Mul4x2 ¶

func (m1 Mat4) Mul4x2(m2 Mat4x2) Mat4x2

Mul4x2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4) Mul4x3 ¶

func (m1 Mat4) Mul4x3(m2 Mat4x3) Mat4x3

Mul4x3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4) Row ¶

func (m Mat4) Row(row int) Vec4

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat4) Rows ¶

func (m Mat4) Rows() (row0, row1, row2, row3 Vec4)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat4) Set ¶

func (m *Mat4) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat4) SetCol ¶

func (m *Mat4) SetCol(col int, v Vec4)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat4) SetRow ¶

func (m *Mat4) SetRow(row int, v Vec4)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat4) String ¶

func (m Mat4) String() string

Pretty prints the matrix

func (Mat4) Sub ¶

func (m1 Mat4) Sub(m2 Mat4) Mat4

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat4) Trace ¶

func (m Mat4) Trace() float64

Trace is a basic operation on a square matrix that simply sums up all elements on the main diagonal (meaning all elements such that row==col).

func (Mat4) Transpose ¶

func (m1 Mat4) Transpose() Mat4

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat4x2) Abs ¶

func (m Mat4x2) Abs() Mat4x2

Abs returns the element-wise absolute value of this matrix

func (Mat4x2) Add ¶

func (m1 Mat4x2) Add(m2 Mat4x2) Mat4x2

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat4x2) ApproxEqual ¶

func (m1 Mat4x2) ApproxEqual(m2 Mat4x2) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat4x2) ApproxEqualThreshold ¶

func (m1 Mat4x2) ApproxEqualThreshold(m2 Mat4x2, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat4x2) ApproxFuncEqual ¶

func (m1 Mat4x2) ApproxFuncEqual(m2 Mat4x2, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat4x2) At ¶

func (m Mat4x2) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat4x2) Col ¶

func (m Mat4x2) Col(col int) Vec4

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat4x2) Cols ¶

func (m Mat4x2) Cols() (col0, col1 Vec4)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat4x2) Index ¶

func (m Mat4x2) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat4x2) Mul ¶

func (m1 Mat4x2) Mul(c float64) Mat4x2

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat4x2) Mul2 ¶

func (m1 Mat4x2) Mul2(m2 Mat2) Mat4x2

Mul2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x2) Mul2x1 ¶

func (m1 Mat4x2) Mul2x1(m2 Vec2) Vec4

Mul2x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x2) Mul2x3 ¶

func (m1 Mat4x2) Mul2x3(m2 Mat2x3) Mat4x3

Mul2x3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x2) Mul2x4 ¶

func (m1 Mat4x2) Mul2x4(m2 Mat2x4) Mat4

Mul2x4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x2) Row ¶

func (m Mat4x2) Row(row int) Vec2

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat4x2) Rows ¶

func (m Mat4x2) Rows() (row0, row1, row2, row3 Vec2)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat4x2) Set ¶

func (m *Mat4x2) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat4x2) SetCol ¶

func (m *Mat4x2) SetCol(col int, v Vec4)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat4x2) SetRow ¶

func (m *Mat4x2) SetRow(row int, v Vec2)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat4x2) String ¶

func (m Mat4x2) String() string

Pretty prints the matrix

func (Mat4x2) Sub ¶

func (m1 Mat4x2) Sub(m2 Mat4x2) Mat4x2

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat4x2) Transpose ¶

func (m1 Mat4x2) Transpose() Mat2x4

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (Mat4x3) Abs ¶

func (m Mat4x3) Abs() Mat4x3

Abs returns the element-wise absolute value of this matrix

func (Mat4x3) Add ¶

func (m1 Mat4x3) Add(m2 Mat4x3) Mat4x3

Add performs an element-wise addition of two matrices, this is equivalent to iterating over every element of m1 and adding the corresponding value of m2.

func (Mat4x3) ApproxEqual ¶

func (m1 Mat4x3) ApproxEqual(m2 Mat4x3) bool

ApproxEqual performs an element-wise approximate equality test between two matrices, as if FloatEqual had been used.

func (Mat4x3) ApproxEqualThreshold ¶

func (m1 Mat4x3) ApproxEqualThreshold(m2 Mat4x3, threshold float64) bool

ApproxEqualThreshold performs an element-wise approximate equality test between two matrices with a given epsilon threshold, as if FloatEqualThreshold had been used.

func (Mat4x3) ApproxFuncEqual ¶

func (m1 Mat4x3) ApproxFuncEqual(m2 Mat4x3, eq func(float64, float64) bool) bool

ApproxFuncEqual performs an element-wise approximate equality test between two matrices with a given equality functions, intended to be used with FloatEqualFunc; although and comparison function may be used in practice.

func (Mat4x3) At ¶

func (m Mat4x3) At(row, col int) float64

At returns the matrix element at the given row and column. This is equivalent to mat[col * numRow + row] where numRow is constant (E.G. for a Mat3x2 it's equal to 3)

This method is garbage-in garbage-out. For instance, on a Mat4 asking for At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds.

func (Mat4x3) Col ¶

func (m Mat4x3) Col(col int) Vec4

Col returns a vector representing the corresponding column (starting at col 0). This package makes no distinction between row and column vectors, so it will be a normal VecN for a MxN matrix.

func (Mat4x3) Cols ¶

func (m Mat4x3) Cols() (col0, col1, col2 Vec4)

Cols decomposes a matrix into its corresponding column vectors. This is equivalent to calling mat.Col for each column.

func (Mat4x3) Index ¶

func (m Mat4x3) Index(row, col int) int

Index returns the index of the given row and column, to be used with direct access. E.G. Index(0,0) = 0.

This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause a panic if you try to access the array with it if it's truly out of bounds.

func (Mat4x3) Mul ¶

func (m1 Mat4x3) Mul(c float64) Mat4x3

Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating over every element of the matrix and multiply it by c.

func (Mat4x3) Mul3 ¶

func (m1 Mat4x3) Mul3(m2 Mat3) Mat4x3

Mul3 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x3) Mul3x1 ¶

func (m1 Mat4x3) Mul3x1(m2 Vec3) Vec4

Mul3x1 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x3) Mul3x2 ¶

func (m1 Mat4x3) Mul3x2(m2 Mat3x2) Mat4x2

Mul3x2 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x3) Mul3x4 ¶

func (m1 Mat4x3) Mul3x4(m2 Mat3x4) Mat4

Mul3x4 performs a "matrix product" between this matrix and another of the given dimension. For any two matrices of dimensionality MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using Mul4x2 will result in a Mat4x2.

func (Mat4x3) Row ¶

func (m Mat4x3) Row(row int) Vec3

Row returns a vector representing the corresponding row (starting at row 0). This package makes no distinction between row and column vectors, so it will be a normal VecM for a MxN matrix.

func (Mat4x3) Rows ¶

func (m Mat4x3) Rows() (row0, row1, row2, row3 Vec3)

Rows decomposes a matrix into its corresponding row vectors. This is equivalent to calling mat.Row for each row.

func (*Mat4x3) Set ¶

func (m *Mat4x3) Set(row, col int, value float64)

Set sets the corresponding matrix element at the given row and column. This has a pointer receiver because it mutates the matrix.

This method is garbage-in garbage-out. For instance, on a Mat4 asking for Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds.

func (*Mat4x3) SetCol ¶

func (m *Mat4x3) SetCol(col int, v Vec4)

SetCol sets a Column within the Matrix, so it mutates the calling matrix.

func (*Mat4x3) SetRow ¶

func (m *Mat4x3) SetRow(row int, v Vec3)

SetRow sets a Row within the Matrix, so it mutates the calling matrix.

func (Mat4x3) String ¶

func (m Mat4x3) String() string

Pretty prints the matrix

func (Mat4x3) Sub ¶

func (m1 Mat4x3) Sub(m2 Mat4x3) Mat4x3

Sub performs an element-wise subtraction of two matrices, this is equivalent to iterating over every element of m1 and subtracting the corresponding value of m2.

func (Mat4x3) Transpose ¶

func (m1 Mat4x3) Transpose() Mat3x4

Transpose produces the transpose of this matrix. For any MxN matrix the transpose is an NxM matrix with the rows swapped with the columns. For instance the transpose of the Mat3x2 is a Mat2x3 like so:

[[a b]]    [[a c e]]
[[c d]] =  [[b d f]]
[[e f]]

func (*MatMxN) Add ¶

func (mat *MatMxN) Add(dst *MatMxN, addend *MatMxN) *MatMxN

Add is the arithemtic + operator defined on a MatMxN.

func (*MatMxN) ApproxEqual ¶

func (mat *MatMxN) ApproxEqual(m2 *MatMxN) bool

ApproxEqual returns whether the two vectors are approximately equal (See FloatEqual).

func (*MatMxN) ApproxEqualFunc ¶

func (mat *MatMxN) ApproxEqualFunc(m2 *MatMxN, comp func(float64, float64) bool) bool

ApproxEqualFunc returns whether the two vectors are approximately equal, given a function which compares two scalar elements.

func (*MatMxN) ApproxEqualThreshold ¶

func (mat *MatMxN) ApproxEqualThreshold(m2 *MatMxN, epsilon float64) bool

ApproxEqualThreshold returns whether the two vectors are approximately equal to within the given threshold given by "epsilon" (See ApproxEqualThreshold).

func (*MatMxN) At ¶

func (mat *MatMxN) At(row, col int) float64

At returns the element at the given row and column. This is garbage in/garbage out and does no bounds checking. If the computation happens to lead to an invalid element, it will be returned; or it may panic.

func (*MatMxN) InferMatrix ¶

func (mat *MatMxN) InferMatrix(m interface{}) (*MatMxN, error)

InferMatrix infers an MxN matrix from a constant matrix from this package. For instance, a Mat2x3 inferred with this function will work just like NewMatrixFromData(m[:],2,3) where m is the Mat2x3. This uses a type switch.

I personally recommend using NewMatrixFromData, because it avoids a potentially costly type switch. However, this is also more robust and less error prone if you change the size of your matrix somewhere.

If the value passed in is not recognized, it returns an InferMatrixError.

func (*MatMxN) Mul ¶

func (mat *MatMxN) Mul(dst *MatMxN, c float64) *MatMxN

Mul performs a scalar multiplication between mat and some constant c, storing the result in dst. Mat and dst can be equal. If dst is not the correct size, a Reshape will occur.

func (*MatMxN) MulMxN ¶

func (mat *MatMxN) MulMxN(dst *MatMxN, mul *MatMxN) *MatMxN

MulMxN performs matrix multiplication on MxN matrix mat and NxO matrix mul, storing the result in dst. This returns dst, or nil if the operation is not able to be performed.

If mat == dst, or mul == dst a temporary matrix will be used.

This uses the naive algorithm (though on smaller matrices, this can actually be faster; about len(mat)+len(mul) < ~100)

func (*MatMxN) MulNx1 ¶

func (mat *MatMxN) MulNx1(dst, v *VecN) *VecN

MulNx1 multiplies the matrix by a vector of size n. If mat or v is nil, this returns nil. If the number of columns in mat does not match the Size of v, this also returns nil.

Dst will be resized if it's not big enough. If dst == v; a temporary vector will be allocated and returned via the realloc callback when complete.

func (*MatMxN) NumCols ¶

func (mat *MatMxN) NumCols() int

NumCols returns the number of columns in this matrix

func (*MatMxN) NumRowCols ¶

func (mat *MatMxN) NumRowCols() (rows, cols int)

NumRowCols returns the number of rows and columns in this matrix as a single operation

func (*MatMxN) NumRows ¶

func (mat *MatMxN) NumRows() int

NumRows returns the number of rows in this matrix

func (*MatMxN) Raw ¶

func (mat *MatMxN) Raw() []float64

Raw returns the raw slice backing this matrix

func (*MatMxN) Reshape ¶

func (mat *MatMxN) Reshape(m, n int) *MatMxN

Reshape reshapes the matrix to the desired dimensions. If the overall size of the new matrix (m*n) is bigger than the current size, the underlying slice will be grown, sending the current slice to the memory pool and grabbing a bigger one if necessary

If the caller is a nil pointer, the return value will be a new matrix, as if NewMatrix(m,n) had been called. Otherwise it's simply the caller.

func (*MatMxN) Set ¶

func (mat *MatMxN) Set(row, col int, val float64)

Set sets the element at the given row and column. This is garbage in/garbage out and does no bounds checking. If the computation happens to lead to an invalid element, it will be set; or it may panic.

func (*MatMxN) Sub ¶

func (mat *MatMxN) Sub(dst *MatMxN, subtrahend *MatMxN) *MatMxN

Sub is the arithemtic - operator defined on a MatMxN.

func (*MatMxN) Trace ¶

func (mat *MatMxN) Trace() float64

Trace returns the trace of a square matrix (sum of all diagonal elements). If the matrix is nil, or not square, the result will be NaN.

func (*MatMxN) Transpose ¶

func (mat *MatMxN) Transpose(dst *MatMxN) (t *MatMxN)

Transpose takes the transpose of mat and puts it in dst.

If dst is not of the correct dimensions, it will be Reshaped, if dst and mat are the same, a temporary matrix of the correct size will be allocated; these resources will be released via the memory pool.

This should be improved in the future.

func (*MatMxN) Zero ¶

func (mat *MatMxN) Zero(m, n int)

Zero reshapes the matrix to m by n and zeroes out all elements.

func (NilMatrixError) Error ¶

func (me NilMatrixError) Error() string

func (Quat) Add ¶

func (q1 Quat) Add(q2 Quat) Quat

Add adds two quaternions. It's no more complicated than adding their W and V components.

func (Quat) ApproxEqual ¶

func (q1 Quat) ApproxEqual(q2 Quat) bool

ApproxEqual returns whether the quaternions are approximately equal, as if FloatEqual was called on each matching element

func (Quat) ApproxEqualFunc ¶

func (q1 Quat) ApproxEqualFunc(q2 Quat, f func(float64, float64) bool) bool

ApproxEqualFunc returns whether the quaternions are approximately equal using the given comparison function, as if the function had been called on each individual element

func (Quat) ApproxEqualThreshold ¶

func (q1 Quat) ApproxEqualThreshold(q2 Quat, epsilon float64) bool

ApproxEqualThreshold returns whether the quaternions are approximately equal with a given tolerence, as if FloatEqualThreshold was called on each matching element with the given epsilon

func (Quat) Conjugate ¶

func (q1 Quat) Conjugate() Quat

Conjugate returns the conjugate of a quaternion. Equivalent to Quat{q1.W, q1.V.Mul(-1)}.

func (Quat) Dot ¶

func (q1 Quat) Dot(q2 Quat) float64

Dot product between two quaternions, equivalent to if this was a Vec4.

func (Quat) Inverse ¶

func (q1 Quat) Inverse() Quat

Inverse of a quaternion. The inverse is equivalent to the conjugate divided by the square of the length.

This method computes the square norm by directly adding the sum of the squares of all terms instead of actually squaring q1.Len(), both for performance and precision.

func (Quat) Len ¶

func (q1 Quat) Len() float64

Len gives the Length of the quaternion, also known as its Norm. This is the same thing as the Len of a Vec4.

func (Quat) Mat4 ¶

func (q1 Quat) Mat4() Mat4

Mat4 returns the homogeneous 3D rotation matrix corresponding to the quaternion.

func (Quat) Mul ¶

func (q1 Quat) Mul(q2 Quat) Quat

Mul multiplies two quaternions. This can be seen as a rotation. Note that Multiplication is NOT commutative, meaning q1.Mul(q2) does not necessarily equal q2.Mul(q1).

func (Quat) Norm ¶

func (q1 Quat) Norm() float64

Norm is an alias for Len() since both are very common terms.

func (Quat) Normalize ¶

func (q1 Quat) Normalize() Quat

Normalize the quaternion, returning its versor (unit quaternion).

This is the same as normalizing it as a Vec4.

func (Quat) OrientationEqual ¶

func (q1 Quat) OrientationEqual(q2 Quat) bool

OrientationEqual returns whether the quaternions represents the same orientation

Different values can represent the same orientation (q == -q) because quaternions avoid singularities and discontinuities involved with rotation in 3 dimensions by adding extra dimensions

func (Quat) OrientationEqualThreshold ¶

func (q1 Quat) OrientationEqualThreshold(q2 Quat, epsilon float64) bool

OrientationEqualThreshold returns whether the quaternions represents the same orientation with a given tolerence

func (Quat) Rotate ¶

func (q1 Quat) Rotate(v Vec3) Vec3

Rotate a vector by the rotation this quaternion represents. This will result in a 3D vector. Strictly speaking, this is equivalent to q1.v.q* where the "."" is quaternion multiplication and v is interpreted as a quaternion with W 0 and V v. In code: q1.Mul(Quat{0,v}).Mul(q1.Conjugate()), and then retrieving the imaginary (vector) part.

In practice, we hand-compute this in the general case and simplify to save a few operations.

func (Quat) Scale ¶

func (q1 Quat) Scale(c float64) Quat

Scale every element of the quaternion by some constant factor.

func (Quat) Sub ¶

func (q1 Quat) Sub(q2 Quat) Quat

Sub subtracts two quaternions. It's no more complicated than subtracting their W and V components.

func (Quat) X ¶

func (q Quat) X() float64

X is a convenient alias for q.V[0]

func (Quat) Y ¶

func (q Quat) Y() float64

Y is a convenient alias for q.V[1]

func (Quat) Z ¶

func (q Quat) Z() float64

Z is a convenient alias for q.V[2]

func (RectangularMatrixError) Error ¶

func (mse RectangularMatrixError) Error() string

func (Vec2) Add ¶

func (v1 Vec2) Add(v2 Vec2) Vec2

Add performs element-wise addition between two vectors. It is equivalent to iterating over every element of v1 and adding the corresponding element of v2 to it.

func (Vec2) ApproxEqual ¶

func (v1 Vec2) ApproxEqual(v2 Vec2) bool

ApproxEqual takes in a vector and does an element-wise approximate float comparison as if FloatEqual had been used

func (Vec2) ApproxEqualThreshold ¶

func (v1 Vec2) ApproxEqualThreshold(v2 Vec2, threshold float64) bool

ApproxEqualThreshold takes in a threshold for comparing two floats, and uses it to do an element-wise comparison of the vector to another.

func (Vec2) ApproxFuncEqual ¶

func (v1 Vec2) ApproxFuncEqual(v2 Vec2, eq func(float64, float64) bool) bool

ApproxFuncEqual takes in a func that compares two floats, and uses it to do an element-wise comparison of the vector to another. This is intended to be used with FloatEqualFunc

func (Vec2) Dot ¶

func (v1 Vec2) Dot(v2 Vec2) float64

Dot returns the dot product of this vector with another. There are multiple ways to describe this value. One is the multiplication of their lengths and cos(theta) where theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta).

The other (and what is actually done) is the sum of the element-wise multiplication of all elements. So for instance, two Vec3s would yield v1.x * v2.x + v1.y * v2.y + v1.z * v2.z.

This means that the dot product of a vector and itself is the square of its Len (within the bounds of floating points error).

The dot product is roughly a measure of how closely two vectors are to pointing in the same direction. If both vectors are normalized, the value will be -1 for opposite pointing, one for same pointing, and 0 for perpendicular vectors.

func (Vec2) Elem ¶

func (v Vec2) Elem() (x, y float64)

Elem extracts the elements of the vector for direct value assignment.

func (Vec2) Len ¶

func (v1 Vec2) Len() float64

Len returns the vector's length. Note that this is NOT the dimension of the vector (len(v)), but the mathematical length. This is equivalent to the square root of the sum of the squares of all elements. E.G. for a Vec2 it's math.Hypot(v[0], v[1]).

func (Vec2) LenSqr ¶

func (v1 Vec2) LenSqr() float64

LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements.

func (Vec2) Mul ¶

func (v1 Vec2) Mul(c float64) Vec2

Mul performs a scalar multiplication between the vector and some constant value c. This is equivalent to iterating over every vector element and multiplying by c.

func (Vec2) Normalize ¶

func (v1 Vec2) Normalize() Vec2

Normalize normalizes the vector. Normalization is (1/|v|)*v, making this equivalent to v.Scale(1/v.Len()). If the len is 0.0, this function will return an infinite value for all elements due to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))).

Normalization makes a vector's Len become 1.0 (within the margin of floating point error), while maintaining its directionality.

(Can be seen here: http://play.golang.org/p/Aaj7SnbqIp )

func (Vec2) OuterProd2 ¶

func (v1 Vec2) OuterProd2(v2 Vec2) Mat2

OuterProd2 does the vector outer product of two vectors. The outer product produces an 2x2 matrix. E.G. a Vec2 * Vec2 = Mat2.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec2) OuterProd3 ¶

func (v1 Vec2) OuterProd3(v2 Vec3) Mat2x3

OuterProd3 does the vector outer product of two vectors. The outer product produces an 2x3 matrix. E.G. a Vec2 * Vec3 = Mat2x3.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec2) OuterProd4 ¶

func (v1 Vec2) OuterProd4(v2 Vec4) Mat2x4

OuterProd4 does the vector outer product of two vectors. The outer product produces an 2x4 matrix. E.G. a Vec2 * Vec4 = Mat2x4.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec2) Sub ¶

func (v1 Vec2) Sub(v2 Vec2) Vec2

Sub performs element-wise subtraction between two vectors. It is equivalent to iterating over every element of v1 and subtracting the corresponding element of v2 from it.

func (Vec2) Vec3 ¶

func (v Vec2) Vec3(z float64) Vec3

Vec3 constructs a 3-dimensional vector by appending the given coordinates.

func (Vec2) Vec4 ¶

func (v Vec2) Vec4(z, w float64) Vec4

Vec4 constructs a 4-dimensional vector by appending the given coordinates.

func (Vec2) X ¶

func (v Vec2) X() float64

X is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec2) Y ¶

func (v Vec2) Y() float64

Y is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec3) Add ¶

func (v1 Vec3) Add(v2 Vec3) Vec3

Add performs element-wise addition between two vectors. It is equivalent to iterating over every element of v1 and adding the corresponding element of v2 to it.

func (Vec3) ApproxEqual ¶

func (v1 Vec3) ApproxEqual(v2 Vec3) bool

ApproxEqual takes in a vector and does an element-wise approximate float comparison as if FloatEqual had been used

func (Vec3) ApproxEqualThreshold ¶

func (v1 Vec3) ApproxEqualThreshold(v2 Vec3, threshold float64) bool

ApproxEqualThreshold takes in a threshold for comparing two floats, and uses it to do an element-wise comparison of the vector to another.

func (Vec3) ApproxFuncEqual ¶

func (v1 Vec3) ApproxFuncEqual(v2 Vec3, eq func(float64, float64) bool) bool

ApproxFuncEqual takes in a func that compares two floats, and uses it to do an element-wise comparison of the vector to another. This is intended to be used with FloatEqualFunc

func (Vec3) Cross ¶

func (v1 Vec3) Cross(v2 Vec3) Vec3

Cross is the vector cross product. This operation is only defined on 3D vectors. It is equivalent to Vec3{v1[1]*v2[2]-v1[2]*v2[1], v1[2]*v2[0]-v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0]}. Another interpretation is that it's the vector whose magnitude is |v1||v2|sin(theta) where theta is the angle between v1 and v2.

The cross product is most often used for finding surface normals. The cross product of vectors will generate a vector that is perpendicular to the plane they form.

Technically, a generalized cross product exists as an "(N-1)ary" operation (that is, the 4D cross product requires 3 4D vectors). But the binary 3D (and 7D) cross product is the most important. It can be considered the area of a parallelogram with sides v1 and v2.

Like the dot product, the cross product is roughly a measure of directionality. Two normalized perpendicular vectors will return a vector with a magnitude of 1.0 or -1.0 and two parallel vectors will return a vector with magnitude 0.0. The cross product is "anticommutative" meaning v1.Cross(v2) = -v2.Cross(v1), this property can be useful to know when finding normals, as taking the wrong cross product can lead to the opposite normal of the one you want.

func (Vec3) Dot ¶

func (v1 Vec3) Dot(v2 Vec3) float64

Dot returns the dot product of this vector with another. There are multiple ways to describe this value. One is the multiplication of their lengths and cos(theta) where theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta).

The other (and what is actually done) is the sum of the element-wise multiplication of all elements. So for instance, two Vec3s would yield v1.x * v2.x + v1.y * v2.y + v1.z * v2.z.

This means that the dot product of a vector and itself is the square of its Len (within the bounds of floating points error).

The dot product is roughly a measure of how closely two vectors are to pointing in the same direction. If both vectors are normalized, the value will be -1 for opposite pointing, one for same pointing, and 0 for perpendicular vectors.

func (Vec3) Elem ¶

func (v Vec3) Elem() (x, y, z float64)

Elem extracts the elements of the vector for direct value assignment.

func (Vec3) Len ¶

func (v1 Vec3) Len() float64

Len returns the vector's length. Note that this is NOT the dimension of the vector (len(v)), but the mathematical length. This is equivalent to the square root of the sum of the squares of all elements. E.G. for a Vec2 it's math.Hypot(v[0], v[1]).

func (Vec3) LenSqr ¶

func (v1 Vec3) LenSqr() float64

LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements.

func (Vec3) Mul ¶

func (v1 Vec3) Mul(c float64) Vec3

Mul performs a scalar multiplication between the vector and some constant value c. This is equivalent to iterating over every vector element and multiplying by c.

func (Vec3) Normalize ¶

func (v1 Vec3) Normalize() Vec3

Normalize normalizes the vector. Normalization is (1/|v|)*v, making this equivalent to v.Scale(1/v.Len()). If the len is 0.0, this function will return an infinite value for all elements due to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))).

Normalization makes a vector's Len become 1.0 (within the margin of floating point error), while maintaining its directionality.

(Can be seen here: http://play.golang.org/p/Aaj7SnbqIp )

func (Vec3) OuterProd2 ¶

func (v1 Vec3) OuterProd2(v2 Vec2) Mat3x2

OuterProd2 does the vector outer product of two vectors. The outer product produces an 3x2 matrix. E.G. a Vec3 * Vec2 = Mat3x2.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec3) OuterProd3 ¶

func (v1 Vec3) OuterProd3(v2 Vec3) Mat3

OuterProd3 does the vector outer product of two vectors. The outer product produces an 3x3 matrix. E.G. a Vec3 * Vec3 = Mat3.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec3) OuterProd4 ¶

func (v1 Vec3) OuterProd4(v2 Vec4) Mat3x4

OuterProd4 does the vector outer product of two vectors. The outer product produces an 3x4 matrix. E.G. a Vec3 * Vec4 = Mat3x4.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec3) Sub ¶

func (v1 Vec3) Sub(v2 Vec3) Vec3

Sub performs element-wise subtraction between two vectors. It is equivalent to iterating over every element of v1 and subtracting the corresponding element of v2 from it.

func (Vec3) Vec2 ¶

func (v Vec3) Vec2() Vec2

Vec2 constructs a 2-dimensional vector by discarding coordinates.

func (Vec3) Vec4 ¶

func (v Vec3) Vec4(w float64) Vec4

Vec4 constructs a 4-dimensional vector by appending the given coordinates.

func (Vec3) X ¶

func (v Vec3) X() float64

X is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec3) Y ¶

func (v Vec3) Y() float64

Y is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec3) Z ¶

func (v Vec3) Z() float64

Z is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec4) Add ¶

func (v1 Vec4) Add(v2 Vec4) Vec4

Add performs element-wise addition between two vectors. It is equivalent to iterating over every element of v1 and adding the corresponding element of v2 to it.

func (Vec4) ApproxEqual ¶

func (v1 Vec4) ApproxEqual(v2 Vec4) bool

ApproxEqual takes in a vector and does an element-wise approximate float comparison as if FloatEqual had been used

func (Vec4) ApproxEqualThreshold ¶

func (v1 Vec4) ApproxEqualThreshold(v2 Vec4, threshold float64) bool

ApproxEqualThreshold takes in a threshold for comparing two floats, and uses it to do an element-wise comparison of the vector to another.

func (Vec4) ApproxFuncEqual ¶

func (v1 Vec4) ApproxFuncEqual(v2 Vec4, eq func(float64, float64) bool) bool

ApproxFuncEqual takes in a func that compares two floats, and uses it to do an element-wise comparison of the vector to another. This is intended to be used with FloatEqualFunc

func (Vec4) Dot ¶

func (v1 Vec4) Dot(v2 Vec4) float64

Dot returns the dot product of this vector with another. There are multiple ways to describe this value. One is the multiplication of their lengths and cos(theta) where theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta).

The other (and what is actually done) is the sum of the element-wise multiplication of all elements. So for instance, two Vec3s would yield v1.x * v2.x + v1.y * v2.y + v1.z * v2.z.

This means that the dot product of a vector and itself is the square of its Len (within the bounds of floating points error).

The dot product is roughly a measure of how closely two vectors are to pointing in the same direction. If both vectors are normalized, the value will be -1 for opposite pointing, one for same pointing, and 0 for perpendicular vectors.

func (Vec4) Elem ¶

func (v Vec4) Elem() (x, y, z, w float64)

Elem extracts the elements of the vector for direct value assignment.

func (Vec4) Len ¶

func (v1 Vec4) Len() float64

Len returns the vector's length. Note that this is NOT the dimension of the vector (len(v)), but the mathematical length. This is equivalent to the square root of the sum of the squares of all elements. E.G. for a Vec2 it's math.Hypot(v[0], v[1]).

func (Vec4) LenSqr ¶

func (v1 Vec4) LenSqr() float64

LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements.

func (Vec4) Mul ¶

func (v1 Vec4) Mul(c float64) Vec4

Mul performs a scalar multiplication between the vector and some constant value c. This is equivalent to iterating over every vector element and multiplying by c.

func (Vec4) Normalize ¶

func (v1 Vec4) Normalize() Vec4

Normalize normalizes the vector. Normalization is (1/|v|)*v, making this equivalent to v.Scale(1/v.Len()). If the len is 0.0, this function will return an infinite value for all elements due to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))).

Normalization makes a vector's Len become 1.0 (within the margin of floating point error), while maintaining its directionality.

(Can be seen here: http://play.golang.org/p/Aaj7SnbqIp )

func (Vec4) OuterProd2 ¶

func (v1 Vec4) OuterProd2(v2 Vec2) Mat4x2

OuterProd2 does the vector outer product of two vectors. The outer product produces an 4x2 matrix. E.G. a Vec4 * Vec2 = Mat4x2.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec4) OuterProd3 ¶

func (v1 Vec4) OuterProd3(v2 Vec3) Mat4x3

OuterProd3 does the vector outer product of two vectors. The outer product produces an 4x3 matrix. E.G. a Vec4 * Vec3 = Mat4x3.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec4) OuterProd4 ¶

func (v1 Vec4) OuterProd4(v2 Vec4) Mat4

OuterProd4 does the vector outer product of two vectors. The outer product produces an 4x4 matrix. E.G. a Vec4 * Vec4 = Mat4.

The outer product can be thought of as the "opposite" of the Dot product. The Dot product treats both vectors like matrices oriented such that the left one has N columns and the right has N rows. So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.

The outer product orients it so they're facing "outward": Vec2*Vec3 = Mat2x1*Mat1x3 = Mat2x3.

func (Vec4) Quat ¶

func (v Vec4) Quat() Quat

Quat reinterprets this vector as a quaternion, with the individual elements staying the same.

func (Vec4) Sub ¶

func (v1 Vec4) Sub(v2 Vec4) Vec4

Sub performs element-wise subtraction between two vectors. It is equivalent to iterating over every element of v1 and subtracting the corresponding element of v2 from it.

func (Vec4) Vec2 ¶

func (v Vec4) Vec2() Vec2

Vec2 constructs a 2-dimensional vector by discarding coordinates.

func (Vec4) Vec3 ¶

func (v Vec4) Vec3() Vec3

Vec3 constructs a 3-dimensional vector by discarding coordinates.

func (Vec4) W ¶

func (v Vec4) W() float64

W is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec4) X ¶

func (v Vec4) X() float64

X is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec4) Y ¶

func (v Vec4) Y() float64

Y is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (Vec4) Z ¶

func (v Vec4) Z() float64

Z is an element access func, it is equivalent to v[n] where n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks show that this is more or less as fast as direct acces, probably due to inlining, so use v[0] or v.X() depending on personal preference.

func (*VecN) Add ¶

func (vn *VecN) Add(dst *VecN, subtrahend *VecN) *VecN

Add adds vn and addend, storing the result in dst. If dst does not have sufficient size it will be resized Dst may be one of the other arguments. If dst is nil, it will be allocated. The value returned is dst, for easier method chaining

If vn and addend are not the same size, this function will add min(vn.Size(), addend.Size()) elements.

func (*VecN) ApproxEqual ¶

func (vn *VecN) ApproxEqual(vn2 *VecN) bool

ApproxEqual returns whether the two vectors are approximately equal (See FloatEqual).

func (*VecN) ApproxEqualFunc ¶

func (vn *VecN) ApproxEqualFunc(vn2 *VecN, comp func(float64, float64) bool) bool

ApproxEqualFunc returns whether the two vectors are approximately equal, given a function which compares two scalar elements.

func (*VecN) ApproxEqualThreshold ¶

func (vn *VecN) ApproxEqualThreshold(vn2 *VecN, epsilon float64) bool

ApproxEqualThreshold returns whether the two vectors are approximately equal to within the given threshold given by "epsilon" (See ApproxEqualThreshold).

func (*VecN) Cap ¶

func (vn *VecN) Cap() int

Cap Returns the cap of the vector's underlying slice.

func (*VecN) Cross ¶

func (vn *VecN) Cross(dst *VecN, other *VecN) *VecN

Cross takes the binary cross product of vn and other, and stores it in dst. If either vn or other are not of size 3 this function will panic

If dst is not of sufficient size, or is nil, a new slice is allocated. Dst is permitted to be one of the other arguments

func (*VecN) Dot ¶

func (vn *VecN) Dot(other *VecN) float64

Dot computes the dot product of two VecNs, if the two vectors are not of the same length -- this will return NaN.

func (VecN) Get ¶

func (vn VecN) Get(i int) float64

Get the element at index i from the vector. This does not bounds check, and will panic if i is out of range.

func (*VecN) Len ¶

func (vn *VecN) Len() float64

Len computes the vector length (also called the Norm) of the vector. Equivalent to math.Sqrt(vn.Dot(vn)) with the appropriate type conversions.

If vn is nil, this returns NaN

func (*VecN) LenSqr ¶

func (vn *VecN) LenSqr() float64

LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements.

func (*VecN) Mul ¶

func (vn *VecN) Mul(dst *VecN, c float64) *VecN

Mul multiplies the vector by some scalar value and stores the result in dst, which will be returned. Dst will be appropriately resized to the size of vn.

The destination can be vn itself and nothing will go wrong.

func (*VecN) Normalize ¶

func (vn *VecN) Normalize(dst *VecN) *VecN

Normalize the vector and stores the result in dst, which will be returned. Dst will be appropraitely resized to the size of vn.

The destination can be vn itself and nothing will go wrong.

This is equivalent to vn.Mul(dst, 1/vn.Len())

func (*VecN) OuterProd ¶

func (vn *VecN) OuterProd(dst *MatMxN, v2 *VecN) *MatMxN

OuterProd performs the vector outer product between vn and v2. The outer product is like a "reverse" dot product. Where the dot product aligns both vectors with the "sized" part facing "inward" (Vec3*Vec3=Mat1x3*Mat3x1=Mat1x1=Scalar). The outer product multiplied them with it facing "outward" (Vec3*Vec3=Mat3x1*Mat1x3=Mat3x3).

The matrix dst will be Reshaped to the correct size, if vn or v2 are nil, this returns nil.

func (VecN) Raw ¶

func (vn VecN) Raw() []float64

Raw returns the raw slice backing the VecN

This may be sent back to the memory pool at any time and you aren't advised to rely on this value

func (*VecN) Resize ¶

func (vn *VecN) Resize(n int) *VecN

Resize the underlying slice to the desired amount, reallocating or retrieving from the pool if necessary. The values after a Resize cannot be expected to be related to the values before a Resize.

If the caller is a nil pointer, this returns a value as if NewVecN(n) had been called, otherwise it simply returns the caller.

func (*VecN) Set ¶

func (vn *VecN) Set(i int, val float64)

Set the element at index i to val.

func (*VecN) SetBackingSlice ¶

func (vn *VecN) SetBackingSlice(newSlice []float64)

SetBackingSlice sets the vector's backing slice to the given new one.

func (*VecN) Size ¶

func (vn *VecN) Size() int

Size returns the len of the vector's underlying slice. This is not titled Len because it conflicts the package's convention of calling the Norm the Len.

func (*VecN) Sub ¶

func (vn *VecN) Sub(dst *VecN, addend *VecN) *VecN

Sub subtracts addend from vn, storing the result in dst. If dst does not have sufficient size it will be resized Dst may be one of the other arguments. If dst is nil, it will be allocated. The value returned is dst, for easier method chaining

If vn and addend are not the same size, this function will add min(vn.Size(), addend.Size()) elements.

func (*VecN) Vec2 ¶

func (vn *VecN) Vec2() Vec2

Vec2 constructs a 2-dimensional vector by discarding coordinates.

func (*VecN) Vec3 ¶

func (vn *VecN) Vec3() Vec3

Vec3 constructs a 3-dimensional vector by discarding coordinates.

func (*VecN) Vec4 ¶

func (vn *VecN) Vec4() Vec4

Vec4 constructs a 4-dimensional vector by discarding coordinates.

func (*VecN) Zero ¶

func (vn *VecN) Zero(n int)

Zero sets the vector's size to n and zeroes out the vector. If n is bigger than the vector's size, it will realloc.