/**
* <p>Performs the following operation:<br>
* <br>
* a = a - b <br>
* a<sub>ij</sub> = a<sub>ij</sub> - b<sub>ij</sub> <br>
* </p>
*
* @param a A Matrix. Modified.
* @param b A Matrix. Not modified.
*/
public static void subtractEquals(FMatrix2x2 a, FMatrix2x2 b)
{
a.a11 -= b.a11;
a.a12 -= b.a12;
a.a21 -= b.a21;
a.a22 -= b.a22;
}
/**
* <p>Performs the following operation:<br>
* <br>
* c = a - b <br>
* c<sub>ij</sub> = a<sub>ij</sub> - b<sub>ij</sub> <br>
* </p>
*
* <p>
* Matrix C can be the same instance as Matrix A and/or B.
* </p>
*
* @param a A Matrix. Not modified.
* @param b A Matrix. Not modified.
* @param c A Matrix where the results are stored. Modified.
*/
public static void subtract(FMatrix2x2 a, FMatrix2x2 b, FMatrix2x2 c)
{
c.a11 = a.a11 - b.a11;
c.a12 = a.a12 - b.a12;
c.a21 = a.a21 - b.a21;
c.a22 = a.a22 - b.a22;
}
/**
* <p>Performs an element by element multiplication operation:<br>
* <br>
* a<sub>ij</sub> = a<sub>ij</sub> * b<sub>ij</sub> <br>
* </p>
* @param a The left matrix in the multiplication operation. Modified.
* @param b The right matrix in the multiplication operation. Not modified.
*/
public static void elementMult(FMatrix2x2 a, FMatrix2x2 b)
{
a.a11 *= b.a11;
a.a12 *= b.a12;
a.a21 *= b.a21;
a.a22 *= b.a22;
}
/**
* <p>
* Changes the sign of every element in the matrix.<br>
* <br>
* a<sub>ij</sub> = -a<sub>ij</sub>
* </p>
*
* @param a A matrix. Modified.
*/
public static void changeSign(FMatrix2x2 a)
{
a.a11 = -a.a11;
a.a12 = -a.a12;
a.a21 = -a.a21;
a.a22 = -a.a22;
}
/**
* <p>
* Performs an element by element scalar multiplication.<br>
* <br>
* b<sub>ij</sub> = α*a<sub>ij</sub>
* </p>
*
* @param alpha the amount each element is multiplied by.
* @param a The matrix that is to be scaled. Not modified.
* @param b Where the scaled matrix is stored. Modified.
*/
public static void scale(float alpha, FMatrix2x2 a, FMatrix2x2 b)
{
b.a11 = a.a11 * alpha;
b.a12 = a.a12 * alpha;
b.a21 = a.a21 * alpha;
b.a22 = a.a22 * alpha;
}
/**
* <p>Performs an element by element division operation:<br>
* <br>
* c<sub>ij</sub> = a<sub>ij</sub> / b<sub>ij</sub> <br>
* </p>
* @param a The left matrix in the division operation. Not modified.
* @param b The right matrix in the division operation. Not modified.
* @param c Where the results of the operation are stored. Modified.
*/
public static void elementDiv(FMatrix2x2 a, FMatrix2x2 b, FMatrix2x2 c)
{
c.a11 = a.a11 / b.a11;
c.a12 = a.a12 / b.a12;
c.a21 = a.a21 / b.a21;
c.a22 = a.a22 / b.a22;
}
/**
* <p>
* Sets every element in the matrix to the specified value.<br>
* <br>
* a<sub>ij</sub> = value
* <p>
*
* @param a A matrix whose elements are about to be set. Modified.
* @param v The value each element will have.
*/
public static void fill(FMatrix2x2 a, float v)
{
a.a11 = v;
a.a12 = v;
a.a21 = v;
a.a22 = v;
}
/**
* <p>Performs an element by element multiplication operation:<br>
* <br>
* c<sub>ij</sub> = a<sub>ij</sub> * b<sub>ij</sub> <br>
* </p>
* @param a The left matrix in the multiplication operation. Not modified.
* @param b The right matrix in the multiplication operation. Not modified.
* @param c Where the results of the operation are stored. Modified.
*/
public static void elementMult(FMatrix2x2 a, FMatrix2x2 b, FMatrix2x2 c)
{
c.a11 = a.a11 * b.a11;
c.a12 = a.a12 * b.a12;
c.a21 = a.a21 * b.a21;
c.a22 = a.a22 * b.a22;
}
/**
* <p>Performs the following operation:<br>
* <br>
* a = a + b <br>
* a<sub>ij</sub> = a<sub>ij</sub> + b<sub>ij</sub> <br>
* </p>
*
* @param a A Matrix. Modified.
* @param b A Matrix. Not modified.
*/
public static void addEquals(FMatrix2x2 a, FMatrix2x2 b)
{
a.a11 += b.a11;
a.a12 += b.a12;
a.a21 += b.a21;
a.a22 += b.a22;
}
/**
* <p>
* Performs an in-place element by element scalar division. Scalar denominator.<br>
* <br>
* a<sub>ij</sub> = a<sub>ij</sub>/α
* </p>
*
* @param a The matrix whose elements are to be divided. Modified.
* @param alpha the amount each element is divided by.
*/
public static void divide(FMatrix2x2 a, float alpha)
{
a.a11 /= alpha;
a.a12 /= alpha;
a.a21 /= alpha;
a.a22 /= alpha;
}
public static void convert(DMatrix2x2 src, FMatrix2x2 dst)
{
dst.a11 = (float)src.a11;
dst.a12 = (float)src.a12;
dst.a21 = (float)src.a21;
dst.a22 = (float)src.a22;
}
/**
* <p>
* Performs an element by element scalar division. Scalar denominator.<br>
* <br>
* b<sub>ij</sub> = a<sub>ij</sub> /α
* </p>
*
* @param alpha the amount each element is divided by.
* @param a The matrix whose elements are to be divided. Not modified.
* @param b Where the results are stored. Modified.
*/
public static void divide(FMatrix2x2 a, float alpha, FMatrix2x2 b)
{
b.a11 = a.a11 / alpha;
b.a12 = a.a12 / alpha;
b.a21 = a.a21 / alpha;
b.a22 = a.a22 / alpha;
}
/**
* Sets all the diagonal elements equal to one and everything else equal to zero.
* If this is a square matrix then it will be an identity matrix.
*
* @param a A matrix.
*/
public static void setIdentity(FMatrix2x2 a)
{
a.a11 = 1;
a.a21 = 0;
a.a12 = 0;
a.a22 = 1;
}
public static void convert(FMatrix2x2 src, DMatrix2x2 dst)
{
dst.a11 = src.a11;
dst.a12 = src.a12;
dst.a21 = src.a21;
dst.a22 = src.a22;
}
/**
* <p>
* Performs the following operation:<br>
* <br>
* c += a * b<sup>T</sup> <br>
* c<sub>ij</sub> += ∑<sub>k=1:n</sub> { a<sub>ik</sub> * b<sub>jk</sub>}
* </p>
*
* @param a The left matrix in the multiplication operation. Not modified.
* @param b The right matrix in the multiplication operation. Not modified.
* @param c Where the results of the operation are stored. Modified.
*/
public static void multAddTransB(FMatrix2x2 a, FMatrix2x2 b, FMatrix2x2 c)
{
c.a11 += a.a11 * b.a11 + a.a12 * b.a12;
c.a12 += a.a11 * b.a21 + a.a12 * b.a22;
c.a21 += a.a21 * b.a11 + a.a22 * b.a12;
c.a22 += a.a21 * b.a21 + a.a22 * b.a22;
}
/**
* <p>Performs the following operation:<br>
* <br>
* c = a + b <br>
* c<sub>ij</sub> = a<sub>ij</sub> + b<sub>ij</sub> <br>
* </p>
*
* <p>
* Matrix C can be the same instance as Matrix A and/or B.
* </p>
*
* @param a A Matrix. Not modified.
* @param b A Matrix. Not modified.
* @param c A Matrix where the results are stored. Modified.
*/
public static void add(FMatrix2x2 a, FMatrix2x2 b, FMatrix2x2 c)
{
c.a11 = a.a11 + b.a11;
c.a12 = a.a12 + b.a12;
c.a21 = a.a21 + b.a21;
c.a22 = a.a22 + b.a22;
}
/**
* <p>
* Performs the following operation:<br>
* <br>
* c = a * b<sup>T</sup> <br>
* c<sub>ij</sub> = ∑<sub>k=1:n</sub> { a<sub>ik</sub> * b<sub>jk</sub>}
* </p>
*
* @param a The left matrix in the multiplication operation. Not modified.
* @param b The right matrix in the multiplication operation. Not modified.
* @param c Where the results of the operation are stored. Modified.
*/
public static void multTransB(FMatrix2x2 a, FMatrix2x2 b, FMatrix2x2 c)
{
c.a11 = a.a11 * b.a11 + a.a12 * b.a12;
c.a12 = a.a11 * b.a21 + a.a12 * b.a22;
c.a21 = a.a21 * b.a11 + a.a22 * b.a12;
c.a22 = a.a21 * b.a21 + a.a22 * b.a22;
}
/**
* <p>
* Performs an in-place element by element scalar multiplication.<br>
* <br>
* a<sub>ij</sub> = α*a<sub>ij</sub>
* </p>
*
* @param a The matrix that is to be scaled. Modified.
* @param alpha the amount each element is multiplied by.
*/
public static void scale(float alpha, FMatrix2x2 a)
{
a.a11 *= alpha;
a.a12 *= alpha;
a.a21 *= alpha;
a.a22 *= alpha;
}
/**
* <p>Performs an element by element division operation:<br>
* <br>
* a<sub>ij</sub> = a<sub>ij</sub> / b<sub>ij</sub> <br>
* </p>
* @param a The left matrix in the division operation. Modified.
* @param b The right matrix in the division operation. Not modified.
*/
public static void elementDiv(FMatrix2x2 a, FMatrix2x2 b)
{
a.a11 /= b.a11;
a.a12 /= b.a12;
a.a21 /= b.a21;
a.a22 /= b.a22;
}
/**
* Performs an in-place transpose. This algorithm is only efficient for square
* matrices.
*
* @param m The matrix that is to be transposed. Modified.
*/
public static void transpose(FMatrix2x2 m)
{
float tmp;
tmp = m.a12;
m.a12 = m.a21;
m.a21 = tmp;
}
public static float fastNormF(FMatrix2x2 M)
{
float sum = 0;
sum += M.a11 * M.a11 + M.a12 * M.a12;
sum += M.a21 * M.a21 + M.a22 * M.a22;
return((float)Math.Sqrt(sum));
}
public static bool hasUncountable(FMatrix2x2 a)
{
if (UtilEjml.isUncountable(a.a11 + a.a12))
{
return(true);
}
if (UtilEjml.isUncountable(a.a21 + a.a22))
{
return(true);
}
return(false);
}
/**
* <p>
* Transposes matrix 'a' and stores the results in 'b':<br>
* <br>
* b<sub>ij</sub> = a<sub>ji</sub><br>
* where 'b' is the transpose of 'a'.
* </p>
*
* @param input The original matrix. Not modified.
* @param output Where the transpose is stored. If null a new matrix is created. Modified.
* @return The transposed matrix.
*/
public static FMatrix2x2 transpose(FMatrix2x2 input, FMatrix2x2 output)
{
if (input == null)
{
input = new FMatrix2x2();
}
output.a11 = input.a11;
output.a12 = input.a21;
output.a21 = input.a12;
output.a22 = input.a22;
return(output);
}
public static float normF(FMatrix2x2 M)
{
float scale = CommonOps_FDF2.elementMaxAbs(M);
if (scale == 0.0f)
{
return(0.0f);
}
float a11 = M.a11 / scale, a12 = M.a12 / scale;
float a21 = M.a21 / scale, a22 = M.a22 / scale;
float sum = 0;
sum += a11 * a11 + a12 * a12;
sum += a21 * a21 + a22 * a22;
return(scale * (float)Math.Sqrt(sum));
}
/**
* <p>
* Returns the value of the element in the matrix that has the largest value.<br>
* <br>
* Max{ a<sub>ij</sub> } for all i and j<br>
* </p>
*
* @param a A matrix. Not modified.
* @return The max element value of the matrix.
*/
public static float elementMax(FMatrix2x2 a)
{
float max = a.a11;
if (a.a12 > max)
{
max = a.a12;
}
if (a.a21 > max)
{
max = a.a21;
}
if (a.a22 > max)
{
max = a.a22;
}
return(max);
}
/**
* <p>
* Returns the value of the element in the matrix that has the minimum value.<br>
* <br>
* Min{ a<sub>ij</sub> } for all i and j<br>
* </p>
*
* @param a A matrix. Not modified.
* @return The value of element in the matrix with the minimum value.
*/
public static float elementMin(FMatrix2x2 a)
{
float min = a.a11;
if (a.a12 < min)
{
min = a.a12;
}
if (a.a21 < min)
{
min = a.a21;
}
if (a.a22 < min)
{
min = a.a22;
}
return(min);
}
public static bool isIdentical(FMatrix2x2 a, FMatrix2x2 b, float tol)
{
if (!MatrixFeatures_FDRM.isIdentical(a.a11, b.a11, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a12, b.a12, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a21, b.a21, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a22, b.a22, tol))
{
return(false);
}
return(true);
}
/**
* <p>
* Returns the absolute value of the element in the matrix that has the largest absolute value.<br>
* <br>
* Max{ |a<sub>ij</sub>| } for all i and j<br>
* </p>
*
* @param a A matrix. Not modified.
* @return The max abs element value of the matrix.
*/
public static float elementMaxAbs(FMatrix2x2 a)
{
float max = Math.Abs(a.a11);
float tmp = Math.Abs(a.a12);
if (tmp > max)
{
max = tmp;
}
tmp = Math.Abs(a.a21);
if (tmp > max)
{
max = tmp;
}
tmp = Math.Abs(a.a22);
if (tmp > max)
{
max = tmp;
}
return(max);
}
/**
* <p>
* Returns the absolute value of the element in the matrix that has the smallest absolute value.<br>
* <br>
* Min{ |a<sub>ij</sub>| } for all i and j<br>
* </p>
*
* @param a A matrix. Not modified.
* @return The max element value of the matrix.
*/
public static float elementMinAbs(FMatrix2x2 a)
{
float min = Math.Abs(a.a11);
float tmp = Math.Abs(a.a12);
if (tmp < min)
{
min = tmp;
}
tmp = Math.Abs(a.a21);
if (tmp < min)
{
min = tmp;
}
tmp = Math.Abs(a.a22);
if (tmp < min)
{
min = tmp;
}
return(min);
}
/**
* Converts {@link FMatrix2x2} into {@link FMatrixRMaj}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FMatrixRMaj convert(FMatrix2x2 input, FMatrixRMaj output)
{
if (output == null)
{
output = new FMatrixRMaj(2, 2);
}
if (input.getNumRows() != output.getNumRows())
{
throw new ArgumentException("Number of rows do not match");
}
if (input.getNumCols() != output.getNumCols())
{
throw new ArgumentException("Number of columns do not match");
}
output.data[0] = input.a11;
output.data[1] = input.a12;
output.data[2] = input.a21;
output.data[3] = input.a22;
return(output);
}
