com.io7m.jtensors.core.parameterized.matrices

## Class PMatrices4x4D

- java.lang.Object
- - com.io7m.jtensors.core.parameterized.matrices.PMatrices4x4D

-     public final class PMatrices4x4D
      extends Object

  Functions over `PMatrix4x4D` values.

  See "Mathematics for 3D Game Programming and Computer Graphics" 2nd Ed for the derivations of most of the code in this class (ISBN: 1-58450-277-0).

  Since:
    8.0.0

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F> PMatrix4x4D<E,F>` | `add(PMatrix4x4D<A,B> m0, PMatrix4x4D<C,D> m1)` Add the matrices `m0` and `m1`.
    `static <A,B> Vector4D` | `column0(PMatrix4x4D<A,B> m)`
    `static <A,B> Vector4D` | `column1(PMatrix4x4D<A,B> m)`
    `static <A,B> Vector4D` | `column2(PMatrix4x4D<A,B> m)`
    `static <A,B> Vector4D` | `column3(PMatrix4x4D<A,B> m)`
    `static <A,B> double` | `determinant(PMatrix4x4D<A,B> m)` Calculate the determinant of the matrix `m`.
    `static <A,B> PMatrix4x4D<A,B>` | `identity()` The identity matrix.
    `static <A,B> Optional<PMatrix4x4D<B,A>>` | `invert(PMatrix4x4D<A,B> m)` Calculate the inverse of the matrix `m`.
    `static <A,B,C> PMatrix4x4D<A,C>` | `multiply(PMatrix4x4D<B,C> m0, PMatrix4x4D<A,B> m1)` Multiply the matrices `m0` and `m1`.
    `static <A,B> PVector4D<B>` | `multiplyVectorPost(PMatrix4x4D<A,B> m, PVector4D<A> v)` Multiply the vector `v` by the matrix `m`.
    `static Vector4D` | `multiplyVectorPost(PMatrix4x4D m, Vector4D v)` Multiply the vector `v` by the matrix `m`.
    `static <A,B> PMatrix4x4D<A,B>` | `ofAxisAngle(double axis_x, double axis_y, double axis_z, double angle)` Construct a matrix that will rotate by `angle` radians around the axis `(x, y, z)`.
    `static <A,B> PMatrix4x4D<A,B>` | `ofColumns(Vector4D c0, Vector4D c1, Vector4D c2, Vector4D c3)` Construct a matrix from the column vectors `(c0, c1, c2, c3)`.
    `static <A,B> PMatrix4x4D<A,B>` | `ofRows(Vector4D r0, Vector4D r1, Vector4D r2, Vector4D r3)` Construct a matrix from the row vectors `(r0, r1, r2, r3)`.
    `static <A,B> PMatrix4x4D<A,B>` | `ofScale(double x, double y, double z)` Construct a matrix that will scale by `(x, y, z)`.
    `static <A,B> PMatrix4x4D<A,B>` | `ofTranslation(double x, double y, double z)` Construct a matrix that will translate by `(x, y, z)`.
    `static <A,B> Vector4D` | `row0(PMatrix4x4D<A,B> m)`
    `static <A,B> Vector4D` | `row1(PMatrix4x4D<A,B> m)`
    `static <A,B> Vector4D` | `row2(PMatrix4x4D<A,B> m)`
    `static <A,B> Vector4D` | `row3(PMatrix4x4D<A,B> m)`
    `static <A,B,C,D> PMatrix4x4D<C,D>` | `scale(PMatrix4x4D<A,B> m, double r)` Scale the matrix `m` by `r`.
    `static <A,B,C,D,E,F> PMatrix4x4D<E,F>` | `subtract(PMatrix4x4D<A,B> m0, PMatrix4x4D<C,D> m1)` Subtract the matrices `m0` and `m1`.
    `static <A,B> PMatrix4x4D<A,B>` | `toParameterized(Matrix4x4D m)`
    `static <A,B> Matrix4x4D` | `toUnparameterized(PMatrix4x4D<A,B> m)`
    `static <A,B> double` | `trace(PMatrix4x4D<A,B> m)` Return the trace of the matrix `m`.
    `static <A,B> PMatrix4x4D<A,B>` | `transpose(PMatrix4x4D<A,B> m)` Calculate the transpose of the matrix `m`.
    `static <A,B> PMatrix4x4D<A,B>` | `withColumn(PMatrix4x4D<A,B> m, int column, double r0, double r1, double r2, double r3)` Set the column `column` of `m` to `(r0, r1, r2, r3)`.
    `static <A,B> PMatrix4x4D<A,B>` | `withRow(PMatrix4x4D<A,B> m, int row, double c0, double c1, double c2, double c3)` Set the row `row` of `m` to `(c0, c1, c2, c3)`.
    `static <A,B> PMatrix4x4D<A,B>` | `zero()` The zero matrix.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### add

          public static <A,B,C,D,E,F> PMatrix4x4D<E,F> add(PMatrix4x4D<A,B> m0,
                                                           PMatrix4x4D<C,D> m1)

      Add the matrices `m0` and `m1`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
        `C` - A phantom type parameter (possibly representing a source coordinate system)
        `D` - A phantom type parameter (possibly representing a target coordinate system)
        `E` - A phantom type parameter (possibly representing a source coordinate system)
        `F` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m0` - The left matrix
        `m1` - The right matrix
      Returns:
        `m0 + m1`

    - #### determinant

          public static <A,B> double determinant(PMatrix4x4D<A,B> m)

      Calculate the determinant of the matrix `m`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        The determinant of `m`

    - #### invert

          public static <A,B> Optional<PMatrix4x4D<B,A>> invert(PMatrix4x4D<A,B> m)

      Calculate the inverse of the matrix `m`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        The inverse of `m`, or nothing if no inverse exists

    - #### multiply

          public static <A,B,C> PMatrix4x4D<A,C> multiply(PMatrix4x4D<B,C> m0,
                                                          PMatrix4x4D<A,B> m1)

      Multiply the matrices `m0` and `m1`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
        `C` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m0` - The left matrix
        `m1` - The right matrix
      Returns:
        `m0 * m1`

    - #### multiplyVectorPost

          public static <A,B> PVector4D<B> multiplyVectorPost(PMatrix4x4D<A,B> m,
                                                              PVector4D<A> v)

      Multiply the vector `v` by the matrix `m`.

      This is post multiplication.

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The matrix
        `v` - The vector
      Returns:
        `m * v`

    - #### multiplyVectorPost

          public static Vector4D multiplyVectorPost(PMatrix4x4D m,
                                                    Vector4D v)

      Multiply the vector `v` by the matrix `m`.

      This is post multiplication.

      Parameters:
        `m` - The matrix
        `v` - The vector
      Returns:
        `m * v`

    - #### ofColumns

          public static <A,B> PMatrix4x4D<A,B> ofColumns(Vector4D c0,
                                                         Vector4D c1,
                                                         Vector4D c2,
                                                         Vector4D c3)

      Construct a matrix from the column vectors `(c0, c1, c2, c3)`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `c0` - The column 0
        `c1` - The column 1
        `c2` - The column 2
        `c3` - The column 3
      Returns:
        A constructed matrix

    - #### ofRows

          public static <A,B> PMatrix4x4D<A,B> ofRows(Vector4D r0,
                                                      Vector4D r1,
                                                      Vector4D r2,
                                                      Vector4D r3)

      Construct a matrix from the row vectors `(r0, r1, r2, r3)`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `r0` - The row 0
        `r1` - The row 1
        `r2` - The row 2
        `r3` - The row 3
      Returns:
        A constructed matrix

    - #### ofScale

          public static <A,B> PMatrix4x4D<A,B> ofScale(double x,
                                                       double y,
                                                       double z)

      Construct a matrix that will scale by `(x, y, z)`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `x` - The X scaling value
        `y` - The Y scaling value
        `z` - The Z scaling value
      Returns:
        A constructed matrix

    - #### ofTranslation

          public static <A,B> PMatrix4x4D<A,B> ofTranslation(double x,
                                                             double y,
                                                             double z)

      Construct a matrix that will translate by `(x, y, z)`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `x` - The X scaling value
        `y` - The Y scaling value
        `z` - The Z scaling value
      Returns:
        A constructed matrix

    - #### ofAxisAngle

          public static <A,B> PMatrix4x4D<A,B> ofAxisAngle(double axis_x,
                                                           double axis_y,
                                                           double axis_z,
                                                           double angle)

      Construct a matrix that will rotate by `angle` radians around the axis `(x, y, z)`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `angle` - The angle in radians
        `axis_x` - The X axis value
        `axis_y` - The Y axis value
        `axis_z` - The Z axis value
      Returns:
        A constructed matrix

    - #### row0

          public static <A,B> Vector4D row0(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Row 0 of the matrix

    - #### row1

          public static <A,B> Vector4D row1(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Row 1 of the matrix

    - #### row2

          public static <A,B> Vector4D row2(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Row 2 of the matrix

    - #### row3

          public static <A,B> Vector4D row3(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Row 3 of the matrix

    - #### column0

          public static <A,B> Vector4D column0(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Column 0 of the matrix

    - #### column1

          public static <A,B> Vector4D column1(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Column 1 of the matrix

    - #### column2

          public static <A,B> Vector4D column2(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Column 2 of the matrix

    - #### column3

          public static <A,B> Vector4D column3(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a source coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        Column 3 of the matrix

    - #### scale

          public static <A,B,C,D> PMatrix4x4D<C,D> scale(PMatrix4x4D<A,B> m,
                                                         double r)

      Scale the matrix `m` by `r`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
        `C` - A phantom type parameter (possibly representing a source coordinate system)
        `D` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The matrix
        `r` - The scale factor
      Returns:
        `m * r`

    - #### subtract

          public static <A,B,C,D,E,F> PMatrix4x4D<E,F> subtract(PMatrix4x4D<A,B> m0,
                                                                PMatrix4x4D<C,D> m1)

      Subtract the matrices `m0` and `m1`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
        `C` - A phantom type parameter (possibly representing a source coordinate system)
        `D` - A phantom type parameter (possibly representing a target coordinate system)
        `E` - A phantom type parameter (possibly representing a source coordinate system)
        `F` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m0` - The left matrix
        `m1` - The right matrix
      Returns:
        `m0 - m1`

    - #### trace

          public static <A,B> double trace(PMatrix4x4D<A,B> m)

      Return the trace of the matrix `m`. The trace is defined as the sum of the diagonal elements of the matrix.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        The trace of the matrix

    - #### transpose

          public static <A,B> PMatrix4x4D<A,B> transpose(PMatrix4x4D<A,B> m)

      Calculate the transpose of the matrix `m`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The matrix
      Returns:
        The transpose of `m`

    - #### withColumn

          public static <A,B> PMatrix4x4D<A,B> withColumn(PMatrix4x4D<A,B> m,
                                                          int column,
                                                          double r0,
                                                          double r1,
                                                          double r2,
                                                          double r3)

      Set the column `column` of `m` to `(r0, r1, r2, r3)`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system) * @param r0 The value of row 0 in the column
      Parameters:
        `m` - The matrix
        `column` - The column index in the range `[0, 3]`
        `r1` - The value of row 1 in the column
        `r2` - The value of row 2 in the column
        `r3` - The value of row 3 in the column
      Returns:
        A matrix with the given row

    - #### withRow

          public static <A,B> PMatrix4x4D<A,B> withRow(PMatrix4x4D<A,B> m,
                                                       int row,
                                                       double c0,
                                                       double c1,
                                                       double c2,
                                                       double c3)

      Set the row `row` of `m` to `(c0, c1, c2, c3)`.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The matrix
        `row` - The row index in the range `[0, 3]`
        `c0` - The value of column 0 in the row
        `c1` - The value of column 1 in the row
        `c2` - The value of column 2 in the row
        `c3` - The value of column 3 in the row
      Returns:
        A matrix with the given row

    - #### zero

          public static <A,B> PMatrix4x4D<A,B> zero()

      The zero matrix.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Returns:
        A matrix with all zero components

    - #### identity

          public static <A,B> PMatrix4x4D<A,B> identity()

      The identity matrix.
      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Returns:
        A matrix with all diagonal components set to 1 and all other components set to 0.

    - #### toUnparameterized

          public static <A,B> Matrix4x4D toUnparameterized(PMatrix4x4D<A,B> m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The input matrix
      Returns:
        A matrix equal to `m` but without type parameters

    - #### toParameterized

          public static <A,B> PMatrix4x4D<A,B> toParameterized(Matrix4x4D m)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a source coordinate system)
        `B` - A phantom type parameter (possibly representing a target coordinate system)
      Parameters:
        `m` - The input matrix
      Returns:
        A matrix equal to `m` with type parameters

Copyright © 2017 <code@io7m.com> http://io7m.com