private IMathComponent[] ConvertToComponents(string[] expressionArray, ConstructNewParser instanceCreator)
{
IMathComponent[] mathComponents = new IMathComponent[expressionArray.Length];
for (int i = 0; i < expressionArray.Length; i++)
{
IExpressionParser parser = instanceCreator.Invoke();
Expression expression = parser.Parse(expressionArray[i], instanceCreator);
mathComponents[i] = expression;
}
return(mathComponents);
}
private void GroupByPriority(int priority)
{
if (components.First == null)
{
return;
}
var node = components.First.Next; // skipping to second component, which should be operator component
if (node == null)
{
return;
}
while (true)
{
IMathComponent component = node.Value;
if (component is OperatorComponent opComponent)
{
var prevComponent = node.Previous;
var nextComponent = node.Next;
if (nextComponent == null)
{
throw new InvalidExpressionSyntaxException("Invalid expression");
}
var nextOperator = nextComponent.Next;
if ((int)opComponent.Operator.ExecutionPriority == priority)
{
OperationComponent operation = new OperationComponent(new OperatorInstance(prevComponent.Value, nextComponent.Value, opComponent.Operator));
components.Remove(prevComponent);
components.Remove(nextComponent);
components.AddBefore(node, operation);
components.Remove(node);
}
if (nextOperator == null)
{
break;
}
node = nextOperator;
}
else
{
throw new InvalidExpressionSyntaxException("Operator expected");
}
}
}
public Utility(
ICompactComponent compact,
IFunctionComponent function,
IMathComponent math,
IObjectComponent obj,
IStringComponent str)
{
if (compact == null)
{
throw new ArgumentNullException("compact");
}
if (function == null)
{
throw new ArgumentNullException("function");
}
if (math == null)
{
throw new ArgumentNullException("math");
}
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (str == null)
{
throw new ArgumentNullException("str");
}
_compact = compact;
_math = math;
_function = function;
_object = obj;
_string = str;
}
/// <summary>
/// Constructs new expression object from internal data structure.
/// </summary>
/// <returns>New <see cref="Expressions.Expression"/> component</returns>
public Expression Build()
{
IMathComponent tree = CreateComponentTree();
return(new Expression(tree));
}
public OperatorInstance(IMathComponent number1, IMathComponent number2, Operator @operator)
{
Operator = @operator;
this.number1 = number1;
this.number2 = number2;
}
public PartitionComponent(IMathComponent math)
{
_math = math;
}
/// <summary>
/// Combines two math component and return number
/// </summary>
/// <param name="input1">Math component on left side of this operator</param>
/// <param name="input2">Math component of right side of this operator</param>
/// <returns>Result of this operator's operation</returns>
public double Combine(IMathComponent input1, IMathComponent input2)
{
return(OperatorFunction.Invoke(input1, input2));
}
public Expression(IMathComponent componentTree)
{
this.componentTree = componentTree;
}
