Matrix2dc (JOML 1.9.17 API)

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 and 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`.
`ByteBuffer`	`get(ByteBuffer buffer)` Store this matrix in column-major order into the supplied `ByteBuffer` at the current buffer `position`.
`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.
`DoubleBuffer`	`get(DoubleBuffer buffer)` Store this matrix in column-major order into the supplied `DoubleBuffer` at the current buffer `position`.
`ByteBuffer`	`get(int index, ByteBuffer buffer)` Store this matrix in column-major order into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`DoubleBuffer`	`get(int index, DoubleBuffer buffer)` Store this matrix in column-major order into the supplied `DoubleBuffer` starting at the specified absolute buffer position/index.
`double`	`get(int column, int row)` Get the matrix element value at the given column and row.
`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`.
`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.
`ByteBuffer`	`getTransposed(ByteBuffer buffer)` Store the transpose of this matrix in column-major order into the supplied `ByteBuffer` at the current buffer `position`.
`DoubleBuffer`	`getTransposed(DoubleBuffer buffer)` Store the transpose of this matrix in column-major order into the supplied `DoubleBuffer` at the current buffer `position`.
`ByteBuffer`	`getTransposed(int index, ByteBuffer buffer)` Store the transpose of this matrix in column-major order into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`DoubleBuffer`	`getTransposed(int index, DoubleBuffer buffer)` Store the transpose of this matrix in column-major order into the supplied `DoubleBuffer` starting at the specified absolute buffer position/index.
`Matrix2d`	`invert(Matrix2d dest)` Invert the `this` matrix and store the result in `dest`.
`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
```
DoubleBuffer get(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
```
DoubleBuffer get(int index,
                 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
```
ByteBuffer get(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
```
ByteBuffer get(int index,
               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
  - getTransposed
```
DoubleBuffer getTransposed(DoubleBuffer buffer)
```
    Store the transpose of 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 getTransposed(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:
    
    getTransposed(int, DoubleBuffer)
  - getTransposed
```
DoubleBuffer getTransposed(int index,
                           DoubleBuffer buffer)
```
    Store the transpose of 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
  - getTransposed
```
ByteBuffer getTransposed(ByteBuffer buffer)
```
    Store the transpose of 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 getTransposed(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:
    
    getTransposed(int, ByteBuffer)
  - getTransposed
```
ByteBuffer getTransposed(int index,
                         ByteBuffer buffer)
```
    Store the transpose of 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
  - 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 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:
    
    IndexOutOfBoundsException - if row is not in [0..1]
  - getColumn
```
Vector2d getColumn(int column,
                   Vector2d dest)
            throws 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:
    
    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

Interface Matrix2dc

Method Summary

Method Detail

m00

m01

m10

m11

mul

mul

mulLocal

determinant

invert

transpose

get

get

get

getRotation

get

get

get

get

getTransposed

getTransposed

getTransposed

getTransposed

get

get

scale

scale

scale

scaleLocal

transform

transform

transform

transformTranspose

transformTranspose

transformTranspose

rotate

rotateLocal

getRow

getColumn

get

normal

getScale

positiveX

normalizedPositiveX

positiveY

normalizedPositiveY

add

sub

mulComponentWise

lerp

equals