Matrices.ele

# Matrix definitions
#
# The default constructors for Matrices use row Vectors,
# and there are also a "fromCols" function to allow definition
# using column vectors. A corresponding "fromRows" function
# also exists which can be used to help with code readability.
#

struct Matrix2x2(m00:Num, m01:Num, m10:Num, m11:Num)
{
    # Factories
    identity:Matrix2x2 = Matrix2x2.fromDiagonal(Vector2.one)

    fromRows(xRow:Vector2, yRow:Vector2):Matrix2x2
    {
        return = Matrix2x2(xRow.x, xRow.y, yRow.x, yRow.y)
    }

    fromCols(xCol:Vector2, yCol:Vector2):Matrix2x2
    {
        return = Matrix2x2.fromRows(xCol, yCol).transpose
    }

    #[[ Create a diagonal matrix from the specified vector ]]
    fromDiagonal(diag:Vector2):Matrix2x2
    {
        return = Matrix2x2(diag.x, 0, 0, diag.y)
    }

    # Properties
    xRow(m:Matrix2x2):Vector2 = Vector2(m.m00, m.m01)
    yRow(m:Matrix2x2):Vector2 = Vector2(m.m10, m.m11)
    xCol(m:Matrix2x2):Vector2 = Vector2(m.xRow.x, m.yRow.x)
    yCol(m:Matrix2x2):Vector2 = Vector2(m.xRow.y, m.yRow.y)

    diagonal(m:Matrix2x2):Vector2 = Vector2(m.xRow.x, m.yRow.y)

    transpose(m:Matrix2x2):Matrix2x2 = Matrix2x2.fromRows(m.xCol, m.yCol)

    determinant(m:Matrix2x2):Num
    {
        return = m.m00.mul(m.m11).sub(m.m10.mul(m.m01))
    }

    # Operations

    #[[ Multiply two square matrices
    #   Matrix 'a' is on the left and Matrix 'b' is on the right.
    #]]
    mul(a:Matrix2x2, b:Matrix2x2):Matrix2x2
    {
        new_m00 = a.xRow.dot(b.xCol)
        new_m01 = a.xRow.dot(b.yCol)
        new_m10 = a.yRow.dot(b.xCol)
        new_m11 = a.yRow.dot(b.yCol)
        return = Matrix2x2(new_m00, new_m01, new_m10, new_m11)
    }

    #[[ Multiple a vector by the matrix
    #   The matrix is on the left, and the vector is on the right.
    #]]
    vectorMul(m:Matrix2x2, v:Vector2):Vector2
    {
        return = Vector2(m.xRow.dot(v), m.yRow.dot(v))
    }
}


struct Matrix3x3(m00:Num, m01:Num, m02:Num, m10:Num, m11:Num, m12:Num, m20:Num, m21:Num, m22:Num)
{
    # Factories
    identity:Matrix3x3 = Matrix3x3.fromDiagonal(Vector3.one)

    fromCols(xCol:Vector3, yCol:Vector3, zCol:Vector3):Matrix3x3
    {
        return = Matrix3x3.fromRows(xCol, yCol, zCol).transpose
    }

    fromRows(xRow:Vector3, yRow:Vector3, zRow:Vector3):Matrix3x3
    {
        return = Matrix3x3(xRow.x, xRow.y, xRow.z,
                            yRow.x, yRow.y, yRow.z,
                            zRow.x, zRow.y, zRow.z)
    }

    #[[ Create a diagonal matrix from a the specified vector ]]
    fromDiagonal(diag:Vector3):Matrix3x3
    {
        return = Matrix3x3.fromRows(Vector3(diag.x, 0, 0), Vector3(0, diag.y, 0), Vector3(0, 0, diag.z))
    }

