public static bool lower4(DMatrix1Row A, DMatrix1Row L)
{
double[] data = A.data;
double a11 = data[0];
double a21 = data[4];
double a22 = data[5];
double a31 = data[8];
double a32 = data[9];
double a33 = data[10];
double a41 = data[12];
double a42 = data[13];
double a43 = data[14];
double a44 = data[15];
L.data[0] = a11 = Math.Sqrt(a11);
L.data[1] = 0;
L.data[2] = 0;
L.data[3] = 0;
L.data[4] = a21 = (a21) / a11;
L.data[5] = a22 = Math.Sqrt(a22 - a21 * a21);
L.data[6] = 0;
L.data[7] = 0;
L.data[8] = a31 = (a31) / a11;
L.data[9] = a32 = (a32 - a31 * a21) / a22;
L.data[10] = a33 = Math.Sqrt(a33 - a31 * a31 - a32 * a32);
L.data[11] = 0;
L.data[12] = a41 = (a41) / a11;
L.data[13] = a42 = (a42 - a41 * a21) / a22;
L.data[14] = a43 = (a43 - a41 * a31 - a42 * a32) / a33;
L.data[15] = Math.Sqrt(a44 - a41 * a41 - a42 * a42 - a43 * a43);
return(!UtilEjml.isUncountable(L.data[15]));
}
/**
* Converts DMatrixSparseTriplet into a DMatrixSparseCSC. Duplicate elements in triplet will result in an
* illegal matrix in output having duplicate elements.
*
* @param src Original matrix which is to be copied. Not modified.
* @param dst Destination. Will be a copy. Modified.
* @param histStorage Workspace. Can be null.
*/
public static DMatrixSparseCSC convert(DMatrixSparseTriplet src, DMatrixSparseCSC dst,
IGrowArray histStorage)
{
dst = UtilEjml.reshapeOrDeclare(dst, src.numRows, src.numCols, src.nz_length);
int[] hist = UtilEjml.adjustClear(histStorage, src.numCols);
// compute the number of elements in each columns
for (int i = 0; i < src.nz_length; i++)
{
hist[src.nz_rowcol.data[i * 2 + 1]]++;
}
// define col_idx
dst.histogramToStructure(hist);
System.Array.Copy(dst.col_idx, 0, hist, 0, dst.numCols);
// now write the row indexes and the values
for (int i = 0; i < src.nz_length; i++)
{
int row = src.nz_rowcol.data[i * 2];
int col = src.nz_rowcol.data[i * 2 + 1];
double value = src.nz_value.data[i];
int index = hist[col]++;
dst.nz_rows[index] = row;
dst.nz_values[index] = value;
}
dst.indicesSorted = false;
return(dst);
}
public static bool upper4(DMatrix1Row A, DMatrix1Row R)
{
double[] data = A.data;
double a11 = data[0];
double a12 = data[1];
double a22 = data[5];
double a13 = data[2];
double a23 = data[6];
double a33 = data[10];
double a14 = data[3];
double a24 = data[7];
double a34 = data[11];
double a44 = data[15];
R.data[0] = a11 = Math.Sqrt(a11);
R.data[4] = 0;
R.data[8] = 0;
R.data[12] = 0;
R.data[1] = a12 = (a12) / a11;
R.data[5] = a22 = Math.Sqrt(a22 - a12 * a12);
R.data[9] = 0;
R.data[13] = 0;
R.data[2] = a13 = (a13) / a11;
R.data[6] = a23 = (a23 - a12 * a13) / a22;
R.data[10] = a33 = Math.Sqrt(a33 - a13 * a13 - a23 * a23);
R.data[14] = 0;
R.data[3] = a14 = (a14) / a11;
R.data[7] = a24 = (a24 - a12 * a14) / a22;
R.data[11] = a34 = (a34 - a13 * a14 - a23 * a24) / a33;
R.data[15] = Math.Sqrt(a44 - a14 * a14 - a24 * a24 - a34 * a34);
return(!UtilEjml.isUncountable(R.data[15]));
}
//CONCURRENT_OMIT_END
/**
* @see CommonOps_DDRM#multTransB(double, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row)
*/
public static void multTransB(double alpha, DMatrix1Row A, DMatrix1Row B, DMatrix1Row C)
{
UtilEjml.assertTrue(A != C && B != C, "Neither 'A' or 'B' can be the same matrix as 'C'");
UtilEjml.assertShape(A.numCols, B.numCols, "The 'A' and 'B' matrices do not have compatible dimensions");
C.reshape(A.numRows, B.numRows);
//CONCURRENT_BELOW EjmlConcurrency.loopFor(0, A.numRows, xA -> {
for (int xA = 0; xA < A.numRows; xA++)
{
int cIndex = xA * B.numRows;
int aIndexStart = xA * B.numCols;
int end = aIndexStart + B.numCols;
int indexB = 0;
for (int xB = 0; xB < B.numRows; xB++)
{
int indexA = aIndexStart;
double total = 0;
while (indexA < end)
{
total += A.data[indexA++] * B.data[indexB++];
}
C.set(cIndex++, alpha * total);
}
}
//CONCURRENT_ABOVE });
}
//CONCURRENT_OMIT_BEGIN
/**
* @see CommonOps_DDRM#mult(double, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row)
*/
public static void mult_aux(double alpha, DMatrix1Row A, DMatrix1Row B, DMatrix1Row C, double[] aux)
{
UtilEjml.assertTrue(A != C && B != C, "Neither 'A' or 'B' can be the same matrix as 'C'");
UtilEjml.assertShape(A.numCols, B.numRows, "The 'A' and 'B' matrices do not have compatible dimensions");
C.reshape(A.numRows, B.numCols);
if (aux == null)
{
aux = new double[B.numRows];
}
for (int j = 0; j < B.numCols; j++)
{
// create a copy of the column in B to avoid cache issues
for (int k = 0; k < B.numRows; k++)
{
aux[k] = B.unsafe_get(k, j);
}
int indexA = 0;
for (int i = 0; i < A.numRows; i++)
{
double total = 0;
for (int k = 0; k < B.numRows;)
{
total += A.data[indexA++] * aux[k++];
}
C.set(i * C.numCols + j, alpha * total);
}
}
}
/**
* Randomly generates matrix with the specified number of non-zero elements filled with values from min to max.
*
* @param numRows Number of rows
* @param numCols Number of columns
* @param nz_total Total number of non-zero elements in the matrix
* @param min Minimum element value, inclusive
* @param max Maximum element value, inclusive
* @param rand Random number generator
* @return Randomly generated matrix
*/
public static DMatrixSparseCSC rectangle(int numRows, int numCols, int nz_total,
double min, double max, IMersenneTwister rand)
{
nz_total = Math.Min(numCols * numRows, nz_total);
int[] selected = UtilEjml.shuffled(numRows * numCols, nz_total, rand);
Array.Sort(selected, 0, nz_total);
DMatrixSparseCSC ret = new DMatrixSparseCSC(numRows, numCols, nz_total);
ret.indicesSorted = true;
// compute the number of elements in each column
int[] hist = new int[numCols];
for (int i = 0; i < nz_total; i++)
{
hist[selected[i] / numRows]++;
}
// define col_idx
ret.colsum(hist);
for (int i = 0; i < nz_total; i++)
{
int row = selected[i] % numRows;
ret.nz_rows[i] = row;
ret.nz_values[i] = rand.NextDouble() * (max - min) + min;
}
return(ret);
}
public static bool hasUncountable(DMatrix6 a)
{
if (UtilEjml.isUncountable(a.a1))
{
return(true);
}
if (UtilEjml.isUncountable(a.a2))
{
return(true);
}
if (UtilEjml.isUncountable(a.a3))
{
return(true);
}
if (UtilEjml.isUncountable(a.a4))
{
return(true);
}
if (UtilEjml.isUncountable(a.a5))
{
return(true);
}
if (UtilEjml.isUncountable(a.a6))
{
return(true);
}
return(false);
}
public static bool hasUncountable(DMatrix6x6 a)
{
if (UtilEjml.isUncountable(a.a11 + a.a12 + a.a13 + a.a14 + a.a15 + a.a16))
{
return(true);
}
if (UtilEjml.isUncountable(a.a21 + a.a22 + a.a23 + a.a24 + a.a25 + a.a26))
{
return(true);
}
if (UtilEjml.isUncountable(a.a31 + a.a32 + a.a33 + a.a34 + a.a35 + a.a36))
{
return(true);
}
if (UtilEjml.isUncountable(a.a41 + a.a42 + a.a43 + a.a44 + a.a45 + a.a46))
{
return(true);
}
if (UtilEjml.isUncountable(a.a51 + a.a52 + a.a53 + a.a54 + a.a55 + a.a56))
{
return(true);
}
if (UtilEjml.isUncountable(a.a61 + a.a62 + a.a63 + a.a64 + a.a65 + a.a66))
{
return(true);
}
return(false);
}
/**
* @see CommonOps_DDRM#multAdd(double, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row)
*/
public static void multAdd_small(double alpha, DMatrix1Row A, DMatrix1Row B, DMatrix1Row C)
{
UtilEjml.assertTrue(A != C && B != C, "Neither 'A' or 'B' can be the same matrix as 'C'");
UtilEjml.assertShape(A.numCols, B.numRows, "The 'A' and 'B' matrices do not have compatible dimensions");
UtilEjml.assertShape(A.numRows == C.numRows && B.numCols == C.numCols, "C is not compatible with A and B");
//CONCURRENT_BELOW EjmlConcurrency.loopFor(0, A.numRows, i -> {
for (int i = 0; i < A.numRows; i++)
{
int cIndex = i * B.numCols;
int aIndexStart = i * A.numCols;
for (int j = 0; j < B.numCols; j++)
{
double total = 0;
int indexA = aIndexStart;
int indexB = j;
int end = indexA + B.numRows;
while (indexA < end)
{
total += A.data[indexA++] * B.data[indexB];
indexB += B.numCols;
}
C.plus(cIndex++, alpha * total);
}
}
//CONCURRENT_ABOVE });
}
/**
* @see CommonOps_DDRM#multTransA(double, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row, org.ejml.data.DMatrix1Row)
*/
public static void multTransA_small(double alpha, DMatrix1Row A, DMatrix1Row B, DMatrix1Row C)
{
UtilEjml.assertTrue(A != C && B != C, "Neither 'A' or 'B' can be the same matrix as 'C'");
UtilEjml.assertShape(A.numRows, B.numRows, "The 'A' and 'B' matrices do not have compatible dimensions");
C.reshape(A.numCols, B.numCols);
//CONCURRENT_BELOW EjmlConcurrency.loopFor(0, A.numCols, i -> {
for (int i = 0; i < A.numCols; i++)
{
int cIndex = i * B.numCols;
for (int j = 0; j < B.numCols; j++)
{
int indexA = i;
int indexB = j;
int end = indexB + B.numRows * B.numCols;
double total = 0;
// loop for k
for (; indexB < end; indexB += B.numCols)
{
total += A.data[indexA] * B.data[indexB];
indexA += A.numCols;
}
C.set(cIndex++, alpha * total);
}
}
//CONCURRENT_ABOVE });
}
/**
* <p>
* Conjugate transposes input matrix 'a' and stores the results in output matrix 'b':<br>
* <br>
* b-real<sub>i,j</sub> = a-real<sub>j,i</sub><br>
* b-imaginary<sub>i,j</sub> = -1*a-imaginary<sub>j,i</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 ZMatrixRMaj transposeConjugate(ZMatrixRMaj input, ZMatrixRMaj output)
{
output = UtilEjml.reshapeOrDeclare(output, input.numCols, input.numRows);
TransposeAlgs_ZDRM.standardConjugate(input, output);
return(output);
}
public static bool lower1(DMatrix1Row A, DMatrix1Row L)
{
double[] data = A.data;
double a11 = data[0];
L.data[0] = Math.Sqrt(a11);
return(!UtilEjml.isUncountable(L.data[0]));
}
public static void elementDiv(DMatrixD1 A, DMatrixD1 B)
{
UtilEjml.checkSameShape(A, B, true);
int length = A.NumElements;
for (int i = 0; i < length; i++)
{
A.div(i, B.get(i));
}
}
public static bool hasUncountable(DMatrixSparseCSC A)
{
for (int i = 0; i < A.nz_length; i++)
{
if (UtilEjml.isUncountable(A.nz_values[i]))
{
return(true);
}
}
return(false);
}
public bool setA(T A)
{
if (alg.modifiesA())
{
this.A = (T)UtilEjml.reshapeOrDeclare(this.A, A);
this.A.To = A;
return(alg.setA(this.A));
}
return(alg.setA(A));
}
public void solve(T B, T X)
{
if (alg.modifiesB())
{
this.B = UtilEjml.reshapeOrDeclare(this.B, B);
this.B.To = B;
B = this.B;
}
alg.solve(B, X);
}
/**
* Places the imaginary component of the input matrix into the output matrix.
*
* @param input Complex matrix. Not modified.
* @param output real matrix. Modified.
*/
public static DMatrixRMaj stripImaginary(ZMatrixD1 input, DMatrixRMaj output)
{
output = UtilEjml.reshapeOrDeclare(output, input.numRows, input.numCols);
int length = input.DataLength;
for (int i = 1; i < length; i += 2)
{
output.data[i / 2] = input.data[i];
}
return(output);
}
/**
* <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(ZMatrixD1 a, ZMatrixD1 b, ZMatrixD1 c)
{
UtilEjml.checkSameShape(a, b, true);
c.reshape(a.numRows, b.numCols);
int length = a.DataLength;
for (int i = 0; i < length; i++)
{
c.data[i] = a.data[i] - b.data[i];
}
}
//@Override
public Complex_F64 computeDeterminant()
{
// see dense algorithm. There is probably a faster way to compute the sign while decomposing
// the matrix.
double value = UtilEjml.permutationSign(pinv, U.numCols, gw.data);
for (int i = 0; i < U.numCols; i++)
{
value *= U.nz_values[U.col_idx[i + 1] - 1];
}
return(new Complex_F64(value, 0));
}
public static bool hasUncountable(FMatrix2 a)
{
if (UtilEjml.isUncountable(a.a1))
{
return(true);
}
if (UtilEjml.isUncountable(a.a2))
{
return(true);
}
return(false);
}
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);
}
public static ZMatrixRMaj diag(ZMatrixRMaj output, int N, double[] data)
{
output = UtilEjml.reshapeOrDeclare(output, N, N);
int index = 0;
for (int i = 0; i < N; i++)
{
output.set(i, i, data[index++], data[index++]);
}
return(output);
}
override public /**/ double quality()
{
return(SpecializedOps_ZDRM.qualityTriangular(R));
}
/**
* Solves for X using the QR decomposition.
*
* @param B A matrix that is n by m. Not modified.
* @param X An n by m matrix where the solution is written to. Modified.
*/
override public void solve(ZMatrixRMaj B, ZMatrixRMaj X)
{
UtilEjml.checkReshapeSolve(numRows, numCols, B, X);
int BnumCols = B.numCols;
// solve each column one by one
for (int colB = 0; colB < BnumCols; colB++)
{
// make a copy of this column in the vector
for (int i = 0; i < numRows; i++)
{
int indexB = (i * BnumCols + colB) * 2;
a.data[i * 2] = B.data[indexB];
a.data[i * 2 + 1] = B.data[indexB + 1];
}
// Solve Qa=b
// a = Q'b
// a = Q_{n-1}...Q_2*Q_1*b
//
// Q_n*b = (I-gamma*u*u^T)*b = b - u*(gamma*U^T*b)
for (int n = 0; n < numCols; n++)
{
double[] u = QR[n];
double realVV = u[n * 2];
double imagVV = u[n * 2 + 1];
u[n * 2] = 1;
u[n * 2 + 1] = 0;
QrHelperFunctions_ZDRM.rank1UpdateMultR(a, u, 0, gammas[n], 0, n, numRows, temp.data);
u[n * 2] = realVV;
u[n * 2 + 1] = imagVV;
}
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_ZDRM.solveU(R.data, a.data, numCols);
// save the results
for (int i = 0; i < numCols; i++)
{
int indexB = (i * BnumCols + colB) * 2;
X.data[indexB] = a.data[i * 2];
X.data[indexB + 1] = a.data[i * 2 + 1];
}
}
}
/**
* <p>
* Computes the complex conjugate of the input matrix.<br>
* <br>
* real<sub>i,j</sub> = real<sub>i,j</sub><br>
* imaginary<sub>i,j</sub> = -1*imaginary<sub>i,j</sub><br>
* </p>
*
* @param input Input matrix. Not modified.
* @param output The complex conjugate of the input matrix. Modified.
*/
public static ZMatrixD1 conjugate(ZMatrixD1 input, ZMatrixRMaj output)
{
output = UtilEjml.reshapeOrDeclare(output, input.numRows, input.numCols);
int length = input.DataLength;
for (int i = 0; i < length; i += 2)
{
output.data[i] = input.data[i];
output.data[i + 1] = -input.data[i + 1];
}
return(output);
}
public static bool lower2(DMatrix1Row A, DMatrix1Row L)
{
double[] data = A.data;
double a11 = data[0];
double a21 = data[2];
double a22 = data[3];
L.data[0] = a11 = Math.Sqrt(a11);
L.data[1] = 0;
L.data[2] = a21 = (a21) / a11;
L.data[3] = Math.Sqrt(a22 - a21 * a21);
return(!UtilEjml.isUncountable(L.data[3]));
}
public static T elementExp <T>(T A, T output)
where T : DMatrixD1
{
output = UtilEjml.reshapeOrDeclare(output, A);
int size = A.NumElements;
for (int i = 0; i < size; i++)
{
output.data[i] = Math.Exp(A.data[i]);
}
return(output);
}
public static T elementPower <T>(double a, T B, T output)
where T : DMatrixD1
{
output = UtilEjml.reshapeOrDeclare(output, B);
int size = B.NumElements;
for (int i = 0; i < size; i++)
{
output.data[i] = Math.Pow(a, B.data[i]);
}
return(output);
}
public static T elementDiv <T>(T A, T B, T output) where T : DMatrixD1
{
UtilEjml.checkSameShape(A, B, true);
output = UtilEjml.reshapeOrDeclare(output, A);
int length = A.NumElements;
for (int i = 0; i < length; i++)
{
output.set(i, A.get(i) / B.get(i));
}
return(output);
}
public static bool upper2(DMatrix1Row A, DMatrix1Row R)
{
double[] data = A.data;
double a11 = data[0];
double a12 = data[1];
double a22 = data[3];
R.data[0] = a11 = Math.Sqrt(a11);
R.data[2] = 0;
R.data[1] = a12 = (a12) / a11;
R.data[3] = Math.Sqrt(a22 - a12 * a12);
return(!UtilEjml.isUncountable(R.data[3]));
}
/**
* <p>
* Computes the induced p = 2 matrix norm, which is the largest singular value.
* </p>
*
* @param A Matrix. Not modified.
* @return The norm.
*/
public static float inducedP2(FMatrixRMaj A)
{
SingularValueDecomposition_F32 <FMatrixRMaj> svd =
DecompositionFactory_FDRM.svd(A.numRows, A.numCols, false, false, true);
if (!svd.decompose(A))
{
throw new InvalidOperationException("Decomposition failed");
}
float[] singularValues = svd.getSingularValues();
// the largest singular value is the induced p2 norm
return(UtilEjml.max(singularValues, 0, singularValues.Length));
}
