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