/// <summary> /// Instancia um novo objecto do tipo <see cref="UnivarPolNormalFormParser{CoeffType} "/>. /// </summary> /// <param name="variable">O nome da variável associada ao polinómio.</param> /// <param name="conversion">O objecto responsável pela conversão entre coeficientes e inteiros.</param> /// <param name="elementsParser">O leitor de coeficientes.</param> /// <param name="ring">O anel responsável pelas operações sobre os coeficientes.</param> public UnivarPolNormalFormParser( string variable, IConversion <int, CoeffType> conversion, IParse <CoeffType, string, string> elementsParser, IRing <CoeffType> ring) { if (string.IsNullOrWhiteSpace(variable)) { throw new ArgumentException("Variable must hava a non empty value."); } else if (conversion == null) { throw new ArgumentNullException("conversion"); } else if (ring == null) { throw new ArgumentNullException("ring"); } else if (elementsParser == null) { throw new ArgumentNullException("elementsParser"); } else { this.conversion = conversion; this.polynomialReader = new UnivariatePolynomialReader <CoeffType, ISymbol <string, string>[]>( variable, elementsParser, ring); } }
/// <summary> /// Permite realizar a leitura de um polinómio a partir de uma representação textual. /// </summary> /// <typeparam name="T">O tipo dos coeficientes do polinómio.</typeparam> /// <param name="polynomialRepresentation">A representação textual do polinómio.</param> /// <param name="ring">O anel responsável pelas operações sobre os coeficientes.</param> /// <param name="coeffsParser">O leitor de representações textuais para os coeficientes.</param> /// <param name="conversion">A conversão do tipo do coeficientes para inteiro.</param> /// <param name="variableName">O nome da variável.</param> /// <param name="readNegativeNumbers"> /// Indica se os números negativos são para ser lidos ou se é lido /// o sinal e depois o respectivo valor como símbolos independentes.</param> /// <returns>O polinómio lido a partir da representação textual.</returns> public static UnivariatePolynomialNormalForm <T> ReadUnivarPolynomial <T>( string polynomialRepresentation, IRing <T> ring, IParse <T, string, string> coeffsParser, IConversion <int, T> conversion, string variableName, bool readNegativeNumbers = false) { var polInputReader = new StringReader(polynomialRepresentation); var polSymbolReader = new StringSymbolReader(polInputReader, readNegativeNumbers); var polParser = new UnivariatePolynomialReader <T, CharSymbolReader <string> >( "x", coeffsParser, ring); var result = default(UnivariatePolynomialNormalForm <T>); 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 polynomial."); } }
/// <summary> /// Permite efectuar a leitura de um polinómio com coeficientes fraccionários 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 <Fraction <int> > Read(string polynomial) { var integerDomain = new IntegerDomain(); var fractionField = new FractionField <int>(integerDomain); var integerParser = new IntegerParser <string>(); var fractionParser = new FieldDrivenExpressionParser <Fraction <int> >( new SimpleElementFractionParser <int>(integerParser, integerDomain), fractionField); var conversion = new ElementFractionConversion <int>(integerDomain); var polInputReader = new StringReader(polynomial); var polSymbolReader = new StringSymbolReader(polInputReader, false); var polParser = new UnivariatePolynomialReader <Fraction <int>, CharSymbolReader <string> >( "x", fractionParser, fractionField); var result = default(UnivariatePolynomialNormalForm <Fraction <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."); } }
/// <summary> /// Permit realizar a leitura de um polinómio com coeficientes fraccionários. /// </summary> /// <typeparam name="T">O tipo de dados dos componentes das fracções.</typeparam> /// <param name="polynomialRepresentation">A representação polinomial.</param> /// <param name="domain">O domínio responsável pelas operações sobre os elementos das fracções.</param> /// <param name="itemsParser">O leitor de elementos da fracção.</param> /// <param name="conversion">A conversão entre cada fracção e o valor inteiro.</param> /// <param name="variableName">O nome da variável.</param> /// <param name="readNegativeNumbers">Indica se são lidos os números negativos.</param> /// <returns>O polinómio lido.</returns> public static UnivariatePolynomialNormalForm <Fraction <T> > ReadFractionalCoeffsUnivarPol <T, D>( string polynomialRepresentation, D domain, IParse <T, string, string> itemsParser, IConversion <int, Fraction <T> > conversion, string variableName, bool readNegativeNumbers = false) where D : IEuclidenDomain <T> { var fractionField = new FractionField <T>(domain); var fractionParser = new FieldDrivenExpressionParser <Fraction <T> >( new SimpleElementFractionParser <T>(itemsParser, domain), fractionField); var polInputReader = new StringReader(polynomialRepresentation); var polSymbolReader = new StringSymbolReader(polInputReader, readNegativeNumbers); var polParser = new UnivariatePolynomialReader <Fraction <T>, CharSymbolReader <string> >( "x", fractionParser, fractionField); var result = default(UnivariatePolynomialNormalForm <Fraction <T> >); 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 polynomial."); } }