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