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 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 ArrayMatrixFactory <Fraction <int> >(); // Leitura da matriz que representa o sistema de equações. var coeffsMatrix = TestsHelper.ReadMatrix <Fraction <int> >( 3, 4, coefficientsMatrixText, matrixFactory, fractionFieldParser); // Leitura do vector de termos independente. var vectorMatrix = TestsHelper.ReadMatrix <Fraction <int> >( 3, 1, independentVectorText, new ArrayMatrixFactory <Fraction <int> >(), fractionFieldParser); var expectedMatrixVector = TestsHelper.ReadMatrix <Fraction <int> >( 4, 1, expectedText, matrixFactory, 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 RunTest() { var mainPolText = "x^3+10*x^2-432*x+5040"; var firstFactorText = "x"; var secondFactorText = "x^2-2"; var variableName = "x"; var prime = 5; var integerDomain = new IntegerDomain(); var integerParser = new IntegerParser <string>(); var integerConversion = new ElementToElementConversion <int>(); var mainPol = TestsHelper.ReadUnivarPolynomial( mainPolText, integerDomain, integerParser, integerConversion, variableName); var firstFactor = TestsHelper.ReadUnivarPolynomial( firstFactorText, integerDomain, integerParser, integerConversion, variableName); var secondFactor = TestsHelper.ReadUnivarPolynomial( secondFactorText, integerDomain, integerParser, integerConversion, variableName); // Testa o levantamento linear. var linearLift = new LinearLiftAlgorithm <int>( new ModularSymmetricIntFieldFactory(), new UnivarPolEuclideanDomainFactory <int>(), integerDomain); var liftingStatus = new LinearLiftingStatus <int>(mainPol, firstFactor, secondFactor, prime); var result = linearLift.Run(liftingStatus, 3); Assert.AreEqual(625, liftingStatus.LiftedFactorizationModule); var expected = liftingStatus.UFactor.Multiply(liftingStatus.WFactor, new ModularIntegerField(625)); var actual = mainPol.ApplyFunction(coeff => this.GetSymmetricRemainder(coeff, 625), integerDomain); Assert.AreEqual(expected, actual); }
public void RunTest_TestFactors2() { var polText = "x^3+2"; var variableName = "x"; var prime = 5; var integerDomain = new IntegerDomain(); var integerParser = new IntegerParser <string>(); var integerConversion = new ElementToElementConversion <int>(); // Faz a leitura do polinómio. var pol = TestsHelper.ReadUnivarPolynomial( polText, integerDomain, integerParser, integerConversion, variableName); // Testa os factores. var integerModule = new ModularIntegerField(prime); var finiteFieldPolAlg = new FiniteFieldPolFactorizationAlgorithm <int>( new DenseCondensationLinSysAlgorithm <int>(integerModule), integerDomain); var result = finiteFieldPolAlg.Run(pol, integerModule); var factorsEnumerator = result.Factors.GetEnumerator(); if (factorsEnumerator.MoveNext()) { var expected = factorsEnumerator.Current; while (factorsEnumerator.MoveNext()) { expected = expected.Multiply(factorsEnumerator.Current, integerModule); } expected = expected.Multiply(result.IndependentCoeff, integerModule); Assert.AreEqual(expected, pol.ApplyFunction(coeff => this.GetSymmetricRemainder(coeff, prime), integerModule)); } else { Assert.Fail("At least the main polynomial may be regarded as a factor."); } }
public void RunTest_BigIntegerMatrix() { // A leitura é realizada por colunas. var matrixText = "[[100000,1001,20005], [32534,4245341,56134513451], [21346136,1134613,1136135613]]"; var integerDomain = new BigIntegerDomain(); var variableName = "x"; var integerParser = new BigIntegerParser <string>(); var conversion = new BigIntegerToIntegerConversion(); var matrix = TestsHelper.ReadMatrix <BigInteger>( 3, 3, matrixText, (i, j) => new ArraySquareMathMatrix <BigInteger>(i), integerParser); var fastDivFreeCharacPolAlg = new FastDivisionFreeCharPolynomCalculator <BigInteger>(variableName, integerDomain); var expected = TestsHelper.ReadUnivarPolynomial("1*x^3+-1140480954*x^2-58754054577367644*x+4689162494877443109176", integerDomain, integerParser, conversion, variableName); var actual = fastDivFreeCharacPolAlg.Run(matrix as ISquareMathMatrix <BigInteger>); Assert.AreEqual(expected, actual); }
public void RunTest_IntegerMatrix() { // A leitura é realizada por colunas. var matrixText = "[[1,-1,2], [3,4,5], [2,1,1]]"; var integerDomain = new IntegerDomain(); var variableName = "x"; var integerParser = new IntegerParser <string>(); var conversion = new ElementToElementConversion <int>(); var matrix = TestsHelper.ReadMatrix <int>( 3, 3, matrixText, (i, j) => new ArraySquareMathMatrix <int>(i), integerParser, true); var fastDivFreeCharacPolAlg = new FastDivisionFreeCharPolynomCalculator <int>(variableName, integerDomain); var expected = TestsHelper.ReadUnivarPolynomial("x^3-6*x^2+3*x+18", integerDomain, integerParser, conversion, variableName); var actual = fastDivFreeCharacPolAlg.Run(matrix as ISquareMathMatrix <int>); Assert.AreEqual(expected, actual); }
public void GetRootPowerSumsTest_Integer() { // Representação dos polinómios. var polynomText = "(x-3)*(x-2)^2*(x+1)^3"; var variableName = "x"; // Estabelece os domínios. var integerDomain = new IntegerDomain(); // Estabelece os conversores. var integerToIntegerConv = new ElementToElementConversion <int>(); // Estabelece os leitores individuais. var integerParser = new IntegerParser <string>(); // Estabelece os polinómios. var integerPolynomial = TestsHelper.ReadUnivarPolynomial( polynomText, integerDomain, integerParser, integerToIntegerConv, variableName); var integerExpectedVector = new ArrayVector <int>(6); integerExpectedVector[0] = 4; integerExpectedVector[1] = 20; integerExpectedVector[2] = 40; integerExpectedVector[3] = 116; integerExpectedVector[4] = 304; integerExpectedVector[5] = 860; var integerActualVector = integerPolynomial.GetRootPowerSums(integerDomain); Assert.AreEqual(integerExpectedVector.Length, integerActualVector.Length, "Vector lengths aren't equal."); for (int i = 0; i < integerActualVector.Length; ++i) { Assert.AreEqual(integerExpectedVector[i], integerActualVector[i]); } }
public void GetElementarySymmetricRepresentationTest() { var domain = new IntegerDomain(); var coeffsParser = new IntegerParser <string>(); var conversion = new ElementToElementConversion <int>(); var dictionary = new Dictionary <int, int>(); dictionary.Add(5, 2); dictionary.Add(0, 2); var varDictionary = new Dictionary <int, Tuple <bool, string, int> >(); varDictionary.Add(1, Tuple.Create(true, "s[1]", 0)); var symmetric = new SymmetricPolynomial <int>( new List <string>() { "x", "y", "z", "w" }, dictionary, 1, domain); var rep = symmetric.GetElementarySymmetricRepresentation(varDictionary, new IntegerDomain()); var expanded = rep.GetExpanded(domain); var expectedPolText = "5*s4^2*s2+-5*s4*s2^3+5*s4*s3^2+5*s2^2*s3^2+1*s2^5"; var expected = TestsHelper.ReadPolynomial( expectedPolText, domain, conversion, coeffsParser); Assert.AreEqual(expected, expanded); }
public void FeedFrowardNeuralNetwork_InternalComputeOutputs() { var target = new FeedForwardNeuralNetwork <double>( new[] { 2L, 3L, 2L }); var parser = new DoubleParser <string>(); var matrix = TestsHelper.ReadMatrix( 5, 5, "[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]", (i, j) => new SparseDictionaryMatrix <double>(i, j, 0), parser, true); var vector = TestsHelper.ReadVector( 5, "[0.5, 0.5, 0.5, 0.5, 0.5]", new SparseDictionaryMathVectorFactory <double>(), parser, true); var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >( matrix, vector); target.LoadModel(model); var outputMatrix = target.InternalReserveOutput(); target.InternalComputeLayerOutputs( new ArrayMathVector <double>(new[] { 1.0, -1.0 }), outputMatrix, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }); Assert.AreEqual(target.Schema.LongCount() - 1L, outputMatrix.LongLength); var currOut = outputMatrix[0]; Assert.AreEqual(0.0, currOut[0]); Assert.AreEqual(1.0, currOut[1]); Assert.AreEqual(0.0, currOut[2]); currOut = outputMatrix[1]; Assert.AreEqual(0.0, currOut[0]); Assert.AreEqual(0.0, currOut[1]); }
public void FeedFrowardNeuralNetwork_RunSimpleMatrixTest() { var target = new FeedForwardNeuralNetwork <double>( new[] { 2L, 3L, 2L }); var parser = new DoubleParser <string>(); var matrix = TestsHelper.ReadMatrix( 5, 5, "[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]", (i, j) => new SparseDictionaryMatrix <double>(i, j, 0), parser, true); var vector = TestsHelper.ReadVector( 5, "[0.5, 0.5, 0.5, 0.5, 0.5]", new SparseDictionaryMathVectorFactory <double>(), parser, true); var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >( matrix, vector); target.LoadModel(model); var actual = target.Run( new[] { 1.0, 0.0 }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }); var expected = new[] { 0.0, 0.0 }; CollectionAssert.AreEqual(expected, actual); actual = target.Run( new[] { 0.0, 1.0 }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }); expected = new[] { 0.0, 1.0 }; CollectionAssert.AreEqual(expected, actual); actual = target.Run( new[] { 1.0, -1.0 }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }); expected = new[] { 0.0, 0.0 }; CollectionAssert.AreEqual(expected, actual); }
public void GetRootPowerSumsTest() { // Representação dos polinómios. var polynomText = "(x-3)*(x-2)^2*(x+1)^3"; var variableName = "x"; // Estabelece os domínios. var integerDomain = new IntegerDomain(); // Estabelece o corpo responsável pelas operações sobre as fracções. var fractionField = new FractionField <int>(integerDomain); // Estabelece os conversores. var integerToFractionConversion = new ElementFractionConversion <int>(integerDomain); // Estabelece os leitores individuais. var integerParser = new IntegerParser <string>(); // Estabelece o leitor de fracções. var fractionParser = new ElementFractionParser <int>(integerParser, integerDomain); // Estabelece os polinómios. var integerPolynomial = TestsHelper.ReadUnivarPolynomial( polynomText, fractionField, fractionParser, integerToFractionConversion, variableName); var number = 10; var roots = new int[] { 3, 2, 2, -1, -1, -1 }; var powerRoots = new int[] { 3, 2, 2, -1, -1, -1 }; var integerFractionExpectedVector = new ArrayVector <Fraction <int> >(number); // Primeiro cálculo var sum = powerRoots[0]; for (int i = 1; i < powerRoots.Length; ++i) { sum += powerRoots[i]; } integerFractionExpectedVector[0] = new Fraction <int>(sum, 1, integerDomain); for (int i = 1; i < number; ++i) { for (int j = 0; j < roots.Length; ++j) { powerRoots[j] *= roots[j]; } sum = powerRoots[0]; for (int j = 1; j < powerRoots.Length; ++j) { sum += powerRoots[j]; } integerFractionExpectedVector[i] = new Fraction <int>(sum, 1, integerDomain); } var integerFractionActualVector = integerPolynomial.GetRootPowerSums( number, fractionField, new SparseDictionaryMathVectorFactory <Fraction <int> >()); Assert.AreEqual( integerFractionExpectedVector.Length, integerFractionActualVector.Length, "Vector lengths aren't equal."); for (int i = 0; i < integerFractionActualVector.Length; ++i) { Assert.AreEqual(integerFractionExpectedVector[i], integerFractionActualVector[i]); } }
public void PowerTest_FractionPolynomial() { var integerDomain = new IntegerDomain(); var longDomain = new LongDomain(); var bigIntegerDomain = new BigIntegerDomain(); var variableName = "x"; var integerPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <int> >( variableName, new FractionField <int>(integerDomain)); var longPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <long> >( variableName, new FractionField <long>(longDomain)); var bigIntegerPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <BigInteger> >( variableName, new FractionField <BigInteger>(bigIntegerDomain)); // Leitores var integerParser = new IntegerParser <string>(); var longParser = new LongParser <string>(); var bigIntegerParser = new BigIntegerParser <string>(); var integerConversion = new OuterElementFractionConversion <int, int>(new ElementToElementConversion <int>(), integerDomain); var longToIntegerConversion = new OuterElementFractionConversion <int, long>(new LongToIntegerConversion(), longDomain); var bigIntegerToIntegerConversion = new OuterElementFractionConversion <int, BigInteger>(new BigIntegerToIntegerConversion(), bigIntegerDomain); var intPowers = new int[3] { 2, 3, 4 }; var longPowers = new long[3] { 2, 3, 4 }; var bigIntPowers = new BigInteger[3] { 2, 3, 4 }; var polynomialsTexts = new string[3] { "1/3*x^3-2/3*x^2+3/2*x-1/2", "2*x^2+4/3*x+4/9", "7/5*x+1" }; var expectedPolinomialsTexts = new string[3] { "1/9*x^6-4/9*x^5+13/9*x^4-7/3*x^3+35/12*x^2-3/2*x+1/4", "8*x^6+16*x^5+16*x^4+256/27*x^3+32/9*x^2+64/81*x+64/729", "2401/625*x^4+1372/125*x^3+294/25*x^2+28/5*x+1" }; // Coeficientes inteiros. for (int i = 0; i < 3; ++i) { var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol( polynomialsTexts[i], integerDomain, integerParser, integerConversion, variableName); var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol( expectedPolinomialsTexts[i], integerDomain, integerParser, integerConversion, variableName); var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], integerPolynomialField); Assert.AreEqual(expectedPolynomial, actualPolynomial); } // Coeficientes longos. for (int i = 0; i < 3; ++i) { var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol( polynomialsTexts[i], longDomain, longParser, longToIntegerConversion, variableName); var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol( expectedPolinomialsTexts[i], longDomain, longParser, longToIntegerConversion, variableName); var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], longPolynomialField); Assert.AreEqual(expectedPolynomial, actualPolynomial); } // Coeficientes correspondentes a inteiros de precisão arbitrária. for (int i = 0; i < 3; ++i) { var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol( polynomialsTexts[i], bigIntegerDomain, bigIntegerParser, bigIntegerToIntegerConversion, variableName); var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol( expectedPolinomialsTexts[i], bigIntegerDomain, bigIntegerParser, bigIntegerToIntegerConversion, variableName); var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], bigIntegerPolynomialField); Assert.AreEqual(expectedPolynomial, actualPolynomial); } }
public void GetPolynomialDerivativeTest_SimpleInteger() { // Representação dos polinómios. var polynomText = "x^1000-2*x^550+1000*x^10+50"; var polDerivativeText = "1000*x^999-1100*x^549+10000*x^9"; var variableName = "x"; // Estabelece os domínios. var integerDomain = new IntegerDomain(); var longDomain = new LongDomain(); var bigIntegerDomain = new BigIntegerDomain(); // Estabelece os conversores. var integerToIntegerConv = new ElementToElementConversion <int>(); var integerToLongConv = new LongToIntegerConversion(); var integerToBigIntegerConvsersion = new BigIntegerToIntegerConversion(); // Estabelece os leitores individuais. var integerParser = new IntegerParser <string>(); var longParser = new LongParser <string>(); var bigIntegerParser = new BigIntegerParser <string>(); // Estabelece os polinómios. var integerPolynomial = TestsHelper.ReadUnivarPolynomial( polynomText, integerDomain, integerParser, integerToIntegerConv, variableName); var integerExpectedPolynomial = TestsHelper.ReadUnivarPolynomial( polDerivativeText, integerDomain, integerParser, integerToIntegerConv, variableName); var integerActualDerivative = integerPolynomial.GetPolynomialDerivative(integerDomain); // Verifica se os polinómios são válidos. Assert.AreEqual(integerExpectedPolynomial, integerActualDerivative); // Estabelece os polinómios. var longPolynomial = TestsHelper.ReadUnivarPolynomial( polynomText, longDomain, longParser, integerToLongConv, variableName); var longExpectedPolynomial = TestsHelper.ReadUnivarPolynomial( polDerivativeText, longDomain, longParser, integerToLongConv, variableName); var longActualDerivative = longPolynomial.GetPolynomialDerivative(longDomain); // Verifica se os polinómios são válidos. Assert.AreEqual(longExpectedPolynomial, longActualDerivative); // Estabelece os polinómios. var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial( polynomText, bigIntegerDomain, bigIntegerParser, integerToBigIntegerConvsersion, variableName); var bigIntegerExpectedPolynomial = TestsHelper.ReadUnivarPolynomial( polDerivativeText, bigIntegerDomain, bigIntegerParser, integerToBigIntegerConvsersion, variableName); var bigIntegerActualDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerDomain); // Verifica se os polinómios são válidos. Assert.AreEqual(bigIntegerExpectedPolynomial, bigIntegerActualDerivative); }
public void GetPolynomialDerivativeTest_IntegerMatrix() { // Os valores a serem lidos var polynomialText = "[[1,2],[3,4]]*x^2-[[1,0],[0,1]]*x+[[7,6],[9,8]]"; var polynomialDerivativeText = "[[2,4],[6,8]]*x+[[-1,0],[0,-1]]"; var variableName = "x"; var arrayDelimiters = new Dictionary <string, string>(); arrayDelimiters.Add("left_bracket", "right_bracket"); // Os domínios responsáveis sobre as operações sobre os inteiros. var integerDomain = new IntegerDomain(); var longDomain = new LongDomain(); var bigIntegerDomain = new BigIntegerDomain(); // Os leitore sde inteiros var integerParser = new IntegerParser <string>(); var longParser = new LongParser <string>(); var bigIntegerParser = new BigIntegerParser <string>(); // As fábricas responsáveis pela instanciação de matrizes var integerSquareArrayMatrixfactory = new ArraySquareMatrixFactory <int>(); var longSquareArrayMatrixFactory = new ArraySquareMatrixFactory <long>(); var bigIntegerSquareArrayMatrixfactory = new ArraySquareMatrixFactory <BigInteger>(); // Os anéis de matrizes var integerGenericMatrixRing = new GeneralMatrixRing <int>( 2, integerSquareArrayMatrixfactory, integerDomain); var longGenericMatrixRing = new GeneralMatrixRing <long>( 2, longSquareArrayMatrixFactory, longDomain); var bigIntegerGenericMatrixRing = new GeneralMatrixRing <BigInteger>( 2, bigIntegerSquareArrayMatrixfactory, bigIntegerDomain); // Os objectos responsáveis pela conversão entre os coeficientes e o grau (inteiro) var integerMatrixConversion = new CantConvertConversion <int, IMatrix <int> >(); var longMatrixConversion = new CantConvertConversion <int, IMatrix <long> >(); var bigIntegerMatrixConversion = new CantConvertConversion <int, IMatrix <BigInteger> >(); var integerMatrixConfigParser = new ConfigMatrixParser <int, IMatrix <int> >( integerParser, 2, 2, (i, j) => integerSquareArrayMatrixfactory.CreateMatrix(i, j)); integerMatrixConfigParser.SeparatorSymbType = "comma"; integerMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket"); integerMatrixConfigParser.AddBlanckSymbolType("blancks"); var longMatrixConfigParser = new ConfigMatrixParser <long, IMatrix <long> >( longParser, 2, 2, (i, j) => longSquareArrayMatrixFactory.CreateMatrix(i, j)); longMatrixConfigParser.SeparatorSymbType = "comma"; longMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket"); longMatrixConfigParser.AddBlanckSymbolType("blancks"); var bigIntegerMatrixConfigParser = new ConfigMatrixParser <BigInteger, IMatrix <BigInteger> >( bigIntegerParser, 2, 2, (i, j) => bigIntegerSquareArrayMatrixfactory.CreateMatrix(i, j)); bigIntegerMatrixConfigParser.SeparatorSymbType = "comma"; bigIntegerMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket"); bigIntegerMatrixConfigParser.AddBlanckSymbolType("blancks"); // Leitura dos polinómios e subsequente teste. var integerPolynomial = TestsHelper.ReadUnivarPolynomial <IMatrix <int> >( polynomialText, integerGenericMatrixRing, integerMatrixConfigParser, integerMatrixConversion, variableName, arrayDelimiters); var integerExpectedDerivative = TestsHelper.ReadUnivarPolynomial( polynomialDerivativeText, integerGenericMatrixRing, integerMatrixConfigParser, integerMatrixConversion, variableName, arrayDelimiters, true); var integerActualDerivative = integerPolynomial.GetPolynomialDerivative(integerGenericMatrixRing); Assert.IsTrue( new UnivarPolynomNormalFormEqualityComparer <IMatrix <int> >(integerGenericMatrixRing).Equals(integerExpectedDerivative, integerActualDerivative), string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative)); var longPolynomial = TestsHelper.ReadUnivarPolynomial( polynomialText, longGenericMatrixRing, longMatrixConfigParser, longMatrixConversion, variableName, arrayDelimiters); var longExpectedDerivative = TestsHelper.ReadUnivarPolynomial( polynomialDerivativeText, longGenericMatrixRing, longMatrixConfigParser, longMatrixConversion, variableName, arrayDelimiters, true); var longActualDerivative = longPolynomial.GetPolynomialDerivative(longGenericMatrixRing); Assert.IsTrue( new UnivarPolynomNormalFormEqualityComparer <IMatrix <long> >(longGenericMatrixRing).Equals(longExpectedDerivative, longActualDerivative), string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative)); var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial( polynomialText, bigIntegerGenericMatrixRing, bigIntegerMatrixConfigParser, bigIntegerMatrixConversion, variableName, arrayDelimiters); var bigIntegerExpectedDerivative = TestsHelper.ReadUnivarPolynomial( polynomialDerivativeText, bigIntegerGenericMatrixRing, bigIntegerMatrixConfigParser, bigIntegerMatrixConversion, variableName, arrayDelimiters, true); var bigIntegerActualDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerGenericMatrixRing); Assert.IsTrue( new UnivarPolynomNormalFormEqualityComparer <IMatrix <BigInteger> >( bigIntegerGenericMatrixRing).Equals(bigIntegerExpectedDerivative, bigIntegerActualDerivative), string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative)); }
public void GetPolynomialDerivativeTest_IntegerFraction() { var polynomialText = "1/2*x^5+3/4*x^4-2/7*x^3+5/3*x^2+1/5*x+9"; var polynomialDerivativeText = "5/2*x^4+3*x^3-6/7*x^2+10/3*x+1/5"; var variableName = "x"; var integerDomain = new IntegerDomain(); var longDomain = new LongDomain(); var bigIntegerDomain = new BigIntegerDomain(); var integerParser = new IntegerParser <string>(); var longParser = new LongParser <string>(); var bigIntegerParser = new BigIntegerParser <string>(); var longConversion = new LongToIntegerConversion(); var bigIntegerConversion = new BigIntegerToIntegerConversion(); var integerFractionConversion = new ElementFractionConversion <int>(integerDomain); var longfractionConversion = new OuterElementFractionConversion <int, long>(longConversion, longDomain); var bigIntegerfractionConversion = new OuterElementFractionConversion <int, BigInteger>(bigIntegerConversion, bigIntegerDomain); var integerFractionField = new FractionField <int>(integerDomain); var longFractionField = new FractionField <long>(longDomain); var bigIntegerFractionField = new FractionField <BigInteger>(bigIntegerDomain); // Coeficientes inteiros var integerPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>( polynomialText, integerDomain, integerParser, integerFractionConversion, variableName); var integerPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>( polynomialDerivativeText, integerDomain, integerParser, integerFractionConversion, variableName); var integerActualPolDerivative = integerPolynomial.GetPolynomialDerivative(integerFractionField); Assert.AreEqual(integerPolynomialDerivative, integerActualPolDerivative); // Coeficientes longos var longPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <long, LongDomain>( polynomialText, longDomain, longParser, longfractionConversion, variableName); var longPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <long, LongDomain>( polynomialDerivativeText, longDomain, longParser, longfractionConversion, variableName); var longActualPolDerivative = longPolynomial.GetPolynomialDerivative(longFractionField); Assert.AreEqual(longPolynomialDerivative, longActualPolDerivative); var bigIntegerPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <BigInteger, BigIntegerDomain>( polynomialText, bigIntegerDomain, bigIntegerParser, bigIntegerfractionConversion, variableName); var bigIntegerPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <BigInteger, BigIntegerDomain>( polynomialDerivativeText, bigIntegerDomain, bigIntegerParser, bigIntegerfractionConversion, variableName); var bigIntegerActualPolDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerFractionField); Assert.AreEqual(bigIntegerPolynomialDerivative, bigIntegerActualPolDerivative); }
public void RunTest_OnlyInequalitiesDouble() { var inputConstraintsMatrixText = "[[1,0,3],[0,2,2]]"; var inputConstraintsVectorText = "[4,12,18]"; var inputObjectiveFuncText = "[-3,-5]"; var inverseMatrixText = "[[1,0,0],[0,1,0],[0,0,1]]"; var cost = 0.0; var nonBasicVariables = new[] { 0, 1 }; var basicVariables = new[] { 2, 3, 4 }; // Leitura da matriz das retrições. var doubleElementsParser = new DoubleParser <string>(); var inputConstraintsMatrix = TestsHelper.ReadMatrix <double>( 3, 2, inputConstraintsMatrixText, (i, j) => new ArrayMathMatrix <double>(i, j), doubleElementsParser, true); // Leitura da matriz inversa. var inverseMatrix = TestsHelper.ReadMatrix <double>( 3, 3, inverseMatrixText, (i, j) => new ArraySquareMathMatrix <double>(i), doubleElementsParser, true) as ISquareMathMatrix <double>; // Leitura do vector de restrições. var vectorFactory = new ArrayVectorFactory <double>(); var inputConstraintsVector = TestsHelper.ReadVector <double>( 3, inputConstraintsVectorText, vectorFactory, doubleElementsParser, true); // Leitura da função objectivo. var inputObjectiveFunction = TestsHelper.ReadVector <double>( 2, inputObjectiveFuncText, vectorFactory, doubleElementsParser, true); // Objecto de entrada para o algoritmo do simplex. var simplexInput = new RevisedSimplexInput <double, double>( basicVariables, nonBasicVariables, inputObjectiveFunction, cost, inputConstraintsMatrix, inputConstraintsVector, inverseMatrix); // Executa o algoritmo do simplex. var doubleField = new DoubleField(); var target = new RevisedSimplexAlgorithm <double>(Comparer <double> .Default, doubleField); var actual = target.Run(simplexInput); // Verifica o custo Assert.AreEqual(36, actual.Cost); // Verifica a solução Assert.AreEqual(2, actual.Solution[0]); Assert.AreEqual(6, actual.Solution[1]); }
public void GetPolynomialDerivativeTest_IntegerPolynomialAsCoefficients() { var polynomialText = "(y^2+y+1)*x^3-2*x^2*y+x*(y^5-3)+4"; var polynomialDerivativeText = "3*(y^2+y+1)*x^2-4*y*x+y^5-3"; var variableName = "x"; var coeffsVariableName = "y"; // Os domínios responsáveis pelas operações sobre os inteiros. var integerDomain = new IntegerDomain(); var longDomain = new LongDomain(); var bigIntegerDomain = new BigIntegerDomain(); // Os leitore sde inteiros var integerParser = new IntegerParser <string>(); var longParser = new LongParser <string>(); var bigIntegerParser = new BigIntegerParser <string>(); // Definição das conversões. var integerConversion = new ElementToElementConversion <int>(); var longConversion = new LongToIntegerConversion(); var bigIntegerConversion = new BigIntegerToIntegerConversion(); var integerPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <int>( coeffsVariableName, integerConversion, integerDomain); var longPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <long>( coeffsVariableName, longConversion, longDomain); var bigIntegerPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <BigInteger>( coeffsVariableName, bigIntegerConversion, bigIntegerDomain); // Definição dos anéis polinomiais. var integerPolynomialRing = new UnivarPolynomRing <int>(coeffsVariableName, integerDomain); var longPolynomialRing = new UnivarPolynomRing <long>(coeffsVariableName, longDomain); var bigIntegerPolynomialRing = new UnivarPolynomRing <BigInteger>(coeffsVariableName, bigIntegerDomain); // Definição dos leitores polinomiais. var integerPolynomialParser = new UnivarPolNormalFormParser <int>( coeffsVariableName, integerConversion, integerParser, integerDomain); var longPolynomialParser = new UnivarPolNormalFormParser <long>( coeffsVariableName, longConversion, longParser, longDomain); var bigIntegerPolynomialParser = new UnivarPolNormalFormParser <BigInteger>( coeffsVariableName, bigIntegerConversion, bigIntegerParser, bigIntegerDomain); // Definição dos testes. var integerPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <int> >( polynomialText, integerPolynomialRing, integerPolynomialParser, integerPolConvertion, variableName); var integerExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <int> >( polynomialDerivativeText, integerPolynomialRing, integerPolynomialParser, integerPolConvertion, variableName); var integerActualPlynomial = integerPolynomial.GetPolynomialDerivative(integerPolynomialRing); Assert.AreEqual(integerExpectedPol, integerActualPlynomial); var longPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <long> >( polynomialText, longPolynomialRing, longPolynomialParser, longPolConvertion, variableName); var longExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <long> >( polynomialDerivativeText, longPolynomialRing, longPolynomialParser, longPolConvertion, variableName); var longActualPlynomial = longPolynomial.GetPolynomialDerivative(longPolynomialRing); Assert.AreEqual(longExpectedPol, longActualPlynomial); var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <BigInteger> >( polynomialText, bigIntegerPolynomialRing, bigIntegerPolynomialParser, bigIntegerPolConvertion, variableName); var bigIntegerExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <BigInteger> >( polynomialDerivativeText, bigIntegerPolynomialRing, bigIntegerPolynomialParser, bigIntegerPolConvertion, variableName); var bigIntegerActualPlynomial = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerPolynomialRing); Assert.AreEqual(bigIntegerExpectedPol, bigIntegerExpectedPol); }
public void PowerTest_IntegerPolynomial() { var integerDomain = new IntegerDomain(); var longDomain = new LongDomain(); var bigIntegerDomain = new BigIntegerDomain(); var variableName = "x"; var intPolDomain = new UnivarPolynomRing <int>(variableName, integerDomain); var longPolDomain = new UnivarPolynomRing <long>(variableName, longDomain); var bigIntegerPolDomain = new UnivarPolynomRing <BigInteger>(variableName, bigIntegerDomain); // Leitores var integerParser = new IntegerParser <string>(); var longParser = new LongParser <string>(); var bigIntegerParser = new BigIntegerParser <string>(); var integerConversion = new ElementToElementConversion <int>(); var longToIntegerConversion = new LongToIntegerConversion(); var bigIntegerToIntegerConversion = new BigIntegerToIntegerConversion(); var intPowers = new int[3] { 2, 3, 4 }; var longPowers = new long[3] { 2, 3, 4 }; var bigIntPowers = new BigInteger[3] { 2, 3, 4 }; var polynomialsTexts = new string[3] { "x^3-2*x^2+3*x-1", "2*x^2+4*x+4", "x+1" }; var expectedPolinomialsTexts = new string[3] { "x^6-4*x^5+10*x^4-14*x^3+13*x^2-6*x+1", "8*x^6+48*x^5+144*x^4+256*x^3+288*x^2+192*x+64", "x^4+4*x^3+6*x^2+4*x+1" }; // Coeficientes inteiros. for (int i = 0; i < 3; ++i) { var polynomialValue = TestsHelper.ReadUnivarPolynomial( polynomialsTexts[i], integerDomain, integerParser, integerConversion, variableName); var expectedPolynomial = TestsHelper.ReadUnivarPolynomial( expectedPolinomialsTexts[i], integerDomain, integerParser, integerConversion, variableName); var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], intPolDomain); Assert.AreEqual(expectedPolynomial, actualPolynomial); } // Coeficientes longos. for (int i = 0; i < 3; ++i) { var polynomialValue = TestsHelper.ReadUnivarPolynomial( polynomialsTexts[i], longDomain, longParser, longToIntegerConversion, variableName); var expectedPolynomial = TestsHelper.ReadUnivarPolynomial( expectedPolinomialsTexts[i], longDomain, longParser, longToIntegerConversion, variableName); var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], longPolDomain); Assert.AreEqual(expectedPolynomial, actualPolynomial); } // Coeficientes correspondentes a inteiros de precisão arbitrária. for (int i = 0; i < 3; ++i) { var polynomialValue = TestsHelper.ReadUnivarPolynomial( polynomialsTexts[i], bigIntegerDomain, bigIntegerParser, bigIntegerToIntegerConversion, variableName); var expectedPolynomial = TestsHelper.ReadUnivarPolynomial( expectedPolinomialsTexts[i], bigIntegerDomain, bigIntegerParser, bigIntegerToIntegerConversion, variableName); var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], bigIntegerPolDomain); Assert.AreEqual(expectedPolynomial, actualPolynomial); } }