/// <summary>
/// Gets all available (not in the brackets) functions.
/// </summary>
/// <param name="expression">The expression to get all variable functions there</param>
/// <param name="intervals">List of intervals, where functions are not available</param>
/// <returns>List of standard functions instances</returns>
public List <StandardFunction> GetStandardFunctions(string expression, List <Interval> intervals)
{
List <StandardFunction> standardFunctions = new List <StandardFunction>();
foreach (string function in StandardFunction.WellKnownFunctions)
{
List <int> funcIndexes = ExpressionParsingHelpers.GetAllSubstringIndexes(expression, function);
foreach (int idx in funcIndexes)
{
if (!Interval.BelongsToIntevals(idx, intervals))
{
standardFunctions.Add(new StandardFunction(idx, function));
}
}
}
return(standardFunctions);
}
/// <summary>
/// Constructor validates the input expression and defines the expression tree
/// </summary>
/// <param name="expression">Initial expression</param>
/// <param name="variables"></param>
public Expression(string expression, List <Variable> variables)
{
if (ExpressionParsingHelpers.CheckBracketBalance(expression))
{
this.parent = new Tree();
this.Variables = variables;
expression = ExpressionParsingHelpers.RemoveSpaces(expression);
expression = ExpressionParsingHelpers.DeleteEmptyBrackets(expression);
expression = ExpressionParsingHelpers.AddMinusOne(expression);
this.ExpressionString = expression;
this.DefineLeaves(parent, this.ExpressionString);
}
else
{
throw new Exception("Ballance of brackets is invalid");
}
}
public void DefineLeaves(Tree parent, string expression)
{
string expressionPrev;
do
{
expressionPrev = expression;
expression = ExpressionParsingHelpers.RemoveWrappedBrackets(expression);
} while (expression != expressionPrev);
List <StandardFunction> funcs = new List <StandardFunction>();
List <Operator> operators = this.GetOperators(expression, '-', '+');
if (operators.Count == 0)
{
operators = this.GetOperators(expression, '*');
if (operators.Count == 0)
{
operators = this.GetOperators(expression, '/');
if (operators.Count == 0)
{
operators = this.GetOperators(expression, '^');
if (operators.Count == 0)
{
List <Interval> intervals = this.GetIntervals(expression);
funcs = this.GetStandardFunctions(expression, intervals);
if (funcs.Count == 0 && Variable.IsNumberOrVariable(expression, this.Variables) == EssenceType.Nothing)
{
throw new Exception("No operators, no functions, no variables were found in string: " + expression);
}
}
}
}
}
EssenceType type;
if (operators.Count > 1)
{
type = EssenceType.Cascade;
}
else if (operators.Count > 0)
{
type = EssenceType.Operator;
}
else if (funcs.Count > 0)
{
type = EssenceType.StandardFunction;
}
else if (Variable.IsNumberOrVariable(expression, this.Variables) != EssenceType.Nothing)
{
type = Variable.IsNumberOrVariable(expression, this.Variables);
}
else
{
throw new Exception("Can't determine type of operator/function/Variable/Number");
}
if (type == EssenceType.Operator)
{
parent.DataType = type;
parent.Data = operators[0].OperatorName.ToString();
parent.StringLeft = ExpressionParsingHelpers.COPY(expression, 0, operators[0].Idx - 1);
parent.StringRight = ExpressionParsingHelpers.COPY(expression, operators[0].Idx + 1, expression.Length - 1);
parent.LeftOperand = 0;
parent.RightOperand = 0;
parent.Cascade = null;
parent.CascadeOperators = null;
parent.LeftLeave = new Tree();
parent.RightLeave = new Tree();
this.DefineLeaves(parent.LeftLeave, parent.StringLeft);
this.DefineLeaves(parent.RightLeave, parent.StringRight);
}
else if (type == EssenceType.StandardFunction)
{
parent.DataType = type;
parent.Data = funcs[0].Name;
parent.StringLeft = null;
parent.StringRight = ExpressionParsingHelpers.COPY(expression, funcs[0].Idx + funcs[0].Name.Length, expression.Length - 1);
parent.LeftOperand = 0;
parent.RightOperand = 0;
parent.Cascade = null;
parent.CascadeOperators = null;
parent.LeftLeave = null;
parent.RightLeave = new Tree();
this.DefineLeaves(parent.RightLeave, parent.StringRight);
}
else if (type == EssenceType.Variable || type == EssenceType.Number)
{
parent.DataType = type;
parent.Data = expression;
parent.StringLeft = null;
parent.StringRight = null;
parent.LeftOperand = 0;
parent.RightOperand = 0;
parent.Cascade = null;
parent.CascadeOperators = null;
parent.LeftLeave = null;
parent.RightLeave = null;
}
else if (type == EssenceType.Cascade)
{
parent.DataType = type;
parent.Data = expression;
parent.StringLeft = null;
parent.StringRight = null;
parent.LeftOperand = 0;
parent.RightOperand = 0;
parent.LeftLeave = null;
parent.RightLeave = null;
List <string> subExpressions = Operator.SplitExpressionByOperators(operators, expression);
parent.Cascade = new List <Tree>();
parent.CascadeOperators = operators;
foreach (string subExpression in subExpressions)
{
Tree subTree = new Tree();
this.DefineLeaves(subTree, subExpression);
parent.Cascade.Add(subTree);
}
}
}
