/// <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> /// Instancia uma nova instância da classe que implementa o algoritmo AKS. /// </summary> public AksPrimalityTest() { this.perfectPowerTest = new IntPerfectPowerTestAlg( new PrimeNumbersIteratorFactory()); this.integerNumber = new IntegerDomain(); this.totientFunctionAlg = new EulerTotFuncAlg <int>( new IntegerSquareRootAlgorithm(), new PrimeNumbersIteratorFactory(), this.integerNumber); this.modularFactory = new ModularIntegerFieldFactory(); }
/// <summary> /// Instancia um novo objecto do tipo <see cref="PollardRhoAlgorithm{NumberType}"/>. /// </summary> /// <param name="testPolynomials">Uma lista de polinómios de teste.</param> /// <param name="modularFieldFactory"> /// A fábrica responsável por objectos capazes de realizarem operações modulares. /// </param> /// <param name="integerNumber">O objecto respons+avel pelas operações sobre os números inteiros.</param> public PollardRhoAlgorithm( List <UnivariatePolynomialNormalForm <NumberType> > testPolynomials, IModularFieldFactory <NumberType> modularFieldFactory, IIntegerNumber <NumberType> integerNumber) : this(modularFieldFactory, integerNumber) { if (testPolynomials == null || testPolynomials.Count == 0) { this.SetupPolynomialList(); } else { this.polynomialsList = new List <UnivariatePolynomialNormalForm <NumberType> >(); this.polynomialsList.AddRange(testPolynomials); } }
/// <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="SearchFactorizationAlgorithm{CoeffType}"/>. /// </summary> /// <param name="modularFieldFactory"> /// A fábrica responsável pela criação de objectos capazes de realizar operações modulares. /// </param> /// <param name="integerNumber">O objecto responsável pelas operações sobre números inteiros.</param> /// <exception cref="ArgumentNullException"> /// Se algum dos argumentos for nulo. /// </exception> public SearchFactorizationAlgorithm( IModularFieldFactory <CoeffType> modularFieldFactory, IIntegerNumber <CoeffType> integerNumber) { if (integerNumber == null) { throw new ArgumentNullException("integerNumber"); } else if (modularFieldFactory == null) { throw new ArgumentNullException("modularFieldFactory"); } else { this.integerNumber = integerNumber; this.modularFieldFactory = modularFieldFactory; } }
/// <summary> /// Instancia um objecto do tipo <see cref="ResSolAlgorithm{NumberType}"/>. /// </summary> /// <param name="modularFieldFactory"> /// A fábrica responsável pela criação dos objectos responsáveis pelas operações modulares. /// </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 ResSolAlgorithm( IModularFieldFactory <NumberType> modularFieldFactory, IIntegerNumber <NumberType> integerNumber) { if (integerNumber == null) { throw new ArgumentNullException("integerNumber"); } else if (modularFieldFactory == null) { throw new ArgumentNullException("modularFieldFactory"); } else { this.integerNumber = integerNumber; this.legendreJacobiSymAlg = new LegendreJacobiSymbolAlgorithm <NumberType>(integerNumber); this.modularFieldFactory = modularFieldFactory; } }
/// <summary> /// Permite criar uma instância dum objecto responsável pela obtenção de factores de um número. /// </summary> /// <param name="modularFieldFactory">O objecto responsável pelas operações modulares.</param> /// <param name="integerNumber">O objecto responsável pelas operações sobre números inteiros.</param> /// <exception cref="ArgumentNullException">Se pelo menos um dos argumentos for nulo.</exception> public PollardRhoAlgorithm( IModularFieldFactory <NumberType> modularFieldFactory, IIntegerNumber <NumberType> integerNumber) { if (integerNumber == null) { throw new ArgumentNullException("integerNumber"); } else if (modularFieldFactory == null) { throw new ArgumentNullException("modularFieldFactory"); } else { this.integerNumber = integerNumber; this.modularFieldFactory = modularFieldFactory; this.startValue = this.integerNumber.MapFrom(19); this.SetupPolynomialList(); } }
/// <summary> /// Instancia um novo objecto do tipo <see cref="LinearLiftAlgorithm{T}"/>. /// </summary> /// <param name="modularFieldFactory"> /// A fábrica responsável pela criação de objectos capazes de realizar operações modulares. /// </param> /// <param name="polynomialDomainFactory"> /// A fábrica responsável pela criação de domínios capazes de realizar operações sobre polinómios. /// </param> /// <param name="integerNumber">A classe responsável pelas operações sobre os inteiros.</param> /// <exception cref="ArgumentNullException"> /// Se algum dos argumentos for nulo. /// </exception> public LinearLiftAlgorithm( IModularFieldFactory <T> modularFieldFactory, IUnivarPolDomainFactory <T> polynomialDomainFactory, IIntegerNumber <T> integerNumber) { if (integerNumber == null) { throw new ArgumentNullException("integerNumber"); } else if (polynomialDomainFactory == null) { throw new ArgumentNullException("polynomialDomainFactory"); } else if (modularFieldFactory == null) { throw new ArgumentNullException("modularFieldFactory"); } else { this.integerNumber = integerNumber; this.modularFieldFactory = modularFieldFactory; this.polynomialDomainFactory = polynomialDomainFactory; } }