/// <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]); } } }