/// <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>
/// 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>
/// Contrói a árvore de factores.
/// </summary>
/// <param name="multiFactorLiftingStatus">Contém a factorização que se pretende elevar.</param>
/// <param name="modularField">O corpo modular sobre o qual são efectuadas as operações.</param>
/// <returns>A árvore.</returns>
private Tree <LinearLiftingStatus <CoeffType> > MountFactorTree(
MultiFactorLiftingStatus <CoeffType> multiFactorLiftingStatus,
IModularField <CoeffType> modularField)
{
var tree = new Tree <LinearLiftingStatus <CoeffType> >();
var currentNodes = new List <TreeNode <LinearLiftingStatus <CoeffType> > >();
var factorEnumerator = multiFactorLiftingStatus.Factorization.Factors.GetEnumerator();
if (factorEnumerator.MoveNext())
{
var factor = factorEnumerator.Current;
if (!modularField.IsMultiplicativeUnity(multiFactorLiftingStatus.Factorization.IndependentCoeff))
{
factor = factor.Multiply(multiFactorLiftingStatus.Factorization.IndependentCoeff, modularField);
}
currentNodes.Add(new TreeNode <LinearLiftingStatus <CoeffType> >(
new LinearLiftingStatus <CoeffType>(factor, modularField.Module),
tree,
null));
while (factorEnumerator.MoveNext())
{
factor = factorEnumerator.Current;
currentNodes.Add(new TreeNode <LinearLiftingStatus <CoeffType> >(
new LinearLiftingStatus <CoeffType>(factor, modularField.Module),
tree,
null));
}
}
if (currentNodes.Count < 2)
{
return(null);
}
else
{
var temporaryNodes = new List <TreeNode <LinearLiftingStatus <CoeffType> > >();
var count = 0;
while (currentNodes.Count > 1)
{
temporaryNodes.Clear();
var i = 0;
while (i < currentNodes.Count)
{
var parentNode = default(TreeNode <LinearLiftingStatus <CoeffType> >);
var first = currentNodes[i];
++i;
if (i < currentNodes.Count)
{
var second = currentNodes[i];
var product = first.NodeObject.Polynom.Multiply(
second.NodeObject.Polynom,
modularField);
var liftingStatus = new LinearLiftingStatus <CoeffType>(
product,
first.NodeObject.Polynom,
second.NodeObject.Polynom,
modularField.Module);
parentNode = new TreeNode <LinearLiftingStatus <CoeffType> >(
liftingStatus,
tree,
null);
first.InternalParent = parentNode;
second.InternalParent = parentNode;
parentNode.Add(first);
parentNode.Add(second);
++i;
}
else
{
parentNode = first;
}
temporaryNodes.Add(parentNode);
}
var swap = currentNodes;
currentNodes = temporaryNodes;
temporaryNodes = swap;
++count;
}
var lastNode = currentNodes[0];
tree.InternalRootNode = lastNode;
return(tree);
}
}