Package org.joml

Interface Matrix2dc

  • All Known Implementing Classes:
    Matrix2d
    public interface Matrix2dc
    Interface to a read-only view of a 2x2 matrix of double-precision floats.
    Author:
    Joseph Burton

    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      Matrix2d add​(Matrix2dc other, Matrix2d dest)
      Component-wise add this and other and store the result in dest.
      double determinant()
      Return the determinant of this matrix.
      boolean equals​(Matrix2dc m, double delta)
      Compare the matrix elements of this matrix with the given matrix using the given delta and return whether all of them are equal within a maximum difference of delta.
      double[] get​(double[] arr)
      Store this matrix into the supplied double array in column-major order.
      double[] get​(double[] arr, int offset)
      Store this matrix into the supplied double array in column-major order at the given offset.
      double get​(int column, int row)
      Get the matrix element value at the given column and row.
      java.nio.ByteBuffer get​(int index, java.nio.ByteBuffer buffer)
      Store this matrix in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
      java.nio.DoubleBuffer get​(int index, java.nio.DoubleBuffer buffer)
      Store this matrix in column-major order into the supplied DoubleBuffer starting at the specified absolute buffer position/index.
      java.nio.ByteBuffer get​(java.nio.ByteBuffer buffer)
      Store this matrix in column-major order into the supplied ByteBuffer at the current buffer position.
      java.nio.DoubleBuffer get​(java.nio.DoubleBuffer buffer)
      Store this matrix in column-major order into the supplied DoubleBuffer at the current buffer position.
      Matrix2d get​(Matrix2d dest)
      Get the current values of this matrix and store them into dest.
      Matrix3d get​(Matrix3d dest)
      Get the current values of this matrix and store them as the rotational component of dest.
      Matrix3x2d get​(Matrix3x2d dest)
      Get the current values of this matrix and store them as the rotational component of dest.
      Vector2d getColumn​(int column, Vector2d dest)
      Get the column at the given column index, starting with 0.
      java.nio.ByteBuffer getFloats​(int index, java.nio.ByteBuffer buffer)
      Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
      java.nio.ByteBuffer getFloats​(java.nio.ByteBuffer buffer)
      Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer at the current buffer position.
      double getRotation()
      Get the angle of the rotation component of this matrix.
      Vector2d getRow​(int row, Vector2d dest)
      Get the row at the given row index, starting with 0.
      Vector2d getScale​(Vector2d dest)
      Get the scaling factors of this matrix for the three base axes.
      Matrix2dc getToAddress​(long address)
      Store this matrix in column-major order at the given off-heap address.
      java.nio.ByteBuffer getTransposed​(int index, java.nio.ByteBuffer buffer)
      Store this matrix in row-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
      java.nio.DoubleBuffer getTransposed​(int index, java.nio.DoubleBuffer buffer)
      Store this matrix in row-major order into the supplied DoubleBuffer starting at the specified absolute buffer position/index.
      java.nio.FloatBuffer getTransposed​(int index, java.nio.FloatBuffer buffer)
      Store this matrix in row-major order into the supplied FloatBuffer starting at the specified absolute buffer position/index.
      java.nio.ByteBuffer getTransposed​(java.nio.ByteBuffer buffer)
      Store this matrix in row-major order into the supplied ByteBuffer at the current buffer position.
      java.nio.DoubleBuffer getTransposed​(java.nio.DoubleBuffer buffer)
      Store this matrix in row-major order into the supplied DoubleBuffer at the current buffer position.
      java.nio.FloatBuffer getTransposed​(java.nio.FloatBuffer buffer)
      Store this matrix in row-major order into the supplied FloatBuffer at the current buffer position.
      java.nio.ByteBuffer getTransposedFloats​(int index, java.nio.ByteBuffer buffer)
      Store this matrix in row-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
      java.nio.ByteBuffer getTransposedFloats​(java.nio.ByteBuffer buffer)
      Store this matrix as float values in row-major order into the supplied ByteBuffer at the current buffer position.
      Matrix2d invert​(Matrix2d dest)
      Invert the this matrix and store the result in dest.
      boolean isFinite()
      Determine whether all matrix elements are finite floating-point values, that is, they are not NaN and not infinity.
      Matrix2d lerp​(Matrix2dc other, double t, Matrix2d dest)
      Linearly interpolate this and other using the given interpolation factor t and store the result in dest.
      double m00()
      Return the value of the matrix element at column 0 and row 0.
      double m01()
      Return the value of the matrix element at column 0 and row 1.
      double m10()
      Return the value of the matrix element at column 1 and row 0.
      double m11()
      Return the value of the matrix element at column 1 and row 1.
      Matrix2d mul​(Matrix2dc right, Matrix2d dest)
      Multiply this matrix by the supplied right matrix and store the result in dest.
      Matrix2d mul​(Matrix2fc right, Matrix2d dest)
      Multiply this matrix by the supplied right matrix and store the result in dest.
      Matrix2d mulComponentWise​(Matrix2dc other, Matrix2d dest)
      Component-wise multiply this by other and store the result in dest.
      Matrix2d mulLocal​(Matrix2dc left, Matrix2d dest)
      Pre-multiply this matrix by the supplied left matrix and store the result in dest.
      Matrix2d normal​(Matrix2d dest)
      Compute a normal matrix from this matrix and store it into dest.
      Vector2d normalizedPositiveX​(Vector2d dest)
      Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied.
      Vector2d normalizedPositiveY​(Vector2d dest)
      Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied.
      Vector2d positiveX​(Vector2d dest)
      Obtain the direction of +X before the transformation represented by this matrix is applied.
      Vector2d positiveY​(Vector2d dest)
      Obtain the direction of +Y before the transformation represented by this matrix is applied.
      Matrix2d rotate​(double ang, Matrix2d dest)
      Apply rotation to this matrix by rotating the given amount of radians and store the result in dest.
      Matrix2d rotateLocal​(double ang, Matrix2d dest)
      Pre-multiply a rotation to this matrix by rotating the given amount of radians and store the result in dest.
      Matrix2d scale​(double x, double y, Matrix2d dest)
      Apply scaling to this matrix by scaling the base axes by the given x and y factors and store the result in dest.
      Matrix2d scale​(double xy, Matrix2d dest)
      Apply scaling to this matrix by uniformly scaling all base axes by the given xy factor and store the result in dest.
      Matrix2d scale​(Vector2dc xy, Matrix2d dest)
      Apply scaling to this matrix by scaling the base axes by the given xy.x and xy.y factors, respectively and store the result in dest.
      Matrix2d scaleLocal​(double x, double y, Matrix2d dest)
      Pre-multiply scaling to this matrix by scaling the base axes by the given x and y factors and store the result in dest.
      Matrix2d sub​(Matrix2dc subtrahend, Matrix2d dest)
      Component-wise subtract subtrahend from this and store the result in dest.
      Vector2d transform​(double x, double y, Vector2d dest)
      Transform the vector (x, y) by this matrix and store the result in dest.
      Vector2d transform​(Vector2d v)
      Transform the given vector by this matrix.
      Vector2d transform​(Vector2dc v, Vector2d dest)
      Transform the given vector by this matrix and store the result in dest.
      Vector2d transformTranspose​(double x, double y, Vector2d dest)
      Transform the vector (x, y) by the transpose of this matrix and store the result in dest.
      Vector2d transformTranspose​(Vector2d v)
      Transform the given vector by the transpose of this matrix.
      Vector2d transformTranspose​(Vector2dc v, Vector2d dest)
      Transform the given vector by the transpose of this matrix and store the result in dest.
      Matrix2d transpose​(Matrix2d dest)
      Transpose this matrix and store the result in dest.

    • Method Detail

      • m00

        double m00()
        Return the value of the matrix element at column 0 and row 0.
        Returns:
        the value of the matrix element

      • m01

        double m01()
        Return the value of the matrix element at column 0 and row 1.
        Returns:
        the value of the matrix element

      • m10

        double m10()
        Return the value of the matrix element at column 1 and row 0.
        Returns:
        the value of the matrix element

      • m11

        double m11()
        Return the value of the matrix element at column 1 and row 1.
        Returns:
        the value of the matrix element

      • mul

        Matrix2d mul​(Matrix2dc right,
             Matrix2d dest)
        Multiply this matrix by the supplied right matrix and store the result in dest.

        If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!

        Parameters:
        right - the right operand of the matrix multiplication
        dest - will hold the result
        Returns:
        dest

      • mul

        Matrix2d mul​(Matrix2fc right,
             Matrix2d dest)
        Multiply this matrix by the supplied right matrix and store the result in dest.

        If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!

        Parameters:
        right - the right operand of the matrix multiplication
        dest - will hold the result
        Returns:
        dest

      • mulLocal

        Matrix2d mulLocal​(Matrix2dc left,
                  Matrix2d dest)
        Pre-multiply this matrix by the supplied left matrix and store the result in dest.

        If M is this matrix and L the left matrix, then the new matrix will be L * M. So when transforming a vector v with the new matrix by using L * M * v, the transformation of this matrix will be applied first!

        Parameters:
        left - the left operand of the matrix multiplication
        dest - the destination matrix, which will hold the result
        Returns:
        dest

      • determinant

        double determinant()
        Return the determinant of this matrix.
        Returns:
        the determinant

      • invert

        Matrix2d invert​(Matrix2d dest)
        Invert the this matrix and store the result in dest.
        Parameters:
        dest - will hold the result
        Returns:
        dest

      • transpose

        Matrix2d transpose​(Matrix2d dest)
        Transpose this matrix and store the result in dest.
        Parameters:
        dest - will hold the result
        Returns:
        dest

      • get

        Matrix2d get​(Matrix2d dest)
        Get the current values of this matrix and store them into dest.
        Parameters:
        dest - the destination matrix
        Returns:
        the passed in destination

      • get

        Matrix3x2d get​(Matrix3x2d dest)
        Get the current values of this matrix and store them as the rotational component of dest. All other values of dest will be set to 0.
        Parameters:
        dest - the destination matrix
        Returns:
        the passed in destination
        See Also:
        Matrix3x2d.set(Matrix2dc)

      • get

        Matrix3d get​(Matrix3d dest)
        Get the current values of this matrix and store them as the rotational component of dest. All other values of dest will be set to identity.
        Parameters:
        dest - the destination matrix
        Returns:
        the passed in destination
        See Also:
        Matrix3d.set(Matrix2dc)

      • getRotation

        double getRotation()
        Get the angle of the rotation component of this matrix.

        This method assumes that there is a valid rotation to be returned, i.e. that atan2(-m10, m00) == atan2(m01, m11).

        Returns:
        the angle

      • get

        java.nio.DoubleBuffer get​(java.nio.DoubleBuffer buffer)
        Store this matrix in column-major order into the supplied DoubleBuffer at the current buffer position.

        This method will not increment the position of the given DoubleBuffer.

        In order to specify the offset into the DoubleBuffer at which the matrix is stored, use get(int, DoubleBuffer), taking the absolute position as parameter.

        Parameters:
        buffer - will receive the values of this matrix in column-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        get(int, DoubleBuffer)

      • get

        java.nio.DoubleBuffer get​(int index,
                          java.nio.DoubleBuffer buffer)
        Store this matrix in column-major order into the supplied DoubleBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given DoubleBuffer.

        Parameters:
        index - the absolute position into the DoubleBuffer
        buffer - will receive the values of this matrix in column-major order
        Returns:
        the passed in buffer

      • get

        java.nio.ByteBuffer get​(java.nio.ByteBuffer buffer)
        Store this matrix in column-major order into the supplied ByteBuffer at the current buffer position.

        This method will not increment the position of the given ByteBuffer.

        In order to specify the offset into the ByteBuffer at which the matrix is stored, use get(int, ByteBuffer), taking the absolute position as parameter.

        Parameters:
        buffer - will receive the values of this matrix in column-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        get(int, ByteBuffer)

      • get

        java.nio.ByteBuffer get​(int index,
                        java.nio.ByteBuffer buffer)
        Store this matrix in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given ByteBuffer.

        Parameters:
        index - the absolute position into the ByteBuffer
        buffer - will receive the values of this matrix in column-major order
        Returns:
        the passed in buffer

      • getFloats

        java.nio.ByteBuffer getFloats​(java.nio.ByteBuffer buffer)
        Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer at the current buffer position.

        This method will not increment the position of the given ByteBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given ByteBuffer.

        In order to specify the offset into the ByteBuffer at which the matrix is stored, use getFloats(int, ByteBuffer), taking the absolute position as parameter.

        Parameters:
        buffer - will receive the elements of this matrix as float values in column-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        getFloats(int, ByteBuffer)

      • getFloats

        java.nio.ByteBuffer getFloats​(int index,
                              java.nio.ByteBuffer buffer)
        Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given ByteBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given ByteBuffer.

        Parameters:
        index - the absolute position into the ByteBuffer
        buffer - will receive the elements of this matrix as float values in column-major order
        Returns:
        the passed in buffer

      • getTransposed

        java.nio.DoubleBuffer getTransposed​(java.nio.DoubleBuffer buffer)
        Store this matrix in row-major order into the supplied DoubleBuffer at the current buffer position.

        This method will not increment the position of the given DoubleBuffer.

        In order to specify the offset into the DoubleBuffer at which the matrix is stored, use getTransposed(int, DoubleBuffer), taking the absolute position as parameter.

        Parameters:
        buffer - will receive the values of this matrix in row-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        getTransposed(int, DoubleBuffer)

      • getTransposed

        java.nio.DoubleBuffer getTransposed​(int index,
                                    java.nio.DoubleBuffer buffer)
        Store this matrix in row-major order into the supplied DoubleBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given DoubleBuffer.

        Parameters:
        index - the absolute position into the DoubleBuffer
        buffer - will receive the values of this matrix in row-major order
        Returns:
        the passed in buffer

      • getTransposed

        java.nio.ByteBuffer getTransposed​(java.nio.ByteBuffer buffer)
        Store this matrix in row-major order into the supplied ByteBuffer at the current buffer position.

        This method will not increment the position of the given ByteBuffer.

        In order to specify the offset into the ByteBuffer at which the matrix is stored, use getTransposed(int, ByteBuffer), taking the absolute position as parameter.

        Parameters:
        buffer - will receive the values of this matrix in row-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        getTransposed(int, ByteBuffer)

      • getTransposed

        java.nio.ByteBuffer getTransposed​(int index,
                                  java.nio.ByteBuffer buffer)
        Store this matrix in row-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given ByteBuffer.

        Parameters:
        index - the absolute position into the ByteBuffer
        buffer - will receive the values of this matrix in row-major order
        Returns:
        the passed in buffer

      • getTransposed

        java.nio.FloatBuffer getTransposed​(java.nio.FloatBuffer buffer)
        Store this matrix in row-major order into the supplied FloatBuffer at the current buffer position.

        This method will not increment the position of the given FloatBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.

        In order to specify the offset into the FloatBuffer at which the matrix is stored, use getTransposed(int, FloatBuffer), taking the absolute position as parameter.

        Parameters:
        buffer - will receive the values of this matrix in row-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        getTransposed(int, FloatBuffer)

      • getTransposed

        java.nio.FloatBuffer getTransposed​(int index,
                                   java.nio.FloatBuffer buffer)
        Store this matrix in row-major order into the supplied FloatBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given FloatBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.

        Parameters:
        index - the absolute position into the FloatBuffer
        buffer - will receive the values of this matrix in row-major order
        Returns:
        the passed in buffer

      • getTransposedFloats

        java.nio.ByteBuffer getTransposedFloats​(java.nio.ByteBuffer buffer)
        Store this matrix as float values in row-major order into the supplied ByteBuffer at the current buffer position.

        This method will not increment the position of the given ByteBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.

        In order to specify the offset into the ByteBuffer at which the matrix is stored, use getTransposedFloats(int, ByteBuffer), taking the absolute position as parameter.

        Parameters:
        buffer - will receive the values of this matrix as float values in row-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        getTransposedFloats(int, ByteBuffer)

      • getTransposedFloats

        java.nio.ByteBuffer getTransposedFloats​(int index,
                                        java.nio.ByteBuffer buffer)
        Store this matrix in row-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given ByteBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.

        Parameters:
        index - the absolute position into the ByteBuffer
        buffer - will receive the values of this matrix as float values in row-major order
        Returns:
        the passed in buffer

      • getToAddress

        Matrix2dc getToAddress​(long address)
        Store this matrix in column-major order at the given off-heap address.

        This method will throw an UnsupportedOperationException when JOML is used with `-Djoml.nounsafe`.

        This method is unsafe as it can result in a crash of the JVM process when the specified address range does not belong to this process.

        Parameters:
        address - the off-heap address where to store this matrix
        Returns:
        this

      • get

        double[] get​(double[] arr,
             int offset)
        Store this matrix into the supplied double array in column-major order at the given offset.
        Parameters:
        arr - the array to write the matrix values into
        offset - the offset into the array
        Returns:
        the passed in array

      • get

        double[] get​(double[] arr)
        Store this matrix into the supplied double array in column-major order.

        In order to specify an explicit offset into the array, use the method get(double[], int).

        Parameters:
        arr - the array to write the matrix values into
        Returns:
        the passed in array
        See Also:
        get(double[], int)

      • scale

        Matrix2d scale​(Vector2dc xy,
               Matrix2d dest)
        Apply scaling to this matrix by scaling the base axes by the given xy.x and xy.y factors, respectively and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Parameters:
        xy - the factors of the x and y component, respectively
        dest - will hold the result
        Returns:
        dest

      • scale

        Matrix2d scale​(double x,
               double y,
               Matrix2d dest)
        Apply scaling to this matrix by scaling the base axes by the given x and y factors and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Parameters:
        x - the factor of the x component
        y - the factor of the y component
        dest - will hold the result
        Returns:
        dest

      • scale

        Matrix2d scale​(double xy,
               Matrix2d dest)
        Apply scaling to this matrix by uniformly scaling all base axes by the given xy factor and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Parameters:
        xy - the factor for all components
        dest - will hold the result
        Returns:
        dest
        See Also:
        scale(double, double, Matrix2d)

      • scaleLocal

        Matrix2d scaleLocal​(double x,
                    double y,
                    Matrix2d dest)
        Pre-multiply scaling to this matrix by scaling the base axes by the given x and y factors and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be S * M. So when transforming a vector v with the new matrix by using S * M * v , the scaling will be applied last!

        Parameters:
        x - the factor of the x component
        y - the factor of the y component
        dest - will hold the result
        Returns:
        dest

      • transform

        Vector2d transform​(Vector2d v)
        Transform the given vector by this matrix.
        Parameters:
        v - the vector to transform
        Returns:
        v

      • transform

        Vector2d transform​(Vector2dc v,
                   Vector2d dest)
        Transform the given vector by this matrix and store the result in dest.
        Parameters:
        v - the vector to transform
        dest - will hold the result
        Returns:
        dest

      • transform

        Vector2d transform​(double x,
                   double y,
                   Vector2d dest)
        Transform the vector (x, y) by this matrix and store the result in dest.
        Parameters:
        x - the x coordinate of the vector to transform
        y - the y coordinate of the vector to transform
        dest - will hold the result
        Returns:
        dest

      • transformTranspose

        Vector2d transformTranspose​(Vector2d v)
        Transform the given vector by the transpose of this matrix.
        Parameters:
        v - the vector to transform
        Returns:
        v

      • transformTranspose

        Vector2d transformTranspose​(Vector2dc v,
                            Vector2d dest)
        Transform the given vector by the transpose of this matrix and store the result in dest.
        Parameters:
        v - the vector to transform
        dest - will hold the result
        Returns:
        dest

      • transformTranspose

        Vector2d transformTranspose​(double x,
                            double y,
                            Vector2d dest)
        Transform the vector (x, y) by the transpose of this matrix and store the result in dest.
        Parameters:
        x - the x coordinate of the vector to transform
        y - the y coordinate of the vector to transform
        dest - will hold the result
        Returns:
        dest

      • rotate

        Matrix2d rotate​(double ang,
                Matrix2d dest)
        Apply rotation to this matrix by rotating the given amount of radians and store the result in dest.

        The produced rotation will rotate a vector counter-clockwise around the origin.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        dest - will hold the result
        Returns:
        dest

      • rotateLocal

        Matrix2d rotateLocal​(double ang,
                     Matrix2d dest)
        Pre-multiply a rotation to this matrix by rotating the given amount of radians and store the result in dest.

        The produced rotation will rotate a vector counter-clockwise around the origin.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        dest - will hold the result
        Returns:
        dest

      • getRow

        Vector2d getRow​(int row,
                Vector2d dest)
         throws java.lang.IndexOutOfBoundsException
        Get the row at the given row index, starting with 0.
        Parameters:
        row - the row index in [0..1]
        dest - will hold the row components
        Returns:
        the passed in destination
        Throws:
        java.lang.IndexOutOfBoundsException - if row is not in [0..1]

      • getColumn

        Vector2d getColumn​(int column,
                   Vector2d dest)
            throws java.lang.IndexOutOfBoundsException
        Get the column at the given column index, starting with 0.
        Parameters:
        column - the column index in [0..1]
        dest - will hold the column components
        Returns:
        the passed in destination
        Throws:
        java.lang.IndexOutOfBoundsException - if column is not in [0..1]

      • get

        double get​(int column,
           int row)
        Get the matrix element value at the given column and row.
        Parameters:
        column - the colum index in [0..1]
        row - the row index in [0..1]
        Returns:
        the element value

      • normal

        Matrix2d normal​(Matrix2d dest)
        Compute a normal matrix from this matrix and store it into dest.
        Parameters:
        dest - will hold the result
        Returns:
        dest

      • getScale

        Vector2d getScale​(Vector2d dest)
        Get the scaling factors of this matrix for the three base axes.
        Parameters:
        dest - will hold the scaling factors for x and y
        Returns:
        dest

      • positiveX

        Vector2d positiveX​(Vector2d dest)
        Obtain the direction of +X before the transformation represented by this matrix is applied.

        This method is equivalent to the following code: 

         Matrix2d inv = new Matrix2d(this).invert();
 inv.transform(dir.set(1, 0)).normalize();
        If this is already an orthogonal matrix, then consider using normalizedPositiveX(Vector2d) instead.
        Parameters:
        dest - will hold the direction of +X
        Returns:
        dest

      • normalizedPositiveX

        Vector2d normalizedPositiveX​(Vector2d dest)
        Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.

        This method is equivalent to the following code: 

         Matrix2d inv = new Matrix2d(this).transpose();
 inv.transform(dir.set(1, 0));
        Parameters:
        dest - will hold the direction of +X
        Returns:
        dest

      • positiveY

        Vector2d positiveY​(Vector2d dest)
        Obtain the direction of +Y before the transformation represented by this matrix is applied.

        This method is equivalent to the following code: 

         Matrix2d inv = new Matrix2d(this).invert();
 inv.transform(dir.set(0, 1)).normalize();
        If this is already an orthogonal matrix, then consider using normalizedPositiveY(Vector2d) instead.
        Parameters:
        dest - will hold the direction of +Y
        Returns:
        dest

      • normalizedPositiveY

        Vector2d normalizedPositiveY​(Vector2d dest)
        Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.

        This method is equivalent to the following code: 

         Matrix2d inv = new Matrix2d(this).transpose();
 inv.transform(dir.set(0, 1));
        Parameters:
        dest - will hold the direction of +Y
        Returns:
        dest

      • add

        Matrix2d add​(Matrix2dc other,
             Matrix2d dest)
        Component-wise add this and other and store the result in dest.
        Parameters:
        other - the other addend
        dest - will hold the result
        Returns:
        dest

      • sub

        Matrix2d sub​(Matrix2dc subtrahend,
             Matrix2d dest)
        Component-wise subtract subtrahend from this and store the result in dest.
        Parameters:
        subtrahend - the subtrahend
        dest - will hold the result
        Returns:
        dest

      • mulComponentWise

        Matrix2d mulComponentWise​(Matrix2dc other,
                          Matrix2d dest)
        Component-wise multiply this by other and store the result in dest.
        Parameters:
        other - the other matrix
        dest - will hold the result
        Returns:
        dest

      • lerp

        Matrix2d lerp​(Matrix2dc other,
              double t,
              Matrix2d dest)
        Linearly interpolate this and other using the given interpolation factor t and store the result in dest.

        If t is 0.0 then the result is this. If the interpolation factor is 1.0 then the result is other.

        Parameters:
        other - the other matrix
        t - the interpolation factor between 0.0 and 1.0
        dest - will hold the result
        Returns:
        dest

      • equals

        boolean equals​(Matrix2dc m,
               double delta)
        Compare the matrix elements of this matrix with the given matrix using the given delta and return whether all of them are equal within a maximum difference of delta.

        Please note that this method is not used by any data structure such as ArrayList HashSet or HashMap and their operations, such as ArrayList.contains(Object) or HashSet.remove(Object), since those data structures only use the Object.equals(Object) and Object.hashCode() methods.

        Parameters:
        m - the other matrix
        delta - the allowed maximum difference
        Returns:
        true whether all of the matrix elements are equal; false otherwise

      • isFinite

        boolean isFinite()
        Determine whether all matrix elements are finite floating-point values, that is, they are not NaN and not infinity.
        Returns:
        true if all components are finite floating-point values; false otherwise