/// <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 um novo objecto do tipo <see cref="FieldDrivenExpressionReader{ObjectType, InputType}"/>.
/// </summary>
/// <param name="objectParser">O leitor de objectos.</param>
/// <param name="field">O corpo.</param>
/// <param name="integerNumber">O número inteiro.</param>
public FieldDrivenExpressionReader(
IParse <ObjectType, string, string> objectParser,
IField <ObjectType> field,
IIntegerNumber <ObjectType> integerNumber = null) : base(objectParser, field, integerNumber)
{
// A verificação de nulidade do campo é levada a cabo na classe base.
this.field = field;
}
/// <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>
/// Obtém o valor da aplicação sucessiva da operação soma ao mesmo valor tendo em conta que esta é associativa.
/// </summary>
/// <typeparam name="T">O tipo do valor.</typeparam>
/// <typeparam name="Deg">O tipo que representa o número de vezes a adicionar.</typeparam>
/// <typeparam name="D">A classe que define a soma.</typeparam>
/// <param name="val">O valor.</param>
/// <param name="pow">O expoente.</param>
/// <param name="monoid">A classe que define a soma sobre o valor.</param>
/// <param name="degreeIntegerNumber">O objecto responsável pelas operaçóes sobre o grau.</param>
/// <returns>A potência do valor.</returns>
/// <exception cref="MathematicsException">
/// Se o monóide ou o objecto responsável pelas operações sobre inteiros forem nulos ou o expoente
/// for negativo.
/// </exception>
public static T AddPower <T, Deg, D>(
T val,
Deg pow,
D monoid,
IIntegerNumber <Deg> degreeIntegerNumber)
where D : IMonoid <T>
{
if (monoid == null)
{
throw new MathematicsException("Parameter multiplier can't be null.");
}
else if (degreeIntegerNumber == null)
{
throw new MathematicsException("Parameter degreeIntegerNumber can't be null.");
}
else if (degreeIntegerNumber.Compare(pow, degreeIntegerNumber.AdditiveUnity) < 0)
{
throw new MathematicsException("Can't computer the powers with negative expoents.");
}
else
{
var result = monoid.AdditiveUnity;
var innerPow = pow;
var innerVal = val;
var n = degreeIntegerNumber.MapFrom(2);
if (degreeIntegerNumber.Compare(innerPow, degreeIntegerNumber.AdditiveUnity) > 0)
{
var degreeQuotientAndRemainder = degreeIntegerNumber.GetQuotientAndRemainder(
innerPow,
n);
if (degreeIntegerNumber.IsMultiplicativeUnity(degreeQuotientAndRemainder.Remainder))
{
result = monoid.Add(result, innerVal);
}
innerPow = degreeIntegerNumber.Multiply(innerPow, n);
while (degreeIntegerNumber.Compare(innerPow, degreeIntegerNumber.AdditiveUnity) > 0)
{
innerVal = monoid.Add(innerVal, innerVal);
degreeQuotientAndRemainder = degreeIntegerNumber.GetQuotientAndRemainder(
innerPow,
n);
if (degreeIntegerNumber.IsMultiplicativeUnity(degreeQuotientAndRemainder.Remainder))
{
result = monoid.Add(result, innerVal);
}
innerPow = degreeIntegerNumber.Multiply(innerPow, n);
}
}
return(result);
}
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="LegendreJacobiSymbolAlgorithm{NumberType}"/>.
/// </summary>
/// <param name="integerNumber">O objecto responsável pelas operações sobre os números inteiros.</param>
/// <exception cref="ArgumentNullException">
/// Se o objecto responsável pelas operações sobre os números inteiros for nulo.
/// </exception>
public LegendreJacobiSymbolAlgorithm(IIntegerNumber <NumberType> integerNumber)
{
if (integerNumber == null)
{
throw new ArgumentNullException("integerNumber");
}
else
{
this.integerNumber = integerNumber;
}
}
/// <summary>
/// Instancia o objecto responsável pelo cálculo da parte inteira do logaritmo binário de um número.
/// </summary>
/// <param name="integerDomain">O objecto responsável pelas operações sobre inteiros.</param>
/// <exception cref="ArgumentNullException">Se o domínio for nulo.</exception>
public BaseLogIntegerPart(IIntegerNumber <NumberType> integerDomain)
{
if (integerDomain == null)
{
throw new ArgumentNullException("integerDomain");
}
else
{
this.integerDomain = integerDomain;
}
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="SquareFreeFractionFactorizationAlg{CoeffType}"/>.
/// </summary>
/// <param name="integerNumber">O objecto responsável pelas operações sobre números inteiros.</param>
/// <exception cref="ArgumentNullException">
/// Se o argumento for nulo.
/// </exception>
public SquareFreeFractionFactorizationAlg(
IIntegerNumber <CoeffType> integerNumber)
{
if (integerNumber == null)
{
throw new ArgumentNullException("integerNumber");
}
else
{
this.integerNumber = integerNumber;
this.fractionField = new FractionField <CoeffType>(this.integerNumber);
}
}
/// <summary>
/// Cria uma instância de objectos do tipo <see cref="GeneralDegUnivarPolynomEuclideanDomain{CoeffType, DegreeType}"/>.
/// </summary>
/// <param name="variableName">O nome da variável.</param>
/// <param name="field">O corpo responsável pelas operações sobre os coeficiente.</param>
/// <param name="integerNumber">O objecto que é responsável pelas operações sobre os graus.</param>
public GeneralDegUnivarPolynomEuclideanDomain(
string variableName,
IField <CoeffType> field,
IIntegerNumber <DegreeType> integerNumber)
: base(variableName, field, integerNumber)
{
this.field = field;
this.unit = new GeneralDegUnivarPolynomNormalForm <CoeffType, DegreeType>(
this.field.MultiplicativeUnity,
this.integerNumber.MultiplicativeUnity,
this.variableName,
this.field,
this.integerNumber);
}
/// <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>
/// Obtém a potência de um valor.
/// </summary>
/// <typeparam name="T">O tipo do valor.</typeparam>
/// <typeparam name="Deg">O tipo de classe que define os graus.</typeparam>
/// <typeparam name="D">O tipo da classe que define a multiplicação.</typeparam>
/// <param name="val">O valor.</param>
/// <param name="pow">O expoente.</param>
/// <param name="domain">O domínio responsável pelas operações sobre os valores.</param>
/// <param name="integerNumber">A classe que define as operações sobre números inteiros.</param>
/// <returns>A potência do valor.</returns>
/// <exception cref="MathematicsException">
/// Se o domínio ou o objecto que define operações sobre os inteiros forem nulos ou o expoente for negativo.
/// </exception>
public static T Power <T, Deg, D>(T val, Deg pow, D domain, IIntegerNumber <Deg> integerNumber)
where D : IMultiplication <T>
{
if (integerNumber == null)
{
throw new MathematicsException("Parameter integerNumber can't be null.");
}
else if (domain == null)
{
throw new MathematicsException("Parameter domain can't be null.");
}
else if (integerNumber.Compare(pow, integerNumber.AdditiveUnity) < 0)
{
throw new MathematicsException("Can't computer the powers with negative expoents.");
}
else
{
var result = domain.MultiplicativeUnity;
var innerPow = pow;
var innerVal = val;
var two = integerNumber.Successor(integerNumber.MultiplicativeUnity);
if (integerNumber.Compare(innerPow, integerNumber.AdditiveUnity) > 0)
{
var remQuo = integerNumber.GetQuotientAndRemainder(innerPow, two);
if (integerNumber.IsMultiplicativeUnity(remQuo.Remainder))
{
result = domain.Multiply(result, innerVal);
}
innerPow = remQuo.Quotient;
while (integerNumber.Compare(innerPow, integerNumber.AdditiveUnity) > 0)
{
innerVal = domain.Multiply(innerVal, innerVal);
remQuo = integerNumber.GetQuotientAndRemainder(innerPow, two);
if (integerNumber.IsMultiplicativeUnity(remQuo.Remainder))
{
result = domain.Multiply(result, innerVal);
}
innerPow = remQuo.Quotient;
}
}
return(result);
}
}
/// <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));
}
}
public IntegerBigIntFractionConversion(
IIntegerNumber <BigInteger> integerNumber,
BigIntegerToIntegerConversion bigIntegerToIntegerConversion)
{
if (integerNumber == null)
{
throw new ArgumentNullException("integerNumber");
}
else if (bigIntegerToIntegerConversion == null)
{
throw new ArgumentNullException("bigIntegerToIntegerConversion");
}
else
{
this.integerNumber = integerNumber;
this.bigIntegerToIntegerConversion = bigIntegerToIntegerConversion;
}
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="FiniteFieldPolFactorizationAlgorithm{CoeffType}"/>.
/// </summary>
/// <param name="linearSystemSolver">
/// O objecto responsável pela resolução de um sistema de equações lineares.
/// </param>
/// <param name="integerNumber">O ojecto responsável pelas operações sobre os números inteiros.</param>
/// <exception cref="ArgumentNullException">
/// Se algum dos argumentos for nulo.
/// </exception>
public FiniteFieldPolFactorizationAlgorithm(
IAlgorithm <IMathMatrix <CoeffType>, IMathMatrix <CoeffType>, LinearSystemSolution <CoeffType> > linearSystemSolver,
IIntegerNumber <CoeffType> integerNumber)
{
if (integerNumber == null)
{
throw new ArgumentNullException("integerNumber");
}
else if (linearSystemSolver == null)
{
throw new ArgumentNullException("linearSystemSolver");
}
else
{
this.integerNumber = integerNumber;
this.linearSystemSolver = linearSystemSolver;
}
}
/// <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 novo objecto do tipo <see cref="NaiveIntegerFactorizationAlgorithm{NumberType}"/>.
/// </summary>
/// <param name="integerSquareRootAlgorithm">
/// O algoritmo responsável pela determinação da parte inteira de uma raiz quadrada de um número.
/// </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 NaiveIntegerFactorizationAlgorithm(
IAlgorithm <NumberType, NumberType> integerSquareRootAlgorithm,
IIntegerNumber <NumberType> integerNumber)
{
if (integerNumber == null)
{
throw new ArgumentNullException("integerNumber");
}
else if (integerSquareRootAlgorithm == null)
{
throw new ArgumentNullException("integerSquareRootAlgorithm");
}
else
{
this.integerNumber = integerNumber;
this.integerSquareRootAlgorithm = integerSquareRootAlgorithm;
}
}
/// <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 instanciar um leitor de expressões com base num anel numérico.
/// </summary>
/// <param name="objectParser">O objecto responsável pela leitura de cada elemento.</param>
/// <param name="ring">O anel responsável pelas operações sobre os elementos.</param>
/// <param name="integerNumber">O objecto responsável pelas operações sobre o grau.</param>
/// <exception cref="MathematicsException">
/// Se o leitor de objectos ou o anel não forem providenciados.
/// </exception>
public RingDrivenExpressionReader(
IParse <ObjectType, string, string> objectParser,
IRing <ObjectType> ring,
IIntegerNumber <ObjectType> integerNumber)
{
if (objectParser == null)
{
throw new MathematicsException("An objet parser must be provided.");
}
else if (ring == null)
{
throw new MathematicsException("A ring must be provided.");
}
else
{
this.objectParser = objectParser;
this.ring = ring;
this.integerNumber = integerNumber;
}
}
/// <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 uma novo objecto do tipo <see cref="FieldDrivenExpressionParser{ObjectType}"/>.
/// </summary>
/// <param name="elementsParser">O leitor dos valores.</param>
/// <param name="field">O corpo responsável pelas operações sobre os valores.</param>
/// <param name="integerNumber">O objecto responsável pelas operações sobre os representantes de inteiros.</param>
/// <exception cref="ArgumentNullException">Se o leitor dos valores ou o corpo responsável pelas suas operações forem nulos.</exception>
public FieldDrivenExpressionParser(
IParse <ObjectType, string, string> elementsParser,
IField <ObjectType> field,
IIntegerNumber <ObjectType> integerNumber = null)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
else if (elementsParser == null)
{
throw new ArgumentNullException("elementsParser");
}
else
{
this.expressionReader = new FieldDrivenExpressionReader <ObjectType, ISymbol <string, string>[]>(
elementsParser,
field,
integerNumber);
}
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="RingDrivenExpressionParser{ObjectType}"/>.
/// </summary>
/// <param name="elementsParser">O leitor de valores.</param>
/// <param name="ring">O anel responsável pela leitura dos valores.</param>
/// <param name="integerNumber">O objecto responsável pelas operações sobre representantes de números inteiros.</param>
public RingDrivenExpressionParser(
IParse <ObjectType, string, string> elementsParser,
IRing <ObjectType> ring,
IIntegerNumber <ObjectType> integerNumber = null)
{
if (ring == null)
{
throw new ArgumentNullException("ring");
}
else if (elementsParser == null)
{
throw new ArgumentNullException("elementsParser");
}
else
{
this.expressionReader = new RingDrivenExpressionReader <ObjectType, ISymbol <string, string>[]>(
elementsParser,
ring,
integerNumber);
}
}
/// <summary>
/// Cria uma instância de objectos do tipo <see cref="GeneralDegUnivarPolynomRing{CoeffType, DegreeType}"/>.
/// </summary>
/// <param name="variableName">O nome da variável.</param>
/// <param name="ring">O anel responsável pelas operações sobre os coeficientes.</param>
/// <param name="integerNumber">O objecto responsável pelas operações sobre os graus.</param>
/// <exception cref="ArgumentNullException">
/// Se algum dos argumentos form nulo.
/// </exception>
/// <exception cref="ArgumentException">Se a variável for vazia.</exception>
public GeneralDegUnivarPolynomRing(
string variableName,
IRing <CoeffType> ring,
IIntegerNumber <DegreeType> integerNumber)
{
if (integerNumber == null)
{
throw new ArgumentNullException("integerNumber");
}
else if (ring == null)
{
throw new ArgumentNullException("ring");
}
else if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException("Variable must not be empty.");
}
else
{
this.variableName = variableName;
this.ring = ring;
}
}
/// <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;
}
}
/// <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;
}
}
