/// <summary> /// Determina se o polinómio geral é uma unidade multiplicativa. /// </summary> /// <param name="value">O polinómio a ser analisado.</param> /// <returns>Verdadeiro caso o polinómios seja uma unidade multiplicativa e falso caso contrário.</returns> /// <exception cref="ArgumentNullException">Se o argumento for nulo.</exception> public virtual bool IsMultiplicativeUnity(GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> value) { if (value == null) { throw new ArgumentNullException("value"); } else { return(value.IsUnity(this.ring)); } }
/// <summary> /// Retorna um código confuso para a instância. /// </summary> /// <param name="obj">A instância.</param> /// <returns> /// Um código confuso para a instância que pode ser usado em vários algoritmos habituais. /// </returns> public virtual int GetHashCode(GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> obj) { if (obj == null) { return(0); } else { return(obj.GetHashCode()); } }
/// <summary> /// Obtém o grau do polinómio. /// </summary> /// <param name="value">O polinómio do qual se pretende obter o grau.</param> /// <returns>O valor do grau.</returns> /// <exception cref="ArgumentNullException">Se o argumento for nulo.</exception> public uint Degree(GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> value) { if (value == null) { throw new ArgumentNullException("value"); } else { return((uint)(object)value.Degree); } }
/// <summary> /// Determina o inverso aditivo de um polinómio geral. /// </summary> /// <param name="number">O polinómio.</param> /// <returns>O inverso aditivo.</returns> /// <exception cref="ArgumentNullException">Caso o argumento seja nulo.</exception> public virtual GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> AdditiveInverse( GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> number) { if (number == null) { throw new ArgumentNullException("number"); } else { return(number.GetSymmetric(this.ring)); } }
/// <summary> /// Cria uma instância de objectos do tipo <see cref="GeneralDegUnivarPolynomEuclideanDomain{CoeffType, DegreeType}"/>. /// </summary> /// <param name="variableName">O nome da variável.</param> /// <param name="field">O corpo responsável pelas operações sobre os coeficiente.</param> /// <param name="integerNumber">O objecto que é responsável pelas operações sobre os graus.</param> public GeneralDegUnivarPolynomEuclideanDomain( string variableName, IField <CoeffType> field, IIntegerNumber <DegreeType> integerNumber) : base(variableName, field, integerNumber) { this.field = field; this.unit = new GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType>( this.field.MultiplicativeUnity, this.integerNumber.MultiplicativeUnity, this.variableName, this.field, this.integerNumber); }
/// <summary> /// Calcula o produto de dois polinomio gerais. /// </summary> /// <param name="left">O primeiro polinómio geral a ser multiplicado.</param> /// <param name="right">O segundo polinómio geral a ser multiplicado.</param> /// <returns>O resultado do produto dos polinómios.</returns> /// <exception cref="ArgumentNullException"> /// Se pelo menos um dos argumentos for nulo. /// </exception> public virtual GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> Multiply( GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> left, GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> right) { if (left == null) { throw new ArgumentNullException("left"); } else if (right == null) { throw new ArgumentNullException("right"); } else { return(left.Multiply(right, this.ring)); } }
/// <summary> /// Determina quando dois números de precisão dupla são iguais. /// </summary> /// <param name="x">O primeiro polinómio geral a ser comparado.</param> /// <param name="y">O segundo polinómio geral a ser comparado.</param> /// <returns> /// Verdadeiro caso ambos os objectos sejam iguais e falso no caso contrário. /// </returns> public virtual bool Equals( GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> x, GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> y) { if (x == null && y == null) { return(true); } else if (x == null) { return(false); } else if (y == null) { return(false); } else { return(x.Equals(y)); } }
/// <summary> /// Calcula a soma repetida de um polinómio. /// </summary> /// <param name="element">O polinómio a ser somado.</param> /// <param name="times">O número de vezes que a soma é aplicada.</param> /// <returns>O resultado da soma repetida.</returns> /// <exception cref="ArgumentNullException">Se o argumento for nulo.</exception> public virtual GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> AddRepeated( GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> element, int times) { if (element == null) { throw new ArgumentNullException("element"); } else { var result = new GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType>( this.variableName, this.integerNumber); foreach (var termsKvp in element) { result = result.Add( this.ring.AddRepeated(termsKvp.Value, times), termsKvp.Key, this.ring); } return(result); } }
/// <summary> /// Obtém o quociente e o resto da divisão entre dois polinómios. /// </summary> /// <param name="dividend">O dividendo.</param> /// <param name="divisor">O divisor.</param> /// <returns>O quociente e o resto.</returns> /// <exception cref="ArgumentNullException">Caso algum dos argumentos seja nulo.</exception> /// <exception cref="ArgumentException">Se os polinómios contiverem variáveis cujos nomes são diferentes.</exception> /// <exception cref="DivideByZeroException">Se o divisor for uma unidade aditiva.</exception> public DomainResult <GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> > GetQuotientAndRemainder( GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> dividend, GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> divisor) { if (dividend == null) { throw new ArgumentNullException("dividend"); } else if (divisor == null) { throw new ArgumentNullException("divisor"); } else if (divisor.VariableName != divisor.VariableName) { throw new ArgumentException("Polynomials must share the same variable name in order to be operated."); } else { if (this.IsAdditiveUnity(divisor)) { throw new DivideByZeroException("Can't divide by the null polynomial."); } else if (this.IsAdditiveUnity(dividend)) { return(new DomainResult <GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> >( this.AdditiveUnity, this.AdditiveUnity)); } else if (this.integerNumber.Compare(divisor.Degree, dividend.Degree) > 0) { return(new DomainResult <GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> >( new GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType>( this.variableName, this.integerNumber), dividend)); } else { var remainderSortedCoeffs = dividend.GetOrderedCoefficients(this.integerNumber); var divisorSorteCoeffs = divisor.GetOrderedCoefficients(this.integerNumber); var quotientCoeffs = new GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType>( this.variableName, this.integerNumber); var remainderLeadingDegree = remainderSortedCoeffs.Keys[remainderSortedCoeffs.Keys.Count - 1]; var divisorLeadingDegree = divisorSorteCoeffs.Keys[divisorSorteCoeffs.Keys.Count - 1]; var inverseDivisorLeadingCoeff = this.field.MultiplicativeInverse(divisorSorteCoeffs[divisorLeadingDegree]); while (this.integerNumber.Compare(remainderLeadingDegree, divisorLeadingDegree) >= 0 && remainderSortedCoeffs.Count > 0) { var remainderLeadingCoeff = remainderSortedCoeffs[remainderLeadingDegree]; var differenceDegree = this.integerNumber.Add(remainderLeadingDegree, this.integerNumber.AdditiveInverse(divisorLeadingDegree)); var factor = this.field.Multiply( remainderLeadingCoeff, inverseDivisorLeadingCoeff); quotientCoeffs = quotientCoeffs.Add(factor, differenceDegree, this.field); remainderSortedCoeffs.Remove(remainderLeadingDegree); for (int i = 0; i < divisorSorteCoeffs.Keys.Count - 1; ++i) { var currentDivisorDegree = divisorSorteCoeffs.Keys[i]; var currentCoeff = this.field.Multiply( divisorSorteCoeffs[currentDivisorDegree], factor); currentDivisorDegree = this.integerNumber.Add(currentDivisorDegree, differenceDegree); var addCoeff = default(CoeffType); if (remainderSortedCoeffs.TryGetValue(currentDivisorDegree, out addCoeff)) { addCoeff = this.field.Add( addCoeff, this.field.AdditiveInverse(currentCoeff)); if (this.field.IsAdditiveUnity(addCoeff)) { remainderSortedCoeffs.Remove(currentDivisorDegree); } else { remainderSortedCoeffs[currentDivisorDegree] = addCoeff; } } else { remainderSortedCoeffs.Add( currentDivisorDegree, this.field.AdditiveInverse(currentCoeff)); } } if (remainderSortedCoeffs.Count > 0) { remainderLeadingDegree = remainderSortedCoeffs.Keys[remainderSortedCoeffs.Keys.Count - 1]; } else { remainderLeadingDegree = this.integerNumber.AdditiveUnity; } } var remainder = new GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType>( remainderSortedCoeffs, this.variableName, this.field, this.integerNumber); return(new DomainResult <GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType> >( quotientCoeffs, remainder)); } } }