/** * <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(DMatrix2x2 a, DMatrix2x2 b, DMatrix2x2 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(DMatrix2x2 a, double v) { a.a11 = v; a.a12 = v; a.a21 = v; a.a22 = v; }
/** * <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(DMatrix2x2 a) { a.a11 = -a.a11; a.a12 = -a.a12; a.a21 = -a.a21; a.a22 = -a.a22; }
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> * 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(DMatrix2x2 a, DMatrix2x2 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 add(DMatrix2x2 a, DMatrix2x2 b, DMatrix2x2 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 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(DMatrix2x2 a, DMatrix2x2 b) { a.a11 /= b.a11; a.a12 /= b.a12; a.a21 /= b.a21; 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(DMatrix2x2 a, DMatrix2x2 b) { a.a11 *= b.a11; a.a12 *= b.a12; a.a21 *= b.a21; a.a22 *= b.a22; }
/** * <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(DMatrix2x2 a, DMatrix2x2 b, DMatrix2x2 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(DMatrix2x2 a, DMatrix2x2 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 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(double alpha, DMatrix2x2 a) { a.a11 *= alpha; a.a12 *= alpha; a.a21 *= alpha; a.a22 *= alpha; }
/** * <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(DMatrix2x2 a, double alpha) { a.a11 /= alpha; a.a12 /= alpha; a.a21 /= alpha; a.a22 /= alpha; }
/** * <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(double alpha, DMatrix2x2 a, DMatrix2x2 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(DMatrix2x2 a) { a.a11 = 1; a.a21 = 0; a.a12 = 0; a.a22 = 1; }
/** * <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(DMatrix2x2 a, double alpha, DMatrix2x2 b) { b.a11 = a.a11 / alpha; b.a12 = a.a12 / alpha; b.a21 = a.a21 / alpha; b.a22 = a.a22 / alpha; }
/** * <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(DMatrix2x2 a, DMatrix2x2 b, DMatrix2x2 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 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(DMatrix2x2 a, DMatrix2x2 b, DMatrix2x2 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(DMatrix2x2 a, DMatrix2x2 b, DMatrix2x2 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; }
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; }
/** * 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(DMatrix2x2 m) { double tmp; tmp = m.a12; m.a12 = m.a21; m.a21 = tmp; }
public static double fastNormF(DMatrix2x2 M) { double sum = 0; sum += M.a11 * M.a11 + M.a12 * M.a12; sum += M.a21 * M.a21 + M.a22 * M.a22; return(Math.Sqrt(sum)); }
public static bool hasUncountable(DMatrix2x2 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 DMatrix2x2 transpose(DMatrix2x2 input, DMatrix2x2 output) { if (input == null) { input = new DMatrix2x2(); } output.a11 = input.a11; output.a12 = input.a21; output.a21 = input.a12; output.a22 = input.a22; return(output); }
/** * Converts {@link DMatrix2x2} into {@link DMatrixRMaj}. * * @param input Input matrix. * @param output Output matrix. If null a new matrix will be declared. * @return Converted matrix. */ public static DMatrixRMaj convert(DMatrix2x2 input, DMatrixRMaj output) { if (output == null) { output = new DMatrixRMaj(2, 2); } output.reshape(input.NumRows, input.NumCols); output.data[0] = input.a11; output.data[1] = input.a12; output.data[2] = input.a21; output.data[3] = input.a22; return(output); }
/** * <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 double elementMin(DMatrix2x2 a) { double 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); }
/** * <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 double elementMax(DMatrix2x2 a) { double 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); }
public static double normF(DMatrix2x2 M) { double scale = CommonOps_DDF2.elementMaxAbs(M); if (scale == 0.0) { return(0.0); } double a11 = M.a11 / scale, a12 = M.a12 / scale; double a21 = M.a21 / scale, a22 = M.a22 / scale; double sum = 0; sum += a11 * a11 + a12 * a12; sum += a21 * a21 + a22 * a22; return(scale * Math.Sqrt(sum)); }
public static bool isIdentical(DMatrix2x2 a, DMatrix2x2 b, double tol) { if (!MatrixFeatures_DDRM.isIdentical(a.a11, b.a11, tol)) { return(false); } if (!MatrixFeatures_DDRM.isIdentical(a.a12, b.a12, tol)) { return(false); } if (!MatrixFeatures_DDRM.isIdentical(a.a21, b.a21, tol)) { return(false); } if (!MatrixFeatures_DDRM.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 double elementMaxAbs(DMatrix2x2 a) { double max = Math.Abs(a.a11); double 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 double elementMinAbs(DMatrix2x2 a) { double min = Math.Abs(a.a11); double 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); }