/// <summary>
/// Executa o algoritmo que permite obter uma factorização livre de quadrados.
/// </summary>
/// <param name="polynomial">O polinómio de entrada.</param>
/// <returns>A factorização livre de quadrados.</returns>
/// <exception cref="ArgumentNullException">
/// Se o argumento for nulo.
/// </exception>
public SquareFreeFactorizationResult <Fraction <CoeffType>, CoeffType> Run(
UnivariatePolynomialNormalForm <Fraction <CoeffType> > polynomial)
{
if (polynomial == null)
{
throw new ArgumentNullException("polynomial");
}
else
{
var independentCoeff = this.fractionField.MultiplicativeUnity;
var result = new Dictionary <int, UnivariatePolynomialNormalForm <CoeffType> >();
var currentDegree = 1;
var polynomDomain = new UnivarPolynomEuclideanDomain <Fraction <CoeffType> >(
polynomial.VariableName,
this.fractionField);
var lagAlg = new LagrangeAlgorithm <CoeffType>(this.integerNumber);
var dataDerivative = polynomial.GetPolynomialDerivative(this.fractionField);
var gcd = this.GreatCommonDivisor(polynomial, dataDerivative, polynomDomain);
if (gcd.Degree == 0)
{
var lcm = this.GetDenominatorLcm(polynomial, lagAlg);
if (this.integerNumber.IsMultiplicativeUnity(lcm))
{
var integerPol = this.GetIntegerPol(polynomial);
result.Add(currentDegree, integerPol);
}
else
{
independentCoeff = new Fraction <CoeffType>(
this.integerNumber.MultiplicativeUnity,
lcm,
this.integerNumber);
var multipliable = new Fraction <CoeffType>(
lcm,
this.integerNumber.MultiplicativeUnity,
this.integerNumber);
var multipliedPol = polynomial.Multiply(independentCoeff, this.fractionField);
var integerPol = this.GetIntegerPol(multipliedPol);
result.Add(currentDegree, integerPol);
}
}
else
{
var polyCoffactor = polynomDomain.Quo(polynomial, gcd);
var nextGcd = this.GreatCommonDivisor(gcd, polyCoffactor, polynomDomain);
var squareFreeFactor = polynomDomain.Quo(polyCoffactor, nextGcd);
polyCoffactor = gcd;
gcd = nextGcd;
if (squareFreeFactor.Degree > 0)
{
var lcm = this.GetDenominatorLcm(squareFreeFactor, lagAlg);
if (this.integerNumber.IsMultiplicativeUnity(lcm))
{
var integerPol = this.GetIntegerPol(squareFreeFactor);
result.Add(currentDegree, integerPol);
}
else if (this.fractionField.IsAdditiveUnity(independentCoeff))
{
independentCoeff = new Fraction <CoeffType>(
this.integerNumber.MultiplicativeUnity,
MathFunctions.Power(lcm, currentDegree, this.integerNumber),
this.integerNumber);
var multipliable = new Fraction <CoeffType>(
lcm,
this.integerNumber.MultiplicativeUnity,
this.integerNumber);
var multipliedPol = squareFreeFactor.Multiply(independentCoeff, this.fractionField);
var integerPol = this.GetIntegerPol(multipliedPol);
result.Add(currentDegree, integerPol);
}
else
{
var multiplicationCoeff = new Fraction <CoeffType>(
this.integerNumber.MultiplicativeUnity,
MathFunctions.Power(lcm, currentDegree, this.integerNumber),
this.integerNumber);
independentCoeff = this.fractionField.Multiply(independentCoeff, multiplicationCoeff);
var multipliable = new Fraction <CoeffType>(
lcm,
this.integerNumber.MultiplicativeUnity,
this.integerNumber);
var multipliedPol = squareFreeFactor.Multiply(independentCoeff, this.fractionField);
var integerPol = this.GetIntegerPol(multipliedPol);
result.Add(currentDegree, integerPol);
}
}
else
{
var value = squareFreeFactor.GetAsValue(this.fractionField);
if (!this.fractionField.IsMultiplicativeUnity(value))
{
if (this.fractionField.IsMultiplicativeUnity(independentCoeff))
{
independentCoeff = value;
}
else
{
independentCoeff = this.fractionField.Multiply(independentCoeff, value);
}
}
}
++currentDegree;
while (gcd.Degree > 0)
{
polyCoffactor = polynomDomain.Quo(polyCoffactor, gcd);
nextGcd = MathFunctions.GreatCommonDivisor(gcd, polyCoffactor, polynomDomain);
squareFreeFactor = polynomDomain.Quo(gcd, nextGcd);
gcd = nextGcd;
if (squareFreeFactor.Degree > 0)
{
var lcm = this.GetDenominatorLcm(squareFreeFactor, lagAlg);
if (this.integerNumber.IsMultiplicativeUnity(lcm))
{
var integerPol = this.GetIntegerPol(squareFreeFactor);
result.Add(currentDegree, integerPol);
}
else if (this.fractionField.IsAdditiveUnity(independentCoeff))
{
independentCoeff = new Fraction <CoeffType>(
this.integerNumber.MultiplicativeUnity,
MathFunctions.Power(lcm, currentDegree, this.integerNumber),
this.integerNumber);
var multipliable = new Fraction <CoeffType>(
lcm,
this.integerNumber.MultiplicativeUnity,
this.integerNumber);
var multipliedPol = squareFreeFactor.Multiply(independentCoeff, this.fractionField);
var integerPol = this.GetIntegerPol(multipliedPol);
result.Add(currentDegree, integerPol);
}
else
{
var multiplicationCoeff = new Fraction <CoeffType>(
this.integerNumber.MultiplicativeUnity,
MathFunctions.Power(lcm, currentDegree, this.integerNumber),
this.integerNumber);
independentCoeff = this.fractionField.Multiply(independentCoeff, multiplicationCoeff);
var multipliable = new Fraction <CoeffType>(
lcm,
this.integerNumber.MultiplicativeUnity,
this.integerNumber);
var multipliedPol = squareFreeFactor.Multiply(multipliable, this.fractionField);
var integerPol = this.GetIntegerPol(multipliedPol);
result.Add(currentDegree, integerPol);
}
}
else
{
var value = squareFreeFactor.GetAsValue(this.fractionField);
if (!this.fractionField.IsMultiplicativeUnity(value))
{
if (this.fractionField.IsMultiplicativeUnity(independentCoeff))
{
independentCoeff = value;
}
else
{
independentCoeff = this.fractionField.Multiply(independentCoeff, value);
}
}
}
++currentDegree;
}
var cofactorValue = polyCoffactor.GetAsValue(this.fractionField);
if (!this.fractionField.IsMultiplicativeUnity(cofactorValue))
{
if (this.fractionField.IsMultiplicativeUnity(independentCoeff))
{
independentCoeff = cofactorValue;
}
else
{
independentCoeff = this.fractionField.Multiply(independentCoeff, cofactorValue);
}
}
}
return(new SquareFreeFactorizationResult <Fraction <CoeffType>, CoeffType>(
independentCoeff,
result));
}
}
/// <summary>
/// Aplica o algoritmo de factorização livre de quadrados a um polinómio.
/// </summary>
/// <param name="data">O polinómio.</param>
/// <param name="field">O corpos responsável pelas operações sobre os coeficientes.</param>
/// <returns>O resultado da factorização livre de quadrados.</returns>
/// <exception cref="ArgumentNullException">Caso algum dos argumentos seja nulo.</exception>
public SquareFreeFactorizationResult <CoeffType, CoeffType> Run(
UnivariatePolynomialNormalForm <CoeffType> data,
IField <CoeffType> field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
else if (data == null)
{
throw new ArgumentNullException("data");
}
else
{
var independentCoeff = field.MultiplicativeUnity;
var result = new Dictionary <int, UnivariatePolynomialNormalForm <CoeffType> >();
var currentDegree = 1;
var polynomDomain = new UnivarPolynomEuclideanDomain <CoeffType>(data.VariableName, field);
var dataDerivative = data.GetPolynomialDerivative(field);
var gcd = this.GreatCommonDivisor(data, dataDerivative, polynomDomain, field);
if (polynomDomain.IsMultiplicativeUnity(gcd))
{
result.Add(currentDegree, data.Clone());
}
else
{
var polyCoffactor = polynomDomain.Quo(data, gcd);
var nextGcd = this.GreatCommonDivisor(gcd, polyCoffactor, polynomDomain, field);
var squareFreeFactor = polynomDomain.Quo(polyCoffactor, nextGcd);
polyCoffactor = gcd;
gcd = nextGcd;
if (squareFreeFactor.Degree > 0)
{
result.Add(currentDegree, squareFreeFactor);
}
else
{
var value = squareFreeFactor.GetAsValue(field);
if (!field.IsMultiplicativeUnity(value))
{
if (field.IsMultiplicativeUnity(independentCoeff))
{
independentCoeff = value;
}
else
{
independentCoeff = field.Multiply(independentCoeff, value);
}
}
}
++currentDegree;
while (gcd.Degree > 0)
{
polyCoffactor = polynomDomain.Quo(polyCoffactor, gcd);
nextGcd = this.GreatCommonDivisor(gcd, polyCoffactor, polynomDomain, field);
squareFreeFactor = polynomDomain.Quo(gcd, nextGcd);
gcd = nextGcd;
if (squareFreeFactor.Degree > 0)
{
result.Add(currentDegree, squareFreeFactor);
}
else
{
var value = squareFreeFactor.GetAsValue(field);
if (!field.IsMultiplicativeUnity(value))
{
if (field.IsMultiplicativeUnity(independentCoeff))
{
independentCoeff = value;
}
else
{
independentCoeff = field.Multiply(independentCoeff, value);
}
}
}
++currentDegree;
}
var cofactorValue = polyCoffactor.GetAsValue(field);
if (!field.IsMultiplicativeUnity(cofactorValue))
{
if (field.IsMultiplicativeUnity(independentCoeff))
{
independentCoeff = cofactorValue;
}
else
{
independentCoeff = field.Multiply(independentCoeff, cofactorValue);
}
}
}
return(new SquareFreeFactorizationResult <CoeffType, CoeffType>(
independentCoeff,
result));
}
}
/// <summary>
/// Permite processar as restantes combinações.
/// </summary>
/// <param name="modularFactors">Os factores modulares.</param>
/// <param name="integerFactors">Os factores inteiros.</param>
/// <param name="primePower">A potência de um número primo que servirá de módulo.</param>
/// <param name="halfPrimePower">A metade da potência do número primo.</param>
/// <param name="testValue">O valor de teste.</param>
/// <param name="combinationsNumber">O número máximo de polinómios nas combinações.</param>
/// <param name="modularPolynomialDomain">O corpo responsável pelas operações modulares.</param>
private void ProcessRemainingPolynomials(
List <UnivariatePolynomialNormalForm <CoeffType> > modularFactors,
List <UnivariatePolynomialNormalForm <CoeffType> > integerFactors,
CoeffType primePower,
CoeffType halfPrimePower,
CoeffType testValue,
int combinationsNumber,
UnivarPolynomEuclideanDomain <CoeffType> modularPolynomialDomain)
{
if (combinationsNumber > 1 && modularFactors.Count > 1)
{
var modularProduct = default(UnivariatePolynomialNormalForm <CoeffType>);
var currentCombinationNumber = 2;
var productStack = new Stack <UnivariatePolynomialNormalForm <CoeffType> >();
productStack.Push(modularFactors[0]);
var pointers = new Stack <int>();
pointers.Push(0);
pointers.Push(1);
var state = 0;
while (state != -1)
{
if (state == 0)
{
if (pointers.Count == currentCombinationNumber)
{
var topPointer = pointers.Pop();
var topPol = productStack.Pop();
// Obtém o produto de todos os polinómios.
var currentPol = modularPolynomialDomain.Multiply(
topPol,
modularFactors[topPointer]);
currentPol = currentPol.ApplyFunction(
c => this.GetSymmetricRemainder(
c,
primePower,
halfPrimePower),
this.integerNumber);
// Compara as normas com o valor de teste
var firstNorm = this.GetPlynomialNorm(currentPol);
if (this.integerNumber.Compare(firstNorm, testValue) < 0)
{
if (modularProduct == null)
{
modularProduct = this.ComputeModularProduct(
modularFactors,
modularPolynomialDomain);
}
var coPol = modularPolynomialDomain.Quo(
modularProduct,
currentPol);
coPol = coPol.ApplyFunction(
c => this.GetSymmetricRemainder(
c,
primePower,
halfPrimePower),
this.integerNumber);
var secondNorm = this.GetPlynomialNorm(coPol);
var normProd = this.integerNumber.Multiply(firstNorm, secondNorm);
if (this.integerNumber.Compare(normProd, testValue) < 0)
{
integerFactors.Add(currentPol);
modularFactors.RemoveAt(topPointer);
while (pointers.Count > 0)
{
var removeIndex = pointers.Pop();
modularFactors.RemoveAt(removeIndex);
}
productStack.Clear();
if (modularFactors.Count < currentCombinationNumber)
{
state = -1;
}
else
{
productStack.Push(modularFactors[0]);
pointers.Push(0);
pointers.Push(1);
}
}
else
{
productStack.Push(topPol);
pointers.Push(topPointer);
state = 1;
}
}
else
{
productStack.Push(topPol);
pointers.Push(topPointer);
state = 1;
}
}
else
{
var topPointer = pointers.Pop();
var topPol = productStack.Pop();
var currentPol = modularPolynomialDomain.Multiply(
topPol,
modularFactors[topPointer]);
currentPol = currentPol.ApplyFunction(
c => this.GetSymmetricRemainder(
c,
primePower,
halfPrimePower),
this.integerNumber);
productStack.Push(topPol);
productStack.Push(currentPol);
pointers.Push(topPointer);
pointers.Push(topPointer + 1);
}
}
else if (state == 1)
{
var pointerLimit = modularFactors.Count - combinationsNumber + pointers.Count + 1;
if (pointers.Count > 1)
{
var topPointer = pointers.Pop();
++topPointer;
if (topPointer < pointerLimit)
{
pointers.Push(topPointer);
state = 0;
}
else
{
productStack.Pop();
}
}
else
{
var topPointer = pointers.Pop();
++topPointer;
if (topPointer < pointerLimit)
{
pointers.Push(topPointer);
productStack.Push(modularFactors[topPointer]);
pointers.Push(topPointer + 1);
}
else
{
++currentCombinationNumber;
if (currentCombinationNumber < combinationsNumber)
{
state = -1;
}
else if (modularFactors.Count < currentCombinationNumber)
{
state = -1;
}
else
{
pointers.Push(0);
pointers.Push(1);
productStack.Push(modularFactors[0]);
}
}
}
}
}
}
}