    # Properties
    xRow(m:Matrix3x3):Vector3 = Vector3(m.m00, m.m01, m.m02)
    yRow(m:Matrix3x3):Vector3 = Vector3(m.m10, m.m11, m.m12)
    zRow(m:Matrix3x3):Vector3 = Vector3(m.m20, m.m21, m.m22)
    xCol(m:Matrix3x3):Vector3 = Vector3(m.xRow.x, m.yRow.x, m.zRow.x)
    yCol(m:Matrix3x3):Vector3 = Vector3(m.xRow.y, m.yRow.y, m.zRow.y)
    zCol(m:Matrix3x3):Vector3 = Vector3(m.xRow.z, m.yRow.z, m.zRow.z)

    diagonal(m:Matrix3x3):Vector3 = Vector3(m.xRow.x, m.yRow.y, m.zRow.z)

    transpose(m:Matrix3x3):Matrix3x3 = Matrix3x3.fromRows(m.xCol, m.yCol, m.zCol)

    determinant(m:Matrix3x3):Num
    {
        signVector:Vector3 = Vector3(1, -1, 1)
        topRow:Vector3 = m.xRow

        xSubCol:Vector2 = Vector2(m.xCol.y, m.xCol.z)
        ySubCol:Vector2 = Vector2(m.yCol.y, m.yCol.z)
        zSubCol:Vector2 = Vector2(m.zCol.y, m.zCol.z)

        subDeterminants:Vector3 = Vector3(
            Matrix2x2.fromCols(ySubCol, zSubCol).determinant,
            Matrix2x2.fromCols(xSubCol, zSubCol).determinant,
            Matrix2x2.fromCols(xSubCol, ySubCol).determinant
        )
        resultComponents:Vector3 = Vector3(
            topRow.x.mul(subDeterminants.x),
            topRow.y.mul(subDeterminants.y),
            topRow.z.mul(subDeterminants.z)
        )

        return = resultComponents.dot(signVector)
    }

    # Operations

    #[[ Multiply two square matrices
    #   Matrix 'a' is on the left and 'b' is on the right
    #]]
    mul(a:Matrix3x3, b:Matrix3x3):Matrix3x3
    {
        createNewRow = _(v:Vector3, m:Matrix3x3)
        {
            return = Vector3(v.dot(m.xCol), v.dot(m.yCol), v.dot(m.zCol))
        }

        multipliedMatrix = Matrix3x3.fromRows(
            createNewRow(a.xRow, b),
            createNewRow(a.yRow, b),
            createNewRow(a.zRow, b)
        )

        return = multipliedMatrix
    }

    #[[ Multiple a vector by the matrix
    #   The matrix is on the left, and the vector is on the right.
    #]]
    vectorMul(m:Matrix3x3, v:Vector3):Vector3
    {
        return = Vector3(m.xRow.dot(v), m.yRow.dot(v), m.zRow.dot(v))
    }
}


