/// <summary>
/// Aplica o método da factorização em corpos finitos ao polinómio simples.
/// </summary>
/// <param name="polynom">O polinómio simples.</param>
/// <param name="integerModule">O corpo responsável pelas operações sobre os coeficientes.</param>
/// <param name="polynomField">O corpo responsável pelo produto de polinómios.</param>
/// <param name="bachetBezoutAlgorithm">O objecto responsável pelo algoritmo de máximo divisor comum.</param>
/// <returns>A lista dos factores.</returns>
private FiniteFieldPolynomialFactorizationResult <CoeffType> Factorize(
UnivariatePolynomialNormalForm <CoeffType> polynom,
IModularField <CoeffType> integerModule,
UnivarPolynomEuclideanDomain <CoeffType> polynomField,
LagrangeAlgorithm <UnivariatePolynomialNormalForm <CoeffType> > bachetBezoutAlgorithm)
{
var result = new List <UnivariatePolynomialNormalForm <CoeffType> >();
var polynomialStack = new Stack <UnivariatePolynomialNormalForm <CoeffType> >();
var processedPols = this.Process(
polynom,
result,
integerModule,
polynomField,
bachetBezoutAlgorithm);
foreach (var processedPol in processedPols)
{
polynomialStack.Push(processedPol);
}
while (polynomialStack.Count > 0)
{
var topPolynomial = polynomialStack.Pop();
processedPols = this.Process(
topPolynomial,
result,
integerModule,
polynomField,
bachetBezoutAlgorithm);
foreach (var processedPol in processedPols)
{
polynomialStack.Push(processedPol);
}
}
for (int i = 0; i < result.Count; ++i)
{
var leadingMon = result[i].GetLeadingCoefficient(integerModule);
if (!integerModule.IsMultiplicativeUnity(leadingMon))
{
var invLeadingMon = integerModule.MultiplicativeInverse(leadingMon);
result[i] = result[i].ApplyFunction(
c => integerModule.Multiply(c, invLeadingMon),
integerModule);
}
}
var mainLeadingMon = polynom.GetLeadingCoefficient(integerModule);
return(new FiniteFieldPolynomialFactorizationResult <CoeffType>(
mainLeadingMon,
result,
polynom));
}
/// <summary>
/// Cria instâncias de objectos do tipo <see cref="ModularBigIntegerField"/>.
/// </summary>
/// <remarks>
/// A determinação da inversa multiplicativa é efectuada por intermédio de algoritmos relacionados
/// com o algoritmo que permite determinar o máximo divisor comum. Neste caso, é necessário indicar
/// qual será o algoritmo responsável por essa operação.
/// </remarks>
/// <param name="module">O módulo.</param>
/// <exception cref="ArgumentException">
/// Se o módulo for 0, 1, ou -1.
/// </exception>
public ModularBigIntegerField(BigInteger module)
{
if (module == 0 || module == 1 || module == -1)
{
throw new ArgumentException("Module can't neither 0, 1 nor -1.");
}
else
{
this.module = module;
this.inverseAlgorithm = new LagrangeAlgorithm <BigInteger>(
new BigIntegerDomain());
}
}
/// <summary>
/// Cria instâncias de objectos do tipo <see cref="ModularSymmetricIntField"/>.
/// </summary>
/// <remarks>
/// A determinação da inversa multiplicativa é efectuada por intermédio de algoritmos relacionados
/// com o algoritmo que permite determinar o máximo divisor comum. Neste caso, é necessário indicar
/// qual será o algoritmo responsável por essa operação.
/// </remarks>
/// <param name="modulus">O módulo.</param>
/// <exception cref="ArgumentException">
/// Se o módulo for 0, 1 ou -1.
/// </exception>
public ModularSymmetricIntField(int modulus)
{
if (modulus == 0 || modulus == 1 || modulus == -1)
{
throw new ArgumentException("Module can't neither 0, 1 nor -1.");
}
else
{
this.modulus = modulus;
this.halfModulus = modulus >> 1;
this.inverseAlgorithm = new LagrangeAlgorithm <int>(
new IntegerDomain());
}
}
/// <summary>
/// Inicialia o estado do algoritmo caso seja aplicável.
/// </summary>
/// <param name="status">O estado a ser tratado.</param>
/// <param name="polynomialDomain">O domínio polinomial.</param>
/// <param name="modularField">O corpo modular.</param>
/// <returns>Verdadeiro caso se verifique alguma inicialização e falso caso contrário.</returns>
/// <exception cref="ArgumentNullException">Se o estado for nulo.</exception>
private bool Initialize(
LinearLiftingStatus <T> status,
IEuclidenDomain <UnivariatePolynomialNormalForm <T> > polynomialDomain,
IModularField <T> modularField)
{
var result = false;
if (status.NotInitialized)
{
var leadingCoeff = status.W1Factor.GetLeadingCoefficient(modularField);
if (modularField.IsMultiplicativeUnity(leadingCoeff))
{
result = true;
var domainAlg = new LagrangeAlgorithm <UnivariatePolynomialNormalForm <T> >(
polynomialDomain);
var domainResult = domainAlg.Run(status.U1Factor, status.W1Factor);
var invGcd = modularField.MultiplicativeInverse(
domainResult.GreatestCommonDivisor.GetAsValue(modularField));
status.SPol = domainResult.FirstFactor.Multiply(
invGcd,
modularField);
status.TPol = domainResult.SecondFactor.Multiply(
invGcd,
modularField);
status.UFactor = status.U1Factor;
status.WFactor = status.W1Factor;
modularField.Module = this.integerNumber.Multiply(modularField.Module, modularField.Module);
status.InitializedFactorizationModulus = modularField.Module;
var ePol = polynomialDomain.Multiply(status.UFactor, status.WFactor);
ePol = polynomialDomain.Add(
status.Polynom,
polynomialDomain.AdditiveInverse(ePol));
status.EPol = ePol;
status.NotInitialized = false;
}
else
{
throw new MathematicsException(
"The W factor in lifting algorithm must be a monic polynomial.");
}
}
return(result);
}
/// <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);
}
/// <summary>
/// Processa o polinómio determinando os respectivos factores.
/// </summary>
/// <remarks>
/// Os factores constantes são ignorados, os factores lineares são anexados ao resultado e os factores
/// cujos graus são superiores são retornados para futuro processamento. Se o polinómio a ser processado
/// for irredutível, é adicionado ao resultado.
/// </remarks>
/// <param name="polynom">O polinómio a ser processado.</param>
/// <param name="result">O contentor dos factores sucessivamente processados.</param>
/// <param name="integerModule">O objecto responsável pelas operações sobre inteiros.</param>
/// <param name="polynomField">O objecto responsável pelas operações sobre os polinómios.</param>
/// <param name="inverseAlgorithm">O algoritmo inverso.</param>
/// <returns></returns>
List <UnivariatePolynomialNormalForm <CoeffType> > Process(
UnivariatePolynomialNormalForm <CoeffType> polynom,
List <UnivariatePolynomialNormalForm <CoeffType> > result,
IModularField <CoeffType> integerModule,
UnivarPolynomEuclideanDomain <CoeffType> polynomField,
LagrangeAlgorithm <UnivariatePolynomialNormalForm <CoeffType> > inverseAlgorithm)
{
var resultPol = new List <UnivariatePolynomialNormalForm <CoeffType> >();
if (polynom.Degree < 2)
{
result.Add(polynom);
}
else
{
var module = new ModularBachetBezoutField <UnivariatePolynomialNormalForm <CoeffType> >(
polynom,
inverseAlgorithm);
var degree = polynom.Degree;
var arrayMatrix = new ArrayMathMatrix <CoeffType>(degree, degree, integerModule.AdditiveUnity);
arrayMatrix[0, 0] = integerModule.AdditiveUnity;
var pol = new UnivariatePolynomialNormalForm <CoeffType>(
integerModule.MultiplicativeUnity,
1,
polynom.VariableName,
integerModule);
var integerModuleValue = this.integerNumber.ConvertToInt(integerModule.Module);
pol = MathFunctions.Power(pol, integerModuleValue, module);
foreach (var term in pol)
{
arrayMatrix[term.Key, 1] = term.Value;
}
var auxPol = pol;
for (int i = 2; i < degree; ++i)
{
auxPol = module.Multiply(auxPol, pol);
foreach (var term in auxPol)
{
arrayMatrix[term.Key, i] = term.Value;
}
}
for (int i = 1; i < degree; ++i)
{
var value = arrayMatrix[i, i];
value = integerModule.Add(
value,
integerModule.AdditiveInverse(integerModule.MultiplicativeUnity));
arrayMatrix[i, i] = value;
}
var emtpyMatrix = new ZeroMatrix <CoeffType>(degree, 1, integerModule);
var linearSystemSolution = this.linearSystemSolver.Run(arrayMatrix, emtpyMatrix);
var numberOfFactors = linearSystemSolution.VectorSpaceBasis.Count;
if (numberOfFactors < 2)
{
result.Add(polynom);
}
else
{
var hPol = default(UnivariatePolynomialNormalForm <CoeffType>);
var linearSystemCount = linearSystemSolution.VectorSpaceBasis.Count;
for (int i = 0; i < linearSystemCount; ++i)
{
var currentBaseSolution = linearSystemSolution.VectorSpaceBasis[i];
var rowsLength = currentBaseSolution.Length;
for (int j = 1; j < rowsLength; ++j)
{
if (!integerModule.IsAdditiveUnity(currentBaseSolution[j]))
{
hPol = this.GetPolynomial(currentBaseSolution, integerModule, polynom.VariableName);
j = rowsLength;
}
if (hPol != null)
{
j = rowsLength;
}
}
if (hPol != null)
{
i = linearSystemCount;
}
}
for (int i = 0, k = 0; k < numberOfFactors && i < integerModuleValue; ++i)
{
var converted = this.integerNumber.MapFrom(i);
var currentPol = MathFunctions.GreatCommonDivisor(
polynom,
hPol.Subtract(converted, integerModule),
polynomField);
var currentDegree = currentPol.Degree;
if (currentDegree == 1)
{
result.Add(currentPol);
++k;
}
else if (currentDegree > 1)
{
resultPol.Add(currentPol);
++k;
}
}
}
}
return(resultPol);
}
/// <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));
}
}
