/// <summary> /// Permite efectuar a leitura de um polinómio a partir de texto. /// </summary> /// <remarks> /// Se a leitura não for bem sucedida, é lançada uma excep~ção. /// </remarks> /// <param name="polynomial">O texto.</param> /// <returns>O polinómio.</returns> public UnivariatePolynomialNormalForm <int> Read(string polynomial) { var integerDomain = new IntegerDomain(); var integerParser = new IntegerParser <string>(); var conversion = new ElementToElementConversion <int>(); var polInputReader = new StringReader(polynomial); var polSymbolReader = new StringSymbolReader(polInputReader, false); var polParser = new UnivariatePolynomialReader <int, CharSymbolReader <string> >( "x", integerParser, integerDomain); var result = default(UnivariatePolynomialNormalForm <int>); if (polParser.TryParsePolynomial(polSymbolReader, conversion, out result)) { // O polinómio foi lido com sucesso. return(result); } else { // Não é possível ler o polinómio. throw new Exception("Can't read integer polynomial."); } }
public void RunTest_IntegerNumbersRhoAlg() { var integerNumber = new IntegerDomain(); var integerParser = new IntegerParser <string>(); var conversion = new ElementToElementConversion <int>(); var variableName = "x"; var testPols = new List <UnivariatePolynomialNormalForm <int> >(); testPols.Add(TestsHelper.ReadUnivarPolynomial("x^2+1", integerNumber, integerParser, conversion, variableName)); testPols.Add(TestsHelper.ReadUnivarPolynomial("x^2+x+1", integerNumber, integerParser, conversion, variableName)); var rhoAlgorithm = new PollardRhoAlgorithm <int>( testPols, new ModularIntegerFieldFactory(), integerNumber); var factorizationTarget = new DecompositionFactorizationAlgorithm <int, int>( rhoAlgorithm, 1, integerNumber, integerNumber); var value = 72; var expected = new Dictionary <int, int>(); expected.Add(2, 3); expected.Add(3, 2); var actual = factorizationTarget.Run(value); CollectionAssert.AreEqual(expected, actual); }
public void ReplaceTest_Integer() { // Representação dos polinómios. var polynomText = "x^5+2*x^4+3*x^3+4*x^2+5*x+6"; 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 integerReplaceValues = new int[] { 0, 1, 2, 3 }; var integerExpectedValues = new int[] { 6, 21, 120, 543 }; for (int i = 0; i < integerReplaceValues.Length; ++i) { var integerActualValue = integerPolynomial.Replace(integerReplaceValues[i], integerDomain); Assert.AreEqual(integerExpectedValues[i], integerActualValue); } }
public void RunTest_IntegerPolynomial() { var integerDomain = new IntegerDomain(); var fractionField = new FractionField <int>(integerDomain); var integerParser = new IntegerParser <string>(); var conversion = new ElementToElementConversion <int>(); var fractionConversion = new ElementFractionConversion <int>(integerDomain); string variableName = "x"; var univarPolDomain = new UnivarPolynomEuclideanDomain <Fraction <int> >( variableName, fractionField); var lagAlg = new LagrangeAlgorithm <UnivariatePolynomialNormalForm <Fraction <int> > >(univarPolDomain); var firstValue = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>( "(x-1/2)*(x+1/3)", integerDomain, integerParser, fractionConversion, variableName); var secondValue = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>( "(x-1/2)*(x-1)", integerDomain, integerParser, fractionConversion, variableName); var gcd = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>( "x-1/2", integerDomain, integerParser, fractionConversion, variableName); var result = lagAlg.Run(firstValue, secondValue); var mainGcdCoeff = result.GreatestCommonDivisor.GetLeadingCoefficient(fractionField); var monicGcd = result.GreatestCommonDivisor.Multiply( fractionField.MultiplicativeInverse(mainGcdCoeff), fractionField); Assert.AreEqual(gcd, monicGcd); var firstTermExpression = univarPolDomain.Multiply(result.FirstFactor, result.FirstItem); var secondTermExpression = univarPolDomain.Multiply(result.SecondFactor, result.SecondItem); var actualExpression = univarPolDomain.Add(firstTermExpression, secondTermExpression); Assert.AreEqual(result.GreatestCommonDivisor, actualExpression); actualExpression = univarPolDomain.Multiply(result.GreatestCommonDivisor, result.FirstCofactor); Assert.AreEqual(result.FirstItem, actualExpression); actualExpression = univarPolDomain.Multiply(result.GreatestCommonDivisor, result.SecondCofactor); Assert.AreEqual(result.SecondItem, actualExpression); }
public void ReplaceTest_ReplaceByMatrixWithMatrixAlgebra() { // Representação dos polinómios. var polynomText = "x^2 + 2*x + 1"; var variableName = "x"; var integerDomain = new IntegerDomain(); var integerToIntegerConv = new ElementToElementConversion <int>(); var integerParser = new IntegerParser <string>(); var fractionField = new FractionField <int>(integerDomain); var fractionFieldParser = new FieldDrivenExpressionParser <Fraction <int> >( new SimpleElementFractionParser <int>(integerParser, integerDomain), fractionField); var polynomial = TestsHelper.ReadUnivarPolynomial <Fraction <int> >( polynomText, fractionField, fractionFieldParser, new ElementFractionConversion <int>(integerDomain), variableName); // Leitura da matriz. var matrix = TestsHelper.ReadMatrix <Fraction <int> >( 2, 2, "[[1/2+1/3,1/2-1/3],[1/5+1/4,1/5-1/4]]", (i, j) => new ArrayMathMatrix <Fraction <int> >(i, j), fractionFieldParser); var matrixAlgebra = new GeneralMatrixAlgebra <Fraction <int> >( 2, new ArrayMathMatrixFactory <Fraction <int> >(), fractionField); var actual = polynomial.Replace(matrix, matrixAlgebra); var expected = TestsHelper.ReadMatrix <Fraction <int> >( 2, 2, "[[1237/360,167/360],[501/400,391/400]]", (i, j) => new ArrayMathMatrix <Fraction <int> >(i, j), fractionFieldParser); for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { Assert.AreEqual(expected[i, j], actual[i, j]); } } }
public void ReplaceTest_ReplaceByFraction() { // Representação dos polinómios. var polynomText = "x^5+2*x^4+3*x^3+4*x^2+5*x+6"; 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>(); var fractionField = new FractionField <int>(integerDomain); var integerFractionAddOp = new ElementFractionAddOper <int>(integerDomain); // Estabelece os polinómios. var integerPolynomial = TestsHelper.ReadUnivarPolynomial( polynomText, integerDomain, integerParser, integerToIntegerConv, variableName); var fractionValues = new Fraction <int>[] { new Fraction <int>(0, 1, integerDomain), new Fraction <int>(1, 1, integerDomain), new Fraction <int>(1, 2, integerDomain), new Fraction <int>(1, 3, integerDomain) }; var fractionExpectedValues = new Fraction <int>[] { new Fraction <int>(6, 1, integerDomain), new Fraction <int>(21, 1, integerDomain), new Fraction <int>(321, 32, integerDomain), new Fraction <int>(2005, 243, integerDomain) }; for (int i = 0; i < fractionValues.Length; ++i) { var integerActualValue = integerPolynomial.Replace( fractionValues[i], integerFractionAddOp, fractionField); Assert.AreEqual(fractionExpectedValues[i], integerActualValue); } }
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_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 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 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 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); } }