/// <summary>Frobenius norm</summary>
/// <returns> sqrt of sum of squares of all elements.
/// </returns>
public virtual double NormF()
{
double f = 0;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
f = Maths.Hypot(f, A[i][j]);
}
}
return(f);
}
/// <summary>QR Decomposition, computed by Householder reflections.</summary>
/// <param name="A"> Rectangular matrix
/// </param>
/// <returns> Structure to access R and the Householder vectors and compute Q.
/// </returns>
public QRDecomposition(GeneralMatrix A)
{
// Initialize.
QR = A.ArrayCopy;
m = A.RowDimension;
n = A.ColumnDimension;
Rdiag = new double[n];
// Main loop.
for (int k = 0; k < n; k++)
{
// Compute 2-norm of k-th column without under/overflow.
double nrm = 0;
for (int i = k; i < m; i++)
{
nrm = Maths.Hypot(nrm, QR[i][k]);
}
if (nrm != 0.0)
{
// Form k-th Householder vector.
if (QR[k][k] < 0)
{
nrm = -nrm;
}
for (int i = k; i < m; i++)
{
QR[i][k] /= nrm;
}
QR[k][k] += 1.0;
// Apply transformation to remaining columns.
for (int j = k + 1; j < n; j++)
{
double s = 0.0;
for (int i = k; i < m; i++)
{
s += QR[i][k] * QR[i][j];
}
s = (-s) / QR[k][k];
for (int i = k; i < m; i++)
{
QR[i][j] += s * QR[i][k];
}
}
}
Rdiag[k] = -nrm;
}
}
// Symmetric tridiagonal QL algorithm.
private void tql2()
{
// This is derived from the Algol procedures tql2, by
// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
// Fortran subroutine in EISPACK.
for (int i = 1; i < n; i++)
{
e[i - 1] = e[i];
}
e[n - 1] = 0.0;
double f = 0.0;
double tst1 = 0.0;
double eps = System.Math.Pow(2.0, -52.0);
for (int l = 0; l < n; l++)
{
// Find small subdiagonal element
tst1 = System.Math.Max(tst1, System.Math.Abs(d[l]) + System.Math.Abs(e[l]));
int m = l;
while (m < n)
{
if (System.Math.Abs(e[m]) <= eps * tst1)
{
break;
}
m++;
}
// If m == l, d[l] is an eigenvalue,
// otherwise, iterate.
if (m > l)
{
int iter = 0;
do
{
iter = iter + 1; // (Could check iteration count here.)
// Compute implicit shift
double g = d[l];
double p = (d[l + 1] - g) / (2.0 * e[l]);
double r = Maths.Hypot(p, 1.0);
if (p < 0)
{
r = -r;
}
d[l] = e[l] / (p + r);
d[l + 1] = e[l] * (p + r);
double dl1 = d[l + 1];
double h = g - d[l];
for (int i = l + 2; i < n; i++)
{
d[i] -= h;
}
f = f + h;
// Implicit QL transformation.
p = d[m];
double c = 1.0;
double c2 = c;
double c3 = c;
double el1 = e[l + 1];
double s = 0.0;
double s2 = 0.0;
for (int i = m - 1; i >= l; i--)
{
c3 = c2;
c2 = c;
s2 = s;
g = c * e[i];
h = c * p;
r = Maths.Hypot(p, e[i]);
e[i + 1] = s * r;
s = e[i] / r;
c = p / r;
p = c * d[i] - s * g;
d[i + 1] = h + s * (c * g + s * d[i]);
// Accumulate transformation.
for (int k = 0; k < n; k++)
{
h = V[k][i + 1];
V[k][i + 1] = s * V[k][i] + c * h;
V[k][i] = c * V[k][i] - s * h;
}
}
p = (-s) * s2 * c3 * el1 * e[l] / dl1;
e[l] = s * p;
d[l] = c * p;
// Check for convergence.
}while (System.Math.Abs(e[l]) > eps * tst1);
}
d[l] = d[l] + f;
e[l] = 0.0;
}
// Sort eigenvalues and corresponding vectors.
for (int i = 0; i < n - 1; i++)
{
int k = i;
double p = d[i];
for (int j = i + 1; j < n; j++)
{
if (d[j] < p)
{
k = j;
p = d[j];
}
}
if (k != i)
{
d[k] = d[i];
d[i] = p;
for (int j = 0; j < n; j++)
{
p = V[j][i];
V[j][i] = V[j][k];
V[j][k] = p;
}
}
}
}
