public void ArrayConstructor_ShouldSucced() { VectorXD v = new VectorXD(new double[] { 1, 2, 5, 6 }); Assert.Equal(new double[] { 1, 2, 5, 6 }, v.GetValues().ToArray()); Assert.Equal("VectorXD, 4:\n\n1 2 5 6", v.ToString()); }
public void Dot_ShouldSucceed() { VectorXD A = new VectorXD(new double[] { 1, 2, 3, 4 }); VectorXD B = new VectorXD(new double[] { 1, 2, 3, 4 }); Assert.Equal(30.0, A.Dot(B)); }
public static SparseVectorD ToSparse(this VectorXD vector, double zeroTolerance = ZeroTolerance) { var elements = Enumerable.Range(0, vector.Length) .Zip(vector.GetValues().ToArray(), (index, value) => (index, value)).Where(x => Math.Abs(x.value) > zeroTolerance).ToArray(); return(new SparseVectorD(elements, vector.Length)); }
public void Scale_ShouldSucceed() { VectorXD A = new VectorXD(Enumerable.Range(1, 4).Select(n => (double)n).ToArray()); var scaledVector = A.Scale(2.0); Assert.Equal(new VectorXD(new double[] { 2, 4, 6, 8 }), scaledVector); }
public void ScaleInplace_ShouldSucceed() { var A = new VectorXD(Enumerable.Range(1, 4).Select(n => (double)n).ToArray()); A.ScaleInplace(2.0); Assert.Equal(new VectorXD(new double[] { 2, 4, 6, 8 }), A); }
public void Random_ShouldSucceed() { VectorXD A = VectorXD.Random(10); Assert.True(A.Max() <= 1.0); Assert.True(A.Min() >= 0.0); Assert.Equal(10, A.Length); }
public void Count_ShouldSucceed() { var A = new VectorXD(new double[] { 1, 3, -1, 0, double.PositiveInfinity, -1 }).ToSparse(); Assert.Equal(1, A.Count(x => x == 0)); Assert.Equal(2, A.Count(x => x == -1)); Assert.Equal(1, A.Count(x => double.IsInfinity(x))); }
public void Add_ShouldSucceed() { VectorXD A = new VectorXD(new double[] { 1, 2, 3, 4 }); VectorXD B = new VectorXD(new double[] { 1, 2, 3, 4 }); var addVector = A.Add(B); Assert.Equal(new VectorXD(new double[] { 2, 4, 6, 8 }), addVector); }
public void SolveColPivHouseholderQr_ShouldSucceed() { var A = new MatrixXD("1 2 3; 4 5 6; 7 8 10"); var rhs = new VectorXD("3 3 4"); VectorXD result = A.Solve(rhs, DenseSolverType.ColPivHouseholderQR); Assert.Equal(new VectorXD("-2 1 1"), result); }
public void SolveLDLT_ShouldSucceed() { var A = new MatrixXD("2 4 0;4 2 1;0 1 4"); var rhs = new VectorXD("3 3 4"); VectorXD result = A.Solve(rhs, DenseSolverType.LDLT); Assert.Equal(new VectorXD("0.22 0.64 0.84"), result); }
public void Minus_ShouldSucceed() { var A = new VectorXD(new double[] { 1, 2, 3, 4 }); var B = new VectorXD(new double[] { 1, 2, 3, 4 }); var addVector = A.Minus(B); Assert.Equal(new VectorXD(new double[] { 0, 0, 0, 0 }), addVector); }
public void LeastSquaresNE_ShouldSucceed() { var A = new MatrixXD("-1 -0.0827; -0.737 0.0655; 0.511 -0.562 "); var rhs = new VectorXD("-0.906 0.358 0.359"); VectorXD result = A.LeastSquaresNE(rhs); Assert.Equal(new VectorXD("0.46347421844577846 0.04209165616389611"), result); }
public IterativeSolverResult(VectorXD result, int interations, double error, IterativeSolverType solver, bool success) { Result = result; Interations = interations; Error = error; Solver = solver; Success = success; }
public void RelativeError_ShouldSucceed() { var A = new MatrixXD("1 2 3; 4 5 6; 7 8 10"); var rhs = new VectorXD("3 3 4"); var x = new VectorXD("-2 1 1"); Assert.Equal(0.0, A.RelativeError(rhs, x), DoublePrecision); }
public void Count_ShouldSucceed() { var A = new VectorXD(new double[] { 1, 3, double.NaN, 0, double.PositiveInfinity, double.NaN }); Assert.Equal(1, A.Count(x => x == 0)); Assert.Equal(2, A.Count(x => double.IsNaN(x))); Assert.Equal(1, A.Count(x => double.IsInfinity(x))); }
public void SolvePartialPivLU_ShouldSucceed() { var A = new MatrixXD("1 2 1; 2 1 0 ; -1 1 2"); var rhs = new VectorXD("3 3 4"); VectorXD result = A.Solve(rhs, DenseSolverType.PartialPivLU); Assert.Equal(new VectorXD("2.3333333333333321 -1.6666666666666643 3.9999999999999978"), result); }
public void SolveLLT_ShouldSucceed() { var A = new MatrixXD("6 4 0;4 4 1;0 1 8"); var rhs = new VectorXD("3 3 4"); VectorXD result = A.Solve(rhs, DenseSolverType.LLT); Assert.Equal(new VectorXD("0.22413793103448287 0.41379310344827569 0.44827586206896558"), result); }
public void Zeros_ShouldSucceed() { VectorXD v = VectorXD.Zeros(4); Assert.True(v.Max() <= 0.0); Assert.True(v.Min() >= 0.0); Assert.Equal(4, v.Length); Assert.Equal(new VectorXD(new[] { 0.0, 0.0, 0.0, 0.0 }), v); }
public void Ones_ShouldSucceed() { VectorXD v = VectorXD.Ones(4); Assert.True(v.Max() <= 1.0); Assert.True(v.Min() >= 1.0); Assert.Equal(4, v.Length); Assert.Equal(new VectorXD(new[] { 1.0, 1.0, 1.0, 1.0 }), v); }
public void Linspace_ShouldSucceed() { VectorXD v = VectorXD.Linespace(1, 10, 10); Assert.Equal(10.0, v.Max()); Assert.Equal(1.0, v.Min()); Assert.Equal(10, v.Length); Assert.Equal(new VectorXD(new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }), v); }
public void Replace_ShouldSucceed() { var A = new VectorXD(new double[] { 1, 3, -1, 0, double.PositiveInfinity, -1 }).ToSparse(); A.Replace(x => x == -1 ? 0.0 : x); Assert.Equal(0, A.Get(2)); Assert.Equal(0, A.Get(5)); A.Replace(x => double.IsInfinity(x) ? 0.0 : x); Assert.Equal(0, A.Get(4)); }
public void Replace_ShouldSucceed() { var A = new VectorXD(new double[] { 1, 3, double.NaN, 0, double.PositiveInfinity, double.NaN }); A.Replace(x => double.IsNaN(x) ? 0.0 : x); Assert.Equal(0, A.Get(2)); Assert.Equal(0, A.Get(5)); A.Replace(x => double.IsInfinity(x) ? 0.0 : x); Assert.Equal(0, A.Get(4)); }
public void Identity_ShouldSucceed() { VectorXD v = VectorXD.Identity(3, 1); Assert.True(v.Max() <= 1.0); Assert.True(v.Min() >= 0.0); Assert.Equal(3, v.Length); Assert.Equal(1, v.Get(1)); Assert.Equal(0, v.Get(0)); Assert.Equal(0, v.Get(2)); }
public void ToString_ShouldSucceed() { SparseVectorD A = new VectorXD(new double[] { 1, 3, 1 }).ToSparse(); Assert.Equal("SparseVectorD, 3:\n\n1 3 1", A.ToString()); var B = new VectorXD(new double[] { 1.3423432, 3.234324, 3243241 }).ToSparse(); Assert.Equal("SparseVectorD, 3:\n\n1.34 3.23 3.24E+06", B.ToString()); var C = VectorXD.Linespace(0, 99, 100).ToSparse(); Assert.Equal("SparseVectorD, 100:\n\n0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...", C.ToString()); }
public void ConstructorString_ShouldSucceed() { double[] values = new double[] { 1.0, 2.0, 5.0, 6.0 }; int length = 4; VectorXD v = new VectorXD("1 2 5 6"); Assert.Equal(length, v.Length); for (int i = 0; i < length; i++) { Assert.Equal(values[i], v.Get(i)); } }
public void MultV_ShouldSucceed() { MatrixXD A = MatrixXD.Diag(new[] { 3.5, 2, 4.5 }); VectorXD v = new VectorXD(new[] { 2.0, 2.0, 2.0 }); var result = A.Mult(v); Assert.Equal(new double[] { 7, 4, 9 }, result.GetValues().ToArray()); A = new MatrixXD("1 2 1; 2 5 2; 2 5 5"); v = new VectorXD(new[] { 1.5, 4.5, 2.0 }); result = A.Mult(v); Assert.Equal(new double[] { 12.5, 29.5, 35.5 }, result.GetValues().ToArray()); A = new MatrixXD("1 -2 ; 2 5 ; 4 -2"); v = new VectorXD(new[] { 3.0, -7.0 }); result = A.Mult(v); Assert.Equal(new double[] { 17.0, -29.0, 26.0 }, result.GetValues().ToArray()); }
public void SquaredNorm_ShouldSucceed(string valuesString, double expected) { VectorXD v = new VectorXD(valuesString); Assert.Equal(expected, v.SquaredNorm()); }
public SVDResult(MatrixXD u, VectorXD s, MatrixXD v) { U = u; S = s; V = v; }
public void LpInfNorm_ShouldSucceed(string valuesString, double expected) { var v = new VectorXD(valuesString).ToSparse(); Assert.Equal(expected, v.LpInfNorm()); }
public SAEigenSolverResult(VectorXD eigenvalues, MatrixXD eigenvectors) { Eigenvalues = eigenvalues; Eigenvectors = eigenvectors; }