/**
* <p>Performs the following operation:<br>
* <br>
* c = α * a * b <br>
* <br>
* c<sub>ij</sub> = α ∑<sub>k=1:n</sub> { * a<sub>ik</sub> * b<sub>kj</sub>}
* </p>
*
* @param realAlpha real component of scaling factor.
* @param imgAlpha imaginary component of scaling factor.
* @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 mult(double realAlpha, double imgAlpha, ZMatrixRMaj a, ZMatrixRMaj b, ZMatrixRMaj c)
{
if (b.numCols >= EjmlParameters.CMULT_COLUMN_SWITCH)
{
MatrixMatrixMult_ZDRM.mult_reorder(realAlpha, imgAlpha, a, b, c);
}
else
{
MatrixMatrixMult_ZDRM.mult_small(realAlpha, imgAlpha, a, b, c);
}
}
/**
* <p>
* Sets each element in the matrix to a value drawn from an uniform distribution from 0 to 1 inclusive.
* </p>
*
* @param mat The matrix who is to be randomized. Modified.
* @param rand Random number generator used to fill the matrix.
*/
public static void fillUniform(ZMatrixRMaj mat, IMersenneTwister rand)
{
fillUniform(mat, 0, 1, rand);
}
/**
* <p>Performs element by element division operation with a complex number on the right<br>
* <br>
* output<sub>ij</sub> = (real + imaginary*i) / input<sub>ij</sub> <br>
* </p>
*
* @param real Real component of the number it is multiplied by
* @param imaginary Imaginary component of the number it is multiplied by
* @param input The right matrix in the multiplication operation. Not modified.
* @param output Where the results of the operation are stored. Modified.
*/
public static ZMatrixRMaj elementDivide(double real, double imaginary, ZMatrixD1 input, ZMatrixRMaj output)
{
output = UtilEjml.reshapeOrDeclare(output, input.numRows, input.numCols);
int N = input.DataLength;
for (int i = 0; i < N; i += 2)
{
double inReal = input.data[i];
double inImag = input.data[i + 1];
double norm = inReal * inReal + inImag * inImag;
output.data[i] = (real * inReal + imaginary * inImag) / norm;
output.data[i + 1] = (imaginary * inReal - real * inImag) / norm;
}
return(output);
}
public override /**/ double quality()
{
return(SpecializedOps_ZDRM.qualityTriangular(QR));
}
/**
* 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 writen to. Modified.
*/
//@Override
public override void solve(ZMatrixRMaj B, ZMatrixRMaj X)
{
if (X.numRows != numCols)
{
throw new ArgumentException("Unexpected dimensions for X");
}
else if (B.numRows != numRows || B.numCols != X.numCols)
{
throw new ArgumentException("Unexpected dimensions for B");
}
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[i * 2] = B.data[indexB];
a[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^H)*b = b - u*(gamma*U^H*b)
for (int n = 0; n < numCols; n++)
{
u[n * 2] = 1;
u[n * 2 + 1] = 0;
double realUb = a[2 * n];
double imagUb = a[2 * n + 1];
// U^H*b
for (int i = n + 1; i < numRows; i++)
{
int indexQR = (i * QR.numCols + n) * 2;
double realU = u[i * 2] = QR.data[indexQR];
double imagU = u[i * 2 + 1] = QR.data[indexQR + 1];
double realB = a[i * 2];
double imagB = a[i * 2 + 1];
realUb += realU * realB + imagU * imagB;
imagUb += realU * imagB - imagU * realB;
}
// gamma*U^H*b
realUb *= gammas[n];
imagUb *= gammas[n];
for (int i = n; i < numRows; i++)
{
double realU = u[i * 2];
double imagU = u[i * 2 + 1];
a[i * 2] -= realU * realUb - imagU * imagUb;
a[i * 2 + 1] -= realU * imagUb + imagU * realUb;
}
}
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_ZDRM.solveU(QR.data, a, numCols);
// save the results
for (int i = 0; i < numCols; i++)
{
int indexX = (i * X.numCols + colB) * 2;
X.data[indexX] = a[i * 2];
X.data[indexX + 1] = a[i * 2 + 1];
}
}
}
/**
* <p>
* Performs the following operation:<br>
* <br>
* c = c + α * a<sup>H</sup> * b<sup>H</sup><br>
* c<sub>ij</sub> = c<sub>ij</sub> + α * ∑<sub>k=1:n</sub> { a<sub>ki</sub> * b<sub>jk</sub>}
* </p>
*
* @param realAlpha Real component of scaling factor.
* @param imagAlpha Imaginary component of scaling factor.
* @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 multAddTransAB(double realAlpha, double imagAlpha, ZMatrixRMaj a, ZMatrixRMaj b,
ZMatrixRMaj c)
{
// TODO add a matrix vectory multiply here
if (a.numCols >= EjmlParameters.CMULT_TRANAB_COLUMN_SWITCH)
{
MatrixMatrixMult_ZDRM.multAddTransAB_aux(realAlpha, imagAlpha, a, b, c, null);
}
else
{
MatrixMatrixMult_ZDRM.multAddTransAB(realAlpha, imagAlpha, a, b, c);
}
}
/**
* <p>
* Performs the following operation:<br>
* <br>
* c = c + α * a * b<sup>H</sup><br>
* c<sub>ij</sub> = c<sub>ij</sub> + α * ∑<sub>k=1:n</sub> { a<sub>ik</sub> * b<sub>jk</sub>}
* </p>
*
* @param realAlpha Real component of scaling factor.
* @param imagAlpha Imaginary component of scaling factor.
* @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(double realAlpha, double imagAlpha, ZMatrixRMaj a, ZMatrixRMaj b,
ZMatrixRMaj c)
{
// TODO add a matrix vectory multiply here
MatrixMatrixMult_ZDRM.multAddTransB(realAlpha, imagAlpha, a, b, c);
}
/**
* <p>
* Performs the following operation:<br>
* <br>
* c = c + a * b<sup>H</sup> <br>
* c<sub>ij</sub> = 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(ZMatrixRMaj a, ZMatrixRMaj b, ZMatrixRMaj c)
{
MatrixMatrixMult_ZDRM.multAddTransB(a, b, c);
}
/**
* <p>
* Performs the following operation:<br>
* <br>
* c = c + α * a<sup>H</sup> * b<br>
* c<sub>ij</sub> =c<sub>ij</sub> + α * ∑<sub>k=1:n</sub> { a<sub>ki</sub> * b<sub>kj</sub>}
* </p>
*
* @param realAlpha Real component of scaling factor.
* @param imagAlpha Imaginary component of scaling factor.
* @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 multAddTransA(double realAlpha, double imagAlpha, ZMatrixRMaj a, ZMatrixRMaj b,
ZMatrixRMaj c)
{
// TODO add a matrix vectory multiply here
if (a.numCols >= EjmlParameters.CMULT_COLUMN_SWITCH ||
b.numCols >= EjmlParameters.CMULT_COLUMN_SWITCH)
{
MatrixMatrixMult_ZDRM.multAddTransA_reorder(realAlpha, imagAlpha, a, b, c);
}
else
{
MatrixMatrixMult_ZDRM.multAddTransA_small(realAlpha, imagAlpha, a, b, c);
}
}
