Exemplo n.º 1
0
 /// <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));
     }
 }
Exemplo n.º 2
0
 /// <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());
     }
 }
Exemplo n.º 3
0
 /// <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);
     }
 }
Exemplo n.º 4
0
 /// <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));
     }
 }
Exemplo n.º 5
0
 /// <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);
 }
Exemplo n.º 6
0
 /// <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));
     }
 }
Exemplo n.º 7
0
 /// <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));
     }
 }
Exemplo n.º 8
0
        /// <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);
            }
        }
Exemplo n.º 9
0
        /// <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));
                }
            }
        }