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))); }