public void ParseManyBrackets()
{
var expression = "(((tg(x)^2)))";
var parameter = new Parameter
{
VariableName = "x",
Value = 0
};
var variables = new List <Variable>()
{
parameter.GetVariable()
};
var result = _parser.TryParse(expression, variables);
var computedResult = 0d;
if (result.IsSuccessfulCreated)
{
computedResult = result.Expression.ComputeValue(new List <Parameter>()
{
parameter
});
}
var expectedResult = Math.Pow(Math.Tan(parameter.Value), 2);
Assert.True(result.IsSuccessfulCreated);
Assert.Equal("Pow", result.Expression.Name);
Assert.Equal(expectedResult, computedResult);
}
public async Task <ComputeExpressionResponseModel> ComputeExpression(ComputeExpressionRequestModel request)
{
var errorMessage = MathParserServiceParametersChecker.CheckForComputeExpression(request, 5);
if (!string.IsNullOrEmpty(errorMessage))
{
return(new ComputeExpressionResponseModel(false, errorMessage));
}
var variables = request.Parameters.Select(p => p.GetVariable()).ToList();
var parseResult = _mathParser.TryParse(request.Expression, variables);
if (parseResult.IsSuccessfulCreated == false)
{
return(new ComputeExpressionResponseModel(false, parseResult.ErrorMessage));
}
var computeResult = parseResult.Expression.ComputeValue(request.Parameters);
var expressionDAL = _expressionFactory
.Create(parseResult,
variables,
request.Parameters,
computeResult);
await _dataBaseService.SaveAsync(expressionDAL);
return(new ComputeExpressionResponseModel(true)
{
Result = computeResult,
Expression = parseResult.Expression
});
}
public void ParseSum()
{
var expression = "2 + 0.5 + 2.5*cos(pi) - log(2, 8) + sin(x) + tg(x)^2";
var parameter = new Parameter("x", 0);
var variables = new List <Variable>()
{
parameter.GetVariable()
};
var result = _parser.TryParse(expression, variables);
var computedResult = 0d;
if (result.IsSuccessfulCreated)
{
computedResult = result.Expression.ComputeValue(new List <Parameter>()
{
parameter
});
}
var expectedResult = 2 + 0.5 + 2.5 * Math.Cos(Math.PI) - Math.Log(8, 2) + Math.Sin(parameter.Value) + Math.Pow(Math.Tan(parameter.Value), 2);
Assert.True(result.IsSuccessfulCreated);
Assert.Equal("Sum", result.Expression.Name);
Assert.Equal(expectedResult, computedResult);
}
public void ExeptionEnter()
{
string testReqwest = "one + six";
var answer = MathParser.TryParse(testReqwest);
Assert.AreEqual(false, answer);
}
public void ParseFraction()
{
var expression = "1/2/3/4/x";
var parameter = new Parameter
{
VariableName = "x",
Value = 0
};
var variables = new List <Variable>()
{
parameter.GetVariable()
};
var result = _parser.TryParse(expression, variables);
var computedResult = 0d;
if (result.IsSuccessfulCreated)
{
computedResult = result.Expression.ComputeValue(new List <Parameter>()
{
parameter
});
}
var expectedResult = 1d / 2d / 3d / 4d / parameter.Value;
Assert.True(result.IsSuccessfulCreated);
Assert.Equal("Fraction", result.Expression.Name);
Assert.Equal(expectedResult, computedResult);
}
public void ParseProduct()
{
var expression = "2 * 0.5 * -2.5*cos(pi)* tg(x)^2 * log(-2, -8) * sin(x)*(2+3)*(cos(0)+sin(0))*(2*(x+1))";
var parameter = new Parameter
{
VariableName = "x",
Value = 1
};
var variables = new List <Variable>()
{
parameter.GetVariable()
};
var result = _parser.TryParse(expression, variables);
var computedResult = 0d;
if (result.IsSuccessfulCreated)
{
computedResult = result.Expression.ComputeValue(new List <Parameter>()
{
parameter
});
}
var expectedResult = 2 * 0.5 * -2.5
* Math.Cos(Math.PI)
* Math.Pow(Math.Tan(parameter.Value), 2)
* Math.Log(-8, -2)
* Math.Sin(parameter.Value)
* (2 + 3)
* (Math.Cos(0) + Math.Sin(0))
* (2 * (parameter.Value + 1));
Assert.True(result.IsSuccessfulCreated);
Assert.Equal("Product", result.Expression.Name);
Assert.Equal(expectedResult, computedResult);
}
public void ExtensionTest()
{
var expression = "x+y+2*z";
var x = 0;
var y = 20;
var z = 1.1;
var result = _parser.TryParse(expression, "x", "y", "z");
var computedResult = 0d;
if (result.IsSuccessfulCreated)
{
computedResult = result.Expression.ComputeValue(x, y, z);
}
var expectedResult = x + y + 2 * z;
Assert.True(result.IsSuccessfulCreated);
Assert.Equal("Sum", result.Expression.Name);
Assert.Equal(expectedResult, computedResult);
}
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
});
}
