/// <summary> /// Instancia um novo objecto do tipo <see cref="QuadraticFieldSieve{NumberType}"/>. /// </summary> /// <param name="integerSquareRootAlgorithm"> /// O objecto responsável pelo cálculo da parte inteira da raiz quadrada de um número. /// </param> /// <param name="modularFieldFactory"> /// A fábrica responsável pela criação de objectos capazes de efectuar operações modulares. /// </param> /// <param name="primesIteratorFactory"> /// A fábrica responsável pela criação de enumeradores para números primos. /// </param> /// <param name="integerNumber">O objecto responsável pelas operações sobre os números inteiros.</param> /// <exception cref="ArgumentNullException"> /// Se pelo menos um dos argumentos for nulo. /// </exception> public QuadraticFieldSieve( IAlgorithm <NumberType, NumberType> integerSquareRootAlgorithm, IModularFieldFactory <NumberType> modularFieldFactory, IPrimeNumberIteratorFactory <int> primesIteratorFactory, IIntegerNumber <NumberType> integerNumber) { if (integerNumber == null) { throw new ArgumentNullException("integerNumber"); } else if (primesIteratorFactory == null) { throw new ArgumentNullException("primesIteratorFactory"); } else if (modularFieldFactory == null) { throw new ArgumentNullException("modularFieldFactory"); } else if (integerSquareRootAlgorithm == null) { throw new ArgumentNullException("integerSquareRootAlgorithm"); } else { this.integerNumber = integerNumber; this.modularFieldFactory = modularFieldFactory; this.field = new ModularIntegerField(2); this.linearSystemAlgorithm = new DenseCondensationLinSysAlgorithm <int>( this.field); this.primesIteratorFactory = primesIteratorFactory; this.integerSquareRootAlgorithm = integerSquareRootAlgorithm; } }
/// <summary> /// Permite criar uma instância da classe responsável pela determinação de potência perfeita. /// </summary> /// <param name="primeNumbersIteratorFactory"> /// A fábrica para instanciar o iterador sobre números primos. /// </param> /// <exception cref="ArgumentNullException">Se a fábrica for nula.</exception> public IntPerfectPowerTestAlg( IPrimeNumberIteratorFactory <int> primeNumbersIteratorFactory) { if (primeNumbersIteratorFactory == null) { throw new ArgumentNullException("primeNumbersIteratorFactory"); } else { this.primeNumbersIteratorFactory = primeNumbersIteratorFactory; } }
/// <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)); } }
/// <summary> /// Instancia um novo objecto do tipo <see cref="BigIntPerfectPowerTestAlg"/>. /// </summary> /// <param name="nthRootAlgorithm"> /// O algoritmo que permite calcular a parte inteira de uma raiz de ordem n. /// </param> /// <param name="primeNumbersIteratorFactory"> /// A fábrica que permite criar enumeradores para números primos. /// </param> /// <exception cref="ArgumentNullException"> /// Se algum dos argumentos for nulo. /// </exception> public BigIntPerfectPowerTestAlg( IAlgorithm <BigInteger, BigInteger, BigInteger> nthRootAlgorithm, IPrimeNumberIteratorFactory <BigInteger> primeNumbersIteratorFactory) { if (primeNumbersIteratorFactory == null) { throw new ArgumentNullException("primeNumbersIteratorFactory"); } else if (nthRootAlgorithm == null) { throw new ArgumentNullException("nthRootAlgorithm"); } else { this.primeNumbersIteratorFactory = primeNumbersIteratorFactory; this.nthRootAlgorithm = nthRootAlgorithm; } }
/// <summary> /// Obtém uma instância do algorimo orientado para o cálculo da função totient. /// </summary> /// <param name="squareRootAlgorithm">O algoritmo responsável pela extracção de raízes quadradas.</param> /// <param name="primeNumberFactory"> /// A fábrica responsável pela instanciação de um iterador para números /// primos. /// </param> /// <param name="integerNumber">O objecto responsável pelas operações sobre inteiros.</param> /// <exception cref="ArgumentNullException">Se pelo menos um dos argumentos for nulo.</exception> public EulerTotFuncAlg( IAlgorithm <NumberType, NumberType> squareRootAlgorithm, IPrimeNumberIteratorFactory <NumberType> primeNumberFactory, IIntegerNumber <NumberType> integerNumber) { if (integerNumber == null) { throw new ArgumentNullException("integerNumber"); } else if (primeNumberFactory == null) { throw new ArgumentNullException("primeNumberFactory"); } else if (squareRootAlgorithm == null) { throw new ArgumentNullException("squareNumberAlgorithm"); } else { this.integerNumber = integerNumber; this.primeNumberFactory = primeNumberFactory; this.squareRootAlgorithm = squareRootAlgorithm; } }