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