public void QrDecompositionConstructorTest()
{
double[][] value =
{
new double[] { 2, -1, 0 },
new double[] { -1, 2, -1 },
new double[] { 0, -1, 2 }
};
var target = new JaggedQrDecomposition(value);
// Decomposition Identity
var Q = target.OrthogonalFactor;
var QQt = Matrix.Dot(Q, Q.Transpose());
Assert.IsTrue(Matrix.IsEqual(QQt, Jagged.Identity(3), 1e-6));
Assert.IsTrue(Matrix.IsEqual(value, target.Reverse(), 1e-6));
// Linear system solving
double[][] B = Matrix.ColumnVector(new double[] { 1, 2, 3 }).ToJagged();
double[][] expected = Matrix.ColumnVector(new double[] { 2.5, 4.0, 3.5 }).ToJagged();
double[][] actual = target.Solve(B);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0000000000001));
}
public void QrDecompositionConstructorTest2()
{
double[][] value =
{
new double[] { 1 },
new double[] { 2 },
new double[] { 3 }
};
var target = new JaggedQrDecomposition(value);
// Decomposition Identity
var Q = target.OrthogonalFactor;
var QQt = Matrix.Dot(Q.Transpose(), Q);
Assert.IsTrue(Matrix.IsEqual(QQt, Jagged.Identity(1), 1e-6));
double[][] reverse = target.Reverse();
Assert.IsTrue(Matrix.IsEqual(value, reverse, 1e-6));
// Linear system solving
double[][] B = Matrix.ColumnVector(new double[] { 4, 5, 6 }).ToJagged();
double[][] expected = Jagged.ColumnVector(new double[] { 2.285714285714286 });
double[][] actual = target.Solve(B);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0000000000001));
double[][] R = target.UpperTriangularFactor;
actual = value.Dot(R.Inverse());
Assert.IsTrue(Matrix.IsEqual(Q, actual, 0.0000000000001));
}
public void InverseTest1()
{
float[][] value = // positive-definite
{
new float[] { 2, -1, 0 },
new float[] { -1, 2, -1 },
new float[] { 0, -1, 2 }
};
var chol = new JaggedCholeskyDecompositionF(value, robust: false);
Assert.IsTrue(chol.IsPositiveDefinite);
float[][] L = chol.LeftTriangularFactor;
float[][] expected =
{
new float[] { 0.750f, 0.500f, 0.250f },
new float[] { 0.500f, 1.000f, 0.500f },
new float[] { 0.250f, 0.500f, 0.750f },
};
float[][] actual = chol.Inverse();
Assert.IsTrue(actual.IsEqual(expected, 1e-5f));
float[][] inv = chol.Solve(Jagged.Identity <float>(3));
Assert.IsTrue(inv.IsEqual(expected, 1e-5f));
}
public void full_decomposition()
{
double[][] value =
{
new double[] { 1 },
new double[] { 2 },
new double[] { 3 }
};
var target = new JaggedQrDecomposition(value, economy: false);
// Decomposition Identity
var Q = target.OrthogonalFactor;
var QtQ = Matrix.Dot(Q.Transpose(), Q);
Assert.IsTrue(Matrix.IsEqual(QtQ, Jagged.Identity(3), 1e-6));
double[][] reverse = target.Reverse();
Assert.IsTrue(Matrix.IsEqual(value, reverse, 1e-6));
// Linear system solving
double[][] B = Matrix.ColumnVector(new double[] { 4, 5, 6 }).ToJagged();
double[][] expected = Jagged.ColumnVector(new double[] { 2.285714285714286 });
double[][] actual = target.Solve(B);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0000000000001));
var QQt = Matrix.Dot(Q, Q.Transpose());
Assert.IsTrue(Matrix.IsEqual(QQt, Jagged.Identity(3), 1e-6));
}
/// <summary>
/// Initializes the model with initial values obtained
/// through a run of the K-Means clustering algorithm.
/// </summary>
///
public void Initialize(KMeans kmeans)
{
if (kmeans.K != Count)
{
throw new ArgumentException("The number of clusters does not match.", "kmeans");
}
// Initialize the Mixture Model with data from K-Means
var proportions = kmeans.Clusters.Proportions;
var distributions = new MultivariateNormalDistribution[Count];
for (int i = 0; i < Count; i++)
{
double[] mean = kmeans.Clusters.Centroids[i];
double[][] covariance = kmeans.Clusters.Covariances[i];
if (covariance == null || !covariance.IsPositiveDefinite())
{
covariance = Jagged.Identity(kmeans.Dimension);
}
distributions[i] = new MultivariateNormalDistribution(mean, covariance);
}
this.model = new MultivariateMixture <MultivariateNormalDistribution>(proportions, distributions);
}
private double[][] householder(double[] a)
{
double[] v = a.Divide((a[0] + Special.Sign(Norm.Euclidean(a), a[0])));
v[0] = 1;
var H = Jagged.Identity(a.Length);
var vr = Jagged.RowVector(v);
var vc = Jagged.ColumnVector(v);
var t = vc.Dot(vr);
H.Subtract((2 / v.Dot(v)).Multiply(t), result: H);
return(H);
}
private void decompose(ref double[][] a, out double[][] q)
{
int m = a.Rows();
int n = a.Columns();
q = Jagged.Identity(m);
for (int i = 0; i < n; i++)
{
var h = Jagged.Identity(m);
h.Set(i, 0, i, 0, householder(a.GetColumn(i).Get(i, 0)));
q = q.Dot(h);
a = h.Dot(a);
}
}
public void InverseTestNaN()
{
int n = 5;
var I = Jagged.Identity(n);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
double[][] value = Jagged.Magic(n);
value[i][j] = double.NaN;
var target = new JaggedQrDecomposition(value);
var solution = target.Solve(I);
var inverse = target.Inverse();
Assert.IsTrue(Matrix.IsEqual(solution, inverse));
}
}
}
public void InverseTest2()
{
int n = 5;
var I = Jagged.Identity(n);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
double[][] value = Jagged.Magic(n);
var target = new JaggedSingularValueDecomposition(value);
double[][] solution = target.Solve(I);
double[][] inverse = target.Inverse();
double[][] reverse = target.Reverse();
Assert.IsTrue(Matrix.IsEqual(solution, inverse, 1e-4));
Assert.IsTrue(Matrix.IsEqual(value, reverse, 1e-4));
}
}
}
public void InverseTest()
{
var value = new double[][]
{
new double[] { 1.0, 1.0 },
new double[] { 2.0, 2.0 }
};
var target = new JaggedSingularValueDecomposition(value);
var expected = new double[][]
{
new double[] { 0.1, 0.2 },
new double[] { 0.1, 0.2 }
};
var actual = target.Solve(Jagged.Identity(2));
Assert.IsTrue(Matrix.IsEqual(expected, actual, 1e-3));
Assert.IsTrue(Matrix.IsEqual(value, target.Reverse(), 1e-5));
actual = target.Inverse();
Assert.IsTrue(Matrix.IsEqual(expected, actual, 1e-3));
}
/// <summary>
/// Solves a set of equation systems of type <c>A * X = I</c>.
/// </summary>
///
public Double[][] Inverse()
{
return(Solve(Jagged.Identity <Double>(n)));
}
/// <summary>
/// Solves a set of equation systems of type <c>A * X = I</c>.
/// </summary>
///
public Decimal[][] Inverse()
{
return(Solve(Jagged.Identity <Decimal>(n)));
}
/// <summary>
/// Solves a set of equation systems of type <c>A * X = I</c>.
/// </summary>
///
public Single[][] Inverse()
{
return(Solve(Jagged.Identity <Single>(n)));
}
