/// <summary>
/// Faz a leitura de uma matriz de valores numéricos.
/// </summary>
/// <param name="lines">The number of lines.</param>
/// <param name="columns">The number of columns.</param>
/// <param name="arrayString">O texto que representa a matriz.</param>
/// <returns>A matriz lida.</returns>
public ArrayMathMatrix <double> ReadArray(int lines, int columns, string arrayString)
{
var expressionParser = new DoubleExpressionParser();
var reader = new StringReader(arrayString);
var stringSymbolReader = new StringSymbolReader(reader, false);
var arrayMatrixFactory = new ArrayMathMatrixFactory <double>();
var arrayMatrixReader = new ConfigMatrixReader <double, IMathMatrix <double>, string, string>(
lines,
columns);
arrayMatrixReader.MapInternalDelimiters("left_bracket", "right_bracket");
arrayMatrixReader.AddBlanckSymbolType("blancks");
arrayMatrixReader.SeparatorSymbType = "comma";
var matrix = default(IMathMatrix <double>);
if (arrayMatrixReader.TryParseMatrix(stringSymbolReader, expressionParser, (i, j) => arrayMatrixFactory.CreateMatrix(i, j), out matrix))
{
return(matrix as ArrayMathMatrix <double>);
}
else
{
throw new ArgumentException("Can't read the specified matrix.");
}
}
/// <summary>
/// Testa a deomposição sequencial relativa à matriz.
/// </summary>
/// <param name="target">O algoritmo.</param>
/// <param name="matrix">A matriz.</param>
private void TestDecomposition(
ATriangDiagSymmMatrixDecomp <Fraction <int> > target,
ISquareMathMatrix <Fraction <int> > matrix)
{
// Execução do algoritmo.
var decomposition = target.Run(
matrix);
// Calcula o valor esperado.
var matrixFactory = new ArrayMathMatrixFactory <Fraction <int> >();
var matrixMultiplicaton = new MatrixMultiplicationOperation <Fraction <int> >(
matrixFactory,
target.Field,
target.Field);
var actual = new TransposeMatrix <Fraction <int> >(decomposition.UpperTriangularMatrix)
as IMatrix <Fraction <int> >;
actual = matrixMultiplicaton.Multiply(actual, decomposition.DiagonalMatrix);
actual = matrixMultiplicaton.Multiply(actual, decomposition.UpperTriangularMatrix);
// Valida as asserções.
Assert.AreEqual(matrix.GetLength(0), actual.GetLength(0));
Assert.AreEqual(matrix.GetLength(1), actual.GetLength(1));
for (int i = 0; i < actual.GetLength(0); ++i)
{
for (int j = 0; j < actual.GetLength(1); ++j)
{
Assert.AreEqual(matrix[i, j], actual[i, j]);
}
}
}
public void RunTest()
{
var inputMatrix = "[[1,2,1],[2,-1,-1],[1,-1,3]]";
var inputVector = "[[1,2,3]]";
var expectedText = "[[21/19,-6/19,10/19]]";
var integerDomain = new BigIntegerDomain();
var integerParser = new BigIntegerParser <string>();
var fractionField = new FractionField <BigInteger>(integerDomain);
var fractionFieldParser = new FieldDrivenExpressionParser <Fraction <BigInteger> >(
new SimpleElementFractionParser <BigInteger>(integerParser, integerDomain),
fractionField);
var matrixFactory = new ArrayMathMatrixFactory <Fraction <BigInteger> >();
// Leitura da matriz que representa o sistema de equações.
var coeffsMatrix = TestsHelper.ReadMatrix <Fraction <BigInteger> >(
3,
3,
inputMatrix,
(i, j) => new ArrayMathMatrix <Fraction <BigInteger> >(i, j),
fractionFieldParser);
// Leitura do vector de termos independente.
var vectorMatrix = TestsHelper.ReadMatrix <Fraction <BigInteger> >(
3,
1,
inputVector,
(i, j) => new ArrayMathMatrix <Fraction <BigInteger> >(i, j),
fractionFieldParser);
var expectedMatrix = TestsHelper.ReadMatrix <Fraction <BigInteger> >(
3,
1,
expectedText,
(i, j) => new ArrayMathMatrix <Fraction <BigInteger> >(i, j),
fractionFieldParser);
var systemSolver = new SequentialLanczosAlgorithm <Fraction <BigInteger>, FractionField <BigInteger> >(
matrixFactory,
fractionField);
var squareMatrix = (coeffsMatrix as ArrayMathMatrix <Fraction <BigInteger> >).AsSquare();
var actual = systemSolver.Run(squareMatrix, vectorMatrix);
for (int i = 0; i < 3; ++i)
{
Assert.AreEqual(expectedMatrix[i, 0], actual[i, 0]);
}
}
public void DenseCondensationLinSysAlgorithm_RunTest()
{
var coefficientsMatrixText = "[[1,0,0],[0,0,0],[0,3,3],[2,0,1]]";
var independentVectorText = "[[1,3,3]]";
var expectedText = "[[1,0,1,0]]";
var integerDomain = new IntegerDomain();
var integerParser = new IntegerParser <string>();
var fractionField = new FractionField <int>(integerDomain);
var fractionFieldParser = new FieldDrivenExpressionParser <Fraction <int> >(
new SimpleElementFractionParser <int>(integerParser, integerDomain),
fractionField);
var matrixFactory = new ArrayMathMatrixFactory <Fraction <int> >();
// Leitura da matriz que representa o sistema de equações.
var coeffsMatrix = TestsHelper.ReadMatrix <Fraction <int> >(
3,
4,
coefficientsMatrixText,
(i, j) => new ArrayMathMatrix <Fraction <int> >(i, j),
fractionFieldParser);
// Leitura do vector de termos independente.
var vectorMatrix = TestsHelper.ReadMatrix <Fraction <int> >(
3,
1,
independentVectorText,
(i, j) => new ArrayMathMatrix <Fraction <int> >(i, j),
fractionFieldParser);
var expectedMatrixVector = TestsHelper.ReadMatrix <Fraction <int> >(
4,
1,
expectedText,
(i, j) => new ArrayMathMatrix <Fraction <int> >(i, j),
fractionFieldParser);
var algorithm = new DenseCondensationLinSysAlgorithm <Fraction <int> >(fractionField);
var actual = algorithm.Run(coeffsMatrix, vectorMatrix);
Assert.AreEqual(expectedMatrixVector.GetLength(0), actual.Vector.Length);
for (int i = 0; i < actual.Vector.Length; ++i)
{
Assert.AreEqual(expectedMatrixVector[i, 0], actual.Vector[i]);
}
}
public void ComputeCostsCoefficientsTest()
{
var field = new DoubleField();
var revisedSimplexAlg = new RevisedSimplexAlgorithm <double>(
Comparer <double> .Default,
field);
var target = new PrivateObject(revisedSimplexAlg);
var etaVector = new double[4];
// Fábricas úteis para o teste dos quatro cenários.
var arrayMatrixFactory = new ArrayMathMatrixFactory <double>();
var squareArrayMatrixFactory = new ArraySquareMatrixFactory <double>();
var sparseMatrixFactory = new SparseDictionaryMathMatrixFactory <double>();
var squareSparseMatrixFactory = new SparseDictionarySquareMatrixFactory <double>();
this.TestComputeCostsCoefficients(target, squareArrayMatrixFactory, 0, arrayMatrixFactory, 0, etaVector);
this.TestComputeCostsCoefficients(target, squareArrayMatrixFactory, 0, sparseMatrixFactory, 0, etaVector);
this.TestComputeCostsCoefficients(target, squareSparseMatrixFactory, 0, arrayMatrixFactory, 0, etaVector);
this.TestComputeCostsCoefficients(target, squareSparseMatrixFactory, 0, sparseMatrixFactory, 0, etaVector);
}
public void Run_TriangDiagSymmDecompNoInverse()
{
// Definição dos domínios e fábricas.
var integerDomain = new IntegerDomain();
var fractionField = new FractionField <int>(integerDomain);
// Definição dos algoritmos.
var target = new TriangDiagSymmDecompInverseAlg <Fraction <int> >();
var triangDecomp = new ParallelTriangDiagSymmMatrixDecomp <Fraction <int> >(fractionField);
var arraySquareMatrixFactory = new ArraySquareMatrixFactory <Fraction <int> >();
var arrayMatrixFactory = new ArrayMathMatrixFactory <Fraction <int> >();
// A matriz
var matrix = this.GetSingularMatrix(integerDomain);
// Cálculos
var triangDiagDecomp = triangDecomp.Run(
matrix);
var inverseMatrix = target.Run(
triangDiagDecomp,
arraySquareMatrixFactory,
fractionField);
// Verificação dos valores.
var expected = ArrayMathMatrix <Fraction <int> > .GetIdentity(3, fractionField);
var matrixMultiplication = new MatrixMultiplicationOperation <Fraction <int> >(
arrayMatrixFactory,
fractionField,
fractionField);
var actual = matrixMultiplication.Multiply(inverseMatrix, matrix);
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
{
Assert.AreEqual(expected[i, j], actual[i, j]);
}
}
}