/// <summary>
        /// Constrói uma instância de um objecto responsável pela factorização de um polinómio
        /// cujos coeficientes são fracções inteiras.
        /// </summary>
        /// <param name="integerNumber">O objecto responsável pelas operações sobre os números inteiros.</param>
        /// <param name="modularSymmetricFactory">
        /// A fábrica responsável pela ciração de instâncias de objectos
        /// responsáveis pelas operações modulares.
        /// </param>
        /// <param name="primeNumbersIteratorFactory">
        /// A fábrica responsável pela criação de um objecto capaz de iterar sobre o conjunto de números
        /// primos limitados por um determinado valor.
        /// </param>
        /// <param name="logarithmAlgorithm">O objecto responsável pelo cálculo do logaritmo.</param>
        /// <exception cref="ArgumentNullException">Se algum dos argumentos for nulo.</exception>
        public IntegerPolynomialFactorizationAlgorithm(
            IIntegerNumber <CoeffType> integerNumber,
            IModularFieldFactory <CoeffType> modularSymmetricFactory,
            IPrimeNumberIteratorFactory <CoeffType> primeNumbersIteratorFactory,
            IAlgorithm <CoeffType, double> logarithmAlgorithm)
        {
            if (integerNumber == null)
            {
                throw new ArgumentNullException("integerNumber");
            }
            else if (modularSymmetricFactory == null)
            {
                throw new ArgumentNullException("modularSymmetricFactory");
            }
            else if (primeNumbersIteratorFactory == null)
            {
                throw new ArgumentNullException("primeNumbersIteratorFactory");
            }
            else if (logarithmAlgorithm == null)
            {
                throw new ArgumentNullException("logarithmAlgorithm");
            }
            else
            {
                this.integerNumber                = integerNumber;
                this.fractionField                = new FractionField <CoeffType>(integerNumber);
                this.modularSymmetricFactory      = modularSymmetricFactory;
                this.squareFreeAlg                = new SquareFreeFractionFactorizationAlg <CoeffType>(integerNumber);
                this.searchFactorizationAlgorithm = new SearchFactorizationAlgorithm <CoeffType>(
                    modularSymmetricFactory,
                    this.integerNumber);
                this.integerSquareRootAlgorithm  = new IntegerSquareRootAlgorithm();
                this.primeNumbersIteratorFactory = primeNumbersIteratorFactory;
                this.logarithmAlgorithm          = logarithmAlgorithm;
                this.resultantAlg = new UnivarPolDeterminantResultantAlg <CoeffType>(
                    this.integerNumber);

                // O algoritmo responsável pelo levantamento módulo uma potência de um número primo.
                this.multiFactorLiftingAlg = new MultiFactorLiftAlgorithm <CoeffType>(
                    new LinearLiftAlgorithm <CoeffType>(
                        modularSymmetricFactory,
                        new UnivarPolEuclideanDomainFactory <CoeffType>(),
                        integerNumber));
            }
        }
Пример #2
0
        /// <summary>
        /// Executa o algoritmo sobre o polinómio com coeficientes inteiros.
        /// </summary>
        /// <remarks>
        /// O polinómio tem de ser livre de quadrados. Caso contrário, o resultado da aplicação do algoritmo
        /// é imprevisível.
        /// </remarks>
        /// <param name="polymomial">O polinómio.</param>
        /// <param name="modularField">O corpo modular.</param>
        /// <returns>A factorização do polinómio.</returns>
        public FiniteFieldPolynomialFactorizationResult <CoeffType> Run(
            UnivariatePolynomialNormalForm <CoeffType> polymomial,
            IModularField <CoeffType> modularField)
        {
            var fractionField = new FractionField <CoeffType>(this.integerNumber);
            var polynomDomain = new UnivarPolynomEuclideanDomain <CoeffType>(
                polymomial.VariableName,
                modularField);
            var bachetBezourAlg = new LagrangeAlgorithm <UnivariatePolynomialNormalForm <CoeffType> >(polynomDomain);

            var polynomialField = new UnivarPolynomEuclideanDomain <CoeffType>(
                polymomial.VariableName,
                modularField);

            var result = this.Factorize(
                polymomial,
                modularField,
                polynomialField,
                bachetBezourAlg);

            return(result);
        }