public void string_to_multidimensional()
{
string[][] a = Jagged.Magic(3).Apply((x, i, j) => x.ToString());
double[,] expected = Matrix.Magic(3);
object actual = a.To <double[, ]>();
Assert.AreEqual(expected, actual);
}
public void string_to_jagged()
{
string[][] a = Jagged.Magic(3).Apply((x, i, j) => x.ToString());
double[][] expected = Jagged.Magic(3);
object actual = a.To <double[][]>();
Assert.AreEqual(expected, actual);
}
public void jagged_to_multidimensional()
{
double[][] a = Jagged.Magic(3);
double[,] expected = Matrix.Magic(3);
object actual = a.To <double[, ]>();
Assert.AreEqual(expected, actual);
}
public void string_to_jagged()
{
string[][] a = Jagged.Magic(3).Apply((x, i, j) => x.ToString());
double[][] expected = Jagged.Magic(3);
var actual = a.To <double[][]>();
for (int i = 0; i < actual.GetLength()[0]; i++)
{
for (int j = 0; j < actual.GetLength()[1]; j++)
{
Assert.AreEqual(expected[i][j], actual[i][j]);
}
}
}
public void InverseTestNaN()
{
int n = 5;
var I = Matrix.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 JaggedEigenvalueDecomposition(value);
}
}
}
public void minimize_test2()
{
double[][] costMatrix = Jagged.Magic(5);
var m = new Munkres(costMatrix);
Assert.AreEqual(5, m.NumberOfTasks);
Assert.AreEqual(5, m.NumberOfWorkers);
bool success = m.Minimize();
Assert.IsTrue(success);
Assert.AreEqual(15, m.Value);
Assert.AreEqual(2, m.Solution[0]);
Assert.AreEqual(1, m.Solution[1]);
Assert.AreEqual(0, m.Solution[2]);
Assert.AreEqual(4, m.Solution[3]);
Assert.AreEqual(3, m.Solution[4]);
}
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 new_method_column_names()
{
double[][] data = Jagged.Magic(3);
string[] columnNames = { "x", "y", "z" };
var target = new DescriptiveAnalysis(columnNames);
target.Learn(data);
Assert.AreEqual("x", target.ColumnNames[0]);
Assert.AreEqual("y", target.ColumnNames[1]);
Assert.AreEqual("z", target.ColumnNames[2]);
target.ColumnNames = columnNames;
Assert.IsTrue(target.CorrelationMatrix.IsEqual(new double[, ]
{
{ 1.0000, -0.7559, 0.1429 },
{ -0.7559, 1.0000, -0.7559 },
{ 0.1429, -0.7559, 1.0000 },
}, atol: 0.0001));
Assert.IsTrue(target.CovarianceMatrix.IsEqual(new double[, ]
{
{ 7, -8, 1 },
{ -8, 16, -8 },
{ 1, -8, 7 },
}, atol: 0.00000001));
Assert.IsTrue(target.StandardScores.IsEqual(new double[, ]
{
{ 1.1339, -1.0000, 0.3780 },
{ -0.7559, 0, 0.7559 },
{ -0.3780, 1.0000, -1.1339 },
}, atol: 0.001));
Assert.IsTrue(target.Means.IsEqual(new double[] { 5, 5, 5 }));
Assert.IsTrue(target.StandardDeviations.IsEqual(new double[] { 2.6458, 4.0000, 2.6458 }, 0.001));
Assert.IsTrue(target.Medians.IsEqual(new double[] { 4, 5, 6 }));
Assert.AreEqual(3, target.Ranges[0].Min);
Assert.AreEqual(8, target.Ranges[0].Max);
Assert.AreEqual(1, target.Ranges[1].Min);
Assert.AreEqual(9, target.Ranges[1].Max);
Assert.AreEqual(2, target.Ranges[2].Min);
Assert.AreEqual(7, target.Ranges[2].Max);
Assert.AreEqual(3, target.Samples);
Assert.AreEqual(3, target.Variables);
Assert.IsTrue(target.Source.IsEqual(Matrix.Magic(3)));
Assert.IsTrue(target.Sums.IsEqual(new double[] { 15, 15, 15 }));
Assert.IsTrue(target.Variances.IsEqual(new double[] { 7, 16, 7 }));
Assert.AreEqual(3, target.Quartiles[0].Min);
Assert.AreEqual(8, target.Quartiles[0].Max);
Assert.AreEqual(1, target.Quartiles[1].Min);
Assert.AreEqual(9, target.Quartiles[1].Max);
Assert.AreEqual(2, target.Quartiles[2].Min);
Assert.AreEqual(7, target.Quartiles[2].Max);
}
