/// <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;
}
}
