private void CombineTerms(string[] operators)
{
foreach (var element in Stack)
{
(element as Term)?.CombineTerms(operators);
}
if (NeedSubTerms(operators) == false)
return;
var startIndex = 0;
while (startIndex < Stack.Count)
{
startIndex = FindOperator(startIndex, operators);
if (startIndex < 0)
return;
var newterm = new Term {Parent = this};
startIndex--;
var startpoint = startIndex;
while (startIndex < Stack.Count)
{
var item = Stack[startIndex];
if (item is EquationValue)
{
newterm.Add(item);
startIndex++;
}
if (item is Operator)
{
var op = item as Operator;
if (op == null || operators.Contains(op.Value) == false)
{
Stack.RemoveRange(startpoint, newterm.Stack.Count);
Stack.Insert(startpoint, newterm);
break;
}
newterm.Add(item);
startIndex++;
}
if (startIndex >= Stack.Count)
{
Stack.RemoveRange(startpoint, newterm.Stack.Count);
Stack.Insert(startpoint, newterm);
return;
}
}
}
}
private void CombineTopDown()
{
// traitement spécial de l'opérateur de puissance. Si un opérateur est élevé à la puissance d'une puissance, la puissance doit être calculée en premier.
// ex. 2^2^3 = 2^(2^3) = 256. Ceci est réalisé en combinant de droite à gauche (ou de haut en bas)
var operatorCh = "^";
foreach (var element in Stack)
{
(element as Term)?.CombineTopDown();
}
var index = Stack.Count - 1;
while (index > 0)
{
var op = Stack[index] as Operator;
index--;
if (op == null || op.Value != operatorCh)
continue;
var left = Stack[index];
var right = Stack[index + 2];
var newterm = new Term {Parent = this};
newterm.Add(left);
newterm.Add(op);
newterm.Add(right);
if (((EquationValue) left).Signed)
{
((EquationValue) left).Signed = false;
newterm.Signed = true;
}
Stack.RemoveRange(index, newterm.Stack.Count);
Stack.Insert(index, newterm);
}
}
