/// <summary>
/// Парсинг математического выражения
/// </summary>
/// <param name="mathExpression"></param>
/// <param name="variables"></param>
/// <returns>MathTryParseResult</returns>
public MathTryParseResult TryParse(string mathExpression, ICollection <Variable> variables = null)
{
var defaultResult = new MathTryParseResult()
{
IsSuccessfulCreated = false,
InputString = mathExpression
};
var parameters = new MathParserTryParseParameters(mathExpression, variables);
var errorMessage = CheckTryParseParameters(parameters);
if (!string.IsNullOrEmpty(errorMessage))
{
defaultResult = defaultResult with {
ErrorMessage = errorMessage
};
return(defaultResult);
}
var tryParseResult = TryParseExpression(parameters.MathExpression, parameters.Variables);
tryParseResult = tryParseResult with {
InputString = defaultResult.InputString
};
return(tryParseResult);
}
public Expression Create(MathTryParseResult parseResult, List <Variable> variables, List <EgorLucky.MathParser.Parameter> parameters, double result)
{
var expression = _mapper.Map <Expression>(parseResult);
//data access layer parameter
var dalParameters = _mapper.Map <List <DAL.Parameter> >(variables);
var point = new Point
{
Result = result,
Expression = expression
};
expression.Parameters = new List <DAL.Parameter>();
expression.Parameters.AddRange(dalParameters);
expression.Points = new List <Point>();
expression.Points.Add(point);
foreach (var param in parameters)
{
var parameterValue = new ParameterValue
{
Point = point,
Parameter = dalParameters
.Where(p => p.Name == param.VariableName)
.FirstOrDefault(),
Value = param.Value
};
parameterValue.Parameter.Values = new List <ParameterValue>();
parameterValue.Parameter.Values.Add(parameterValue);
point.Coordinates = new List <ParameterValue>();
point.Coordinates.Add(parameterValue);
}
return(expression);
}
public MathTryParseResult TryParse(string expression, ICollection <Variable> variables = null)
{
var result = new Product()
{
Variables = variables
};
var balance = 0;
var factor = "";
var counter = 0;
var mathTryParseResult = new MathTryParseResult()
{
ErrorMessage = "This is not product: " + expression,
IsSuccessfulCreated = false
};
if (!expression.Contains("*") && !expression.StartsWith("-") ||
expression.Last() == '*')
{
return(mathTryParseResult);
}
if (expression.StartsWith("-") && !char.IsDigit(expression[1]))
{
expression = "-1*" + expression.Substring(1);
}
foreach (var ch in expression)
{
counter++;
if (ch == '(')
{
balance--;
}
if (ch == ')')
{
balance++;
}
if (ch == '*' && balance == 0)
{
var parseResult = _mathParser.TryParse(factor, variables);
if (!parseResult.IsSuccessfulCreated)
{
return(parseResult);
}
if (parseResult.Expression is Sum && !Validate.IsExpressionInBrackets(factor))
{
return(mathTryParseResult);
}
result.Factors.Add(parseResult.Expression);
factor = "";
continue;
}
factor += ch;
if (counter == expression.Length)
{
if (result.Factors.Count == 0)
{
return(mathTryParseResult);
}
var parseResult = _mathParser.TryParse(factor, variables);
if (!parseResult.IsSuccessfulCreated)
{
return(parseResult);
}
if (parseResult.Expression is Sum && !Validate.IsExpressionInBrackets(factor))
{
return(mathTryParseResult);
}
result.Factors.Add(parseResult.Expression);
continue;
}
}
if (result.Factors.Count == 1)
{
return(mathTryParseResult);
}
return(new MathTryParseResult
{
IsSuccessfulCreated = true,
Expression = result
});
}
public MathTryParseResult TryParse(string expression, ICollection <Variable> variables = null)
{
var mathTryParseResult = new MathTryParseResult()
{
ErrorMessage = $"This is not {Name}: " + expression,
IsSuccessfulCreated = false
};
if (!expression.StartsWith(Name))
{
return(mathTryParseResult);
}
var argsString = expression.Substring(Name.Length);
if (_argCount > 1 && !Validate.IsExpressionInBrackets(argsString))
{
mathTryParseResult = mathTryParseResult with {
ErrorMessage = $"Incorrect arguments in {Name}"
};
return(mathTryParseResult);
}
if (_argCount > 1)
{
argsString = argsString.Remove(0, 1);
argsString = argsString.Remove(argsString.Length - 1, 1);
}
var arguments = new List <IExpression>();
var balance = 0;
var argumentString = "";
var counter = 0;
if (!expression.Contains(",") && _argCount != 1 ||
expression.EndsWith(","))
{
return(mathTryParseResult);
}
foreach (var ch in argsString)
{
counter++;
if (ch == '(')
{
balance--;
}
if (ch == ')')
{
balance++;
}
if (ch == ',' && balance == 0 && counter != 1)
{
var parseResult = _mathParser.TryParse(argumentString, variables);
if (!parseResult.IsSuccessfulCreated)
{
return(parseResult);
}
arguments.Add(parseResult.Expression);
argumentString = "";
continue;
}
argumentString += ch;
if (counter == argsString.Length)
{
var parseResult = _mathParser.TryParse(argumentString, variables);
if (!parseResult.IsSuccessfulCreated)
{
return(parseResult);
}
arguments.Add(parseResult.Expression);
}
}
if (arguments.Count != _argCount)
{
return(mathTryParseResult);
}
var result = new Function()
{
Arguments = arguments,
Variables = variables
};
return(new MathTryParseResult
{
IsSuccessfulCreated = true,
Expression = result
});
}
}
public MathTryParseResult TryParse(string expression, ICollection <Variable> variables = null)
{
var mathTryParseResult = new MathTryParseResult()
{
ErrorMessage = "This is not fraction: " + expression,
IsSuccessfulCreated = false
};
if (!expression.Contains("/") || expression.EndsWith("/"))
{
return(mathTryParseResult);
}
for (var i = expression.Length - 1; i >= 0; i--)
{
var ch = expression[i];
if (ch != '/')
{
continue;
}
else if (i != 0 && i != expression.Length - 1)
{
var numerator = expression.Substring(0, i);
var denominator = expression.Substring(i + 1);
if (Validate.IsBracketsAreBalanced(numerator) &&
Validate.IsBracketsAreBalanced(denominator))
{
var numeratorParseResult = _mathParser.TryParse(numerator, variables);
if (!numeratorParseResult.IsSuccessfulCreated)
{
return(numeratorParseResult);
}
var denominatorParseResult = _mathParser.TryParse(denominator, variables);
if (!denominatorParseResult.IsSuccessfulCreated)
{
return(denominatorParseResult);
}
var types = new Type[] { typeof(Sum), typeof(Product) };
if (types.Contains(numeratorParseResult.Expression.GetType()) &&
!Validate.IsExpressionInBrackets(numerator))
{
return(mathTryParseResult);
}
if (types.Contains(denominatorParseResult.Expression.GetType()) &&
!Validate.IsExpressionInBrackets(denominator))
{
return(mathTryParseResult);
}
return(new MathTryParseResult
{
IsSuccessfulCreated = true,
ErrorMessage = "",
Expression = new Fraction()
{
Numerator = numeratorParseResult.Expression,
Denominator = denominatorParseResult.Expression,
Variables = variables
}
});
}
}
}
return(mathTryParseResult);
}
public MathTryParseResult TryParse(string expression, ICollection <Variable> variables = null)
{
var mathTryParseResult = new MathTryParseResult()
{
ErrorMessage = "This is not pow: " + expression,
IsSuccessfulCreated = false
};
if (!expression.Contains("^") || expression.EndsWith("^"))
{
return(mathTryParseResult);
}
var i = -1;
foreach (var ch in expression)
{
i++;
if (ch != '^')
{
continue;
}
else if (i != 0 && i != expression.Length - 1)
{
var @base = expression.Substring(0, i);
var log = expression.Substring(i + 1);
if (Validate.IsBracketsAreBalanced(@base) && Validate.IsBracketsAreBalanced(log))
{
var baseParseResult = _mathParser.TryParse(@base, variables);
if (!baseParseResult.IsSuccessfulCreated)
{
return(baseParseResult);
}
var bracketTypes = new Type[] { typeof(Sum), typeof(Product) };
if (bracketTypes.Contains(baseParseResult.Expression.GetType()) &&
!Validate.IsExpressionInBrackets(@base))
{
return(mathTryParseResult);
}
var logParseResult = _mathParser.TryParse(log, variables);
if (!logParseResult.IsSuccessfulCreated)
{
return(mathTryParseResult);
}
if (bracketTypes.Contains(logParseResult.Expression.GetType()) &&
!Validate.IsExpressionInBrackets(log))
{
return(mathTryParseResult);
}
return(new MathTryParseResult
{
IsSuccessfulCreated = true,
ErrorMessage = "",
Expression = new Pow()
{
Base = baseParseResult.Expression,
Log = logParseResult.Expression,
Variables = variables
}
});
}
}
}
return(mathTryParseResult);
}
public MathTryParseResult TryParse(string expression, ICollection <Variable> variables = null)
{
var sum = new Sum()
{
Variables = variables
};
var balance = 0;
var term = "";
var counter = 0;
var mathTryParseResult = new MathTryParseResult()
{
ErrorMessage = "This is not sum: " + expression,
IsSuccessfulCreated = false
};
if (!expression.Contains("+") && !expression.Contains("-") ||
(expression.Last() == '+' || expression.Last() == '-'))
{
return(mathTryParseResult);
}
foreach (var ch in expression)
{
counter++;
if (ch == '(')
{
balance--;
}
if (ch == ')')
{
balance++;
}
if ((ch == '+' || ch == '-') && balance == 0 && counter != 1)
{
var parseResult = _mathParser.TryParse(term, variables);
if (!parseResult.IsSuccessfulCreated)
{
return(parseResult);
}
sum.Terms.Add(parseResult.Expression);
term = ch == '-'? "-":"";
continue;
}
term += ch;
if (counter == expression.Length)
{
if (sum.Terms.Count == 0)
{
return(mathTryParseResult);
}
var parseResult = _mathParser.TryParse(term, variables);
if (!parseResult.IsSuccessfulCreated)
{
return(parseResult);
}
sum.Terms.Add(parseResult.Expression);
}
}
if (sum.Terms.Count == 1)
{
return(mathTryParseResult);
}
return(new MathTryParseResult
{
IsSuccessfulCreated = true,
Expression = sum
});
}