struct Matrix4x4(m00:Num, m01:Num, m02:Num, m03:Num,
                m10:Num, m11:Num, m12:Num, m13:Num,
                m20:Num, m21:Num, m22:Num, m23:Num,
                m30:Num, m31:Num, m32:Num, m33:Num)
{
    identity = Matrix4x4.fromDiagonal(Vector4.one)

    fromRows(xRow:Vector4, yRow:Vector4, zRow:Vector4, wRow:Vector4):Matrix4x4
    {
        return = Matrix4x4(xRow.x, xRow.y, xRow.z, xRow.w,
                            yRow.x, yRow.y, yRow.z, yRow.w,
                            zRow.x, zRow.y, zRow.z, zRow.w,
                            wRow.x, wRow.y, wRow.z, wRow.w)
    }

    fromCols(xCol:Vector4, yCol:Vector4, zCol:Vector4, wCol:Vector4):Matrix4x4
    {
        return = Matrix4x4.fromRows(xCol, yCol, zCol, wCol).transpose
    }

    #[[ Create a diagonal matrix from its diagonal components ]]
    fromDiagonal(diag:Vector4):Matrix4x4
    {
        return = Matrix4x4.fromRows(
            Vector4(diag.x, 0, 0, 0),
            Vector4(0, diag.y, 0, 0),
            Vector4(0, 0, diag.z, 0),
            Vector4(0, 0, 0, diag.w)
        )
    }

    xRow(m:Matrix4x4):Vector4 = Vector4(m.m00, m.m01, m.m02, m.m03)
    yRow(m:Matrix4x4):Vector4 = Vector4(m.m10, m.m11, m.m12, m.m13)
    zRow(m:Matrix4x4):Vector4 = Vector4(m.m20, m.m21, m.m22, m.m23)
    wRow(m:Matrix4x4):Vector4 = Vector4(m.m30, m.m31, m.m32, m.m33)

    xCol(m:Matrix4x4):Vector4 = Vector4(m.xRow.x, m.yRow.x, m.zRow.x, m.wRow.x)
    yCol(m:Matrix4x4):Vector4 = Vector4(m.xRow.y, m.yRow.y, m.zRow.y, m.wRow.y)
    zCol(m:Matrix4x4):Vector4 = Vector4(m.xRow.z, m.yRow.z, m.zRow.z, m.wRow.z)
    wCol(m:Matrix4x4):Vector4 = Vector4(m.xRow.w, m.yRow.w, m.zRow.w, m.wRow.w)

    diagonal(m:Matrix4x4):Vector4
    {
        return = Vector4(m.xRow.x, m.yRow.y, m.zRow.z, m.wRow.w)
    }

    transpose(m:Matrix4x4):Matrix4x4 = Matrix4x4.fromRows(m.xCol, m.yCol, m.zCol, m.wCol)

    determinant(m:Matrix4x4):Num
    {
        signVector:Vector4 = Vector4(1, -1, 1, -1)
        topRow:Vector4 = m.xRow

        xSubCol:Vector3 = Vector3(m.xCol.y, m.xCol.z, m.xCol.w)
        ySubCol:Vector3 = Vector3(m.yCol.y, m.yCol.z, m.yCol.w)
        zSubCol:Vector3 = Vector3(m.zCol.y, m.zCol.z, m.zCol.w)
        wSubCol:Vector3 = Vector3(m.wCol.y, m.wCol.z, m.wCol.w)

        subDeterminants:Vector4 = Vector4(
            Matrix3x3.fromCols(ySubCol, zSubCol, wSubCol).determinant,
            Matrix3x3.fromCols(xSubCol, zSubCol, wSubCol).determinant,
            Matrix3x3.fromCols(xSubCol, ySubCol, wSubCol).determinant,
            Matrix3x3.fromCols(xSubCol, ySubCol, zSubCol).determinant
        )

        resultComponents:Vector4 = Vector4(
            topRow.x.mul(subDeterminants.x),
            topRow.y.mul(subDeterminants.y),
            topRow.z.mul(subDeterminants.z),
            topRow.w.mul(subDeterminants.w)
        )
        return = resultComponents.dot(signVector)
    }

    #[[ Multiply two square matrices
    #   Matrix 'a' is on the left and 'b' is on the right
    #]]
    mul(a:Matrix4x4, b:Matrix4x4):Matrix4x4
    {
        createNewRow = _(v:Vector4, m:Matrix4x4)
        {
            return = Vector4(v.dot(m.xCol), v.dot(m.yCol), v.dot(m.zCol), v.dot(m.wCol))
        }

        multipliedMatrix = Matrix4x4.fromRows(
            createNewRow(a.xRow, b),
            createNewRow(a.yRow, b),
            createNewRow(a.zRow, b),
            createNewRow(a.wRow, b)
        )

        return = multipliedMatrix
    }

    #[[ Multiple a vector by the matrix
    #   The matrix is on the left, and the vector is on the right.
    #]]
    vectorMul(this:Matrix4x4, v:Vector4):Vector4
    {
        multiply(matrixRow:Vector4):Num = matrixRow.dot(v)
        x = multiply(this.xRow)
        y = multiply(this.yRow)
        z = multiply(this.zRow)
        w = multiply(this.wRow)
        return = Vector4(x, y, z, w)
    }
}