Module com.io7m.jtensors.core
Package com.io7m.jtensors.core.parameterized.matrices

## Class PMatrices2x2F

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

-     public final class PMatrices2x2F
      extends Object

  Functions over `PMatrix2x2F` 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 | Description
    --- | --- | ---
    `static <A,B,C,D,E,F> PMatrix2x2F<E,F>` | `add​(PMatrix2x2F<A,B> m0, PMatrix2x2F<C,D> m1)` | Add the matrices `m0` and `m1`.
    `static <A,B> Vector2F` | `column0​(PMatrix2x2F<A,B> m)` |
    `static <A,B> Vector2F` | `column1​(PMatrix2x2F<A,B> m)` |
    `static <A,B> double` | `determinant​(PMatrix2x2F<A,B> m)` | Calculate the determinant of the matrix `m`.
    `static <A,B> PMatrix2x2F<A,B>` | `identity​()` | The identity matrix.
    `static <A,B> Optional<PMatrix2x2F<B,A>>` | `invert​(PMatrix2x2F<A,B> m)` | Calculate the inverse of the matrix `m`.
    `static <A,B,C> PMatrix2x2F<A,C>` | `multiply​(PMatrix2x2F<B,C> m0, PMatrix2x2F<A,B> m1)` | Multiply the matrices `m0` and `m1`.
    `static <A,B> PVector2F<B>` | `multiplyVectorPost​(PMatrix2x2F<A,B> m, PVector2F<A> v)` | Multiply the vector `v` by the matrix `m`.
    `static Vector2F` | `multiplyVectorPost​(PMatrix2x2F m, Vector2F v)` | Multiply the vector `v` by the matrix `m`.
    `static <A,B> PMatrix2x2F<A,B>` | `ofColumns​(Vector2F c0, Vector2F c1)` | Construct a matrix from the column vectors `(c0, c1)`.
    `static <A,B> PMatrix2x2F<A,B>` | `ofRows​(Vector2F r0, Vector2F r1)` | Construct a matrix from the row vectors `(r0, r1)`.
    `static <A,B> PMatrix2x2F<A,B>` | `ofScale​(double x, double y)` | Construct a matrix that will scale by `(x, y)`.
    `static <A,B> Vector2F` | `row0​(PMatrix2x2F<A,B> m)` |
    `static <A,B> Vector2F` | `row1​(PMatrix2x2F<A,B> m)` |
    `static <A,B,C,D> PMatrix2x2F<C,D>` | `scale​(PMatrix2x2F<A,B> m, double r)` | Scale the matrix `m` by `r`.
    `static <A,B,C,D,E,F> PMatrix2x2F<E,F>` | `subtract​(PMatrix2x2F<A,B> m0, PMatrix2x2F<C,D> m1)` | Subtract the matrices `m0` and `m1`.
    `static <A,B> PMatrix2x2F<A,B>` | `toParameterized​(Matrix2x2F m)` |
    `static <A,B> Matrix2x2F` | `toUnparameterized​(PMatrix2x2F<A,B> m)` |
    `static <A,B> double` | `trace​(PMatrix2x2F<A,B> m)` | Return the trace of the matrix `m`.
    `static <A,B> PMatrix2x2F<A,B>` | `transpose​(PMatrix2x2F<A,B> m)` | Calculate the transpose of the matrix `m`.
    `static <A,B> PMatrix2x2F<A,B>` | `withColumn​(PMatrix2x2F<A,B> m, int column, float r0, float r1)` | Set the column `column` of `m` to `(r0, r1)`.
    `static <A,B> PMatrix2x2F<A,B>` | `withRow​(PMatrix2x2F<A,B> m, int row, float c0, float c1)` | Set the row `row` of `m` to `(c0, c1)`.
    `static <A,B> PMatrix2x2F<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> PMatrix2x2F<E,F> add​(PMatrix2x2F<A,B> m0,
                                                           PMatrix2x2F<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​(PMatrix2x2F<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<PMatrix2x2F<B,A>> invert​(PMatrix2x2F<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> PMatrix2x2F<A,C> multiply​(PMatrix2x2F<B,C> m0,
                                                          PMatrix2x2F<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> PVector2F<B> multiplyVectorPost​(PMatrix2x2F<A,B> m,
                                                              PVector2F<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 Vector2F multiplyVectorPost​(PMatrix2x2F m,
                                                    Vector2F 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> PMatrix2x2F<A,B> ofColumns​(Vector2F c0,
                                                         Vector2F c1)

      Construct a matrix from the column vectors `(c0, c1)`.
      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
      Returns:
        A constructed matrix

    - #### ofRows

          public static <A,B> PMatrix2x2F<A,B> ofRows​(Vector2F r0,
                                                      Vector2F r1)

      Construct a matrix from the row vectors `(r0, r1)`.
      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
      Returns:
        A constructed matrix

    - #### ofScale

          public static <A,B> PMatrix2x2F<A,B> ofScale​(double x,
                                                       double y)

      Construct a matrix that will scale by `(x, y)`.
      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
      Returns:
        A constructed matrix

    - #### row0

          public static <A,B> Vector2F row0​(PMatrix2x2F<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> Vector2F row1​(PMatrix2x2F<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

    - #### column0

          public static <A,B> Vector2F column0​(PMatrix2x2F<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> Vector2F column1​(PMatrix2x2F<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

    - #### scale

          public static <A,B,C,D> PMatrix2x2F<C,D> scale​(PMatrix2x2F<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> PMatrix2x2F<E,F> subtract​(PMatrix2x2F<A,B> m0,
                                                                PMatrix2x2F<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​(PMatrix2x2F<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> PMatrix2x2F<A,B> transpose​(PMatrix2x2F<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> PMatrix2x2F<A,B> withColumn​(PMatrix2x2F<A,B> m,
                                                          int column,
                                                          float r0,
                                                          float r1)

      Set the column `column` of `m` to `(r0, r1)`.
      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, 1]`
        `r1` - The value of row 1 in the column
      Returns:
        A matrix with the given row

    - #### withRow

          public static <A,B> PMatrix2x2F<A,B> withRow​(PMatrix2x2F<A,B> m,
                                                       int row,
                                                       float c0,
                                                       float c1)

      Set the row `row` of `m` to `(c0, c1)`.
      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, 1]`
        `c0` - The value of column 0 in the row
        `c1` - The value of column 1 in the row
      Returns:
        A matrix with the given row

    - #### zero

          public static <A,B> PMatrix2x2F<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> PMatrix2x2F<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> Matrix2x2F toUnparameterized​(PMatrix2x2F<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> PMatrix2x2F<A,B> toParameterized​(Matrix2x2F 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