private static void TestClear()
{
var zero = Matrix.CreateZero(SymmPosDef10by10.Order, SymmPosDef10by10.Order);
var matrix = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
matrix.Clear();
comparer.AssertEqual(zero, matrix);
}
private static void TestGetRow()
{
var matrix = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
for (int i = 0; i < SymmPosDef10by10.Order; ++i)
{
Vector rowExpected = DenseStrategies.GetRow(matrix, i);
Vector rowComputed = matrix.GetRow(i);
comparer.AssertEqual(rowExpected, rowComputed);
}
}
private static void TestGetColumn()
{
var matrix = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
for (int j = 0; j < SymmPosDef10by10.Order; ++j)
{
Vector colExpected = DenseStrategies.GetColumn(matrix, j);
Vector colComputed = matrix.GetColumn(j);
comparer.AssertEqual(colExpected, colComputed);
}
}
private static void TestDeterminant(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// positive definite
var A = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
CholeskyPacked factorization = A.FactorCholesky();
double detComputed = factorization.CalcDeterminant();
comparer.AssertEqual(SymmPosDef10by10.Determinant, detComputed);
});
}
private static void TestArrayCopy()
{
// positive definite
var A1 = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
comparer.AssertEqual(SymmPosDef10by10.Matrix, A1.CopyToArray2D());
// singular
var A2 = SymmetricMatrix.CreateFromArray(SymmSingular10by10.Matrix);
comparer.AssertEqual(SymmSingular10by10.Matrix, A2.CopyToArray2D());
}
private static void TestInversion(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// positive definite
var A = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var inverseAExpected = Matrix.CreateFromArray(SymmPosDef10by10.Inverse);
CholeskyPacked factorization = A.FactorCholesky();
SymmetricMatrix inverseAComputed = factorization.Invert(true);
comparer.AssertEqual(inverseAExpected, inverseAComputed);
});
}
private static void TestSystemSolution(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// positive definite
var A = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var b = Vector.CreateFromArray(SymmPosDef10by10.Rhs);
var xExpected = Vector.CreateFromArray(SymmPosDef10by10.Lhs);
CholeskyPacked factorization = A.FactorCholesky();
Vector xComputed = factorization.SolveLinearSystem(b);
comparer.AssertEqual(xExpected, xComputed);
});
}
private static void TestEigensystemCalledFromPackedMatrix(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var A = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var eigenvaluesExpected = Vector.CreateFromArray(SymmPosDef10by10.Eigenvalues);
var eigenvectorsExpected = Matrix.CreateFromArray(SymmPosDef10by10.Eigenvectors);
(Vector eigenvalues, Matrix eigenvectors) = A.CalcEigensystem();
// Check
comparer.AssertEqual(eigenvaluesExpected, eigenvalues);
comparer.AssertEqual(eigenvectorsExpected, eigenvectors);
});
}
private static void TestSerialization()
{
var originalMatrix = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var formatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
formatter.Serialize(stream, originalMatrix);
stream.Seek(0, SeekOrigin.Begin);
var deserializedMatrix = (SymmetricMatrix)formatter.Deserialize(stream);
Assert.True(originalMatrix.Equals(deserializedMatrix));
}
}
private static void TestMatrixVectorMultiplicationIntoResult(LinearAlgebraProviderChoice providers)
{
// The result vectors will first be set to some non zero values to make sure that the result overwrites
// them instead of being added to them.
TestSettings.RunMultiproviderTest(providers, delegate()
{
var A = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var x = Vector.CreateFromArray(SymmPosDef10by10.Lhs);
var bExpected = Vector.CreateFromArray(SymmPosDef10by10.Rhs);
Vector bComputed = Vector.CreateWithValue(A.NumRows, 1.0);
A.MultiplyIntoResult(x, bComputed, false);
comparer.AssertEqual(bExpected, bComputed);
});
}
private static void TestTransposition()
{
// invertible
var A1 = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var A1TransposeExpected = MatrixOperations.Transpose(SymmPosDef10by10.Matrix);
SymmetricMatrix A1TransposeComputed = A1.Transpose(false);
comparer.AssertEqual(A1TransposeExpected, A1TransposeComputed.CopyToArray2D());
// singular
var A2 = SymmetricMatrix.CreateFromArray(SymmSingular10by10.Matrix);
var A2TransposeExpected = MatrixOperations.Transpose(SymmSingular10by10.Matrix);
SymmetricMatrix A2TransposeComputed = A2.Transpose(false);
comparer.AssertEqual(A2TransposeExpected, A2TransposeComputed.CopyToArray2D());
}
private static void TestFactorization(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// positive definite
var A1 = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var expectedU1 = Matrix.CreateFromArray(SymmPosDef10by10.FactorU);
CholeskyPacked factorization1 = A1.FactorCholesky();
TriangularUpper computedU1 = factorization1.GetFactorU();
comparer.AssertEqual(expectedU1, computedU1);
// singular
var A2 = SymmetricMatrix.CreateFromArray(SquareSingular10by10.Matrix);
Assert.Throws <IndefiniteMatrixException>(() => A2.FactorCholesky());
});
}
private static void TestMatrixVectorMultiplication(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// invertible
var A1 = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
var x1 = Vector.CreateFromArray(SymmPosDef10by10.Lhs);
var b1Expected = Vector.CreateFromArray(SymmPosDef10by10.Rhs);
Vector b1Computed = A1.Multiply(x1);
comparer.AssertEqual(b1Expected, b1Computed);
// singular
var A2 = SymmetricMatrix.CreateFromArray(SymmSingular10by10.Matrix);
var x2 = Vector.CreateFromArray(SymmSingular10by10.Lhs);
var b2Expected = Vector.CreateFromArray(SymmSingular10by10.Rhs);
Vector b2Computed = A2.Multiply(x1);
comparer.AssertEqual(b2Expected, b2Computed);
});
}
