public static double Calculate(ref List <string> expression) { for (int i = 0; i < expression.Count; ++i) { string atom = expression[i]; if (!(atom.Contains('+') || atom.Contains('-') || atom.Contains('*') || atom.Contains('/') || atom.Contains('(') || atom.Contains(')'))) { try { expression[i] = AtomToValue(atom).ToString(); } catch (NoValueForAtom e) { expression[i] = ""; expression = new List <string>(); expression.Add("0"); } } } string sExpression = MakeStringFromList(expression); PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(sExpression); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); List <VariableValue> variables = new List <VariableValue>(); return(ToolsHelper.Calculator.Calculate(compiledExpression, variables)); }
/// <summary> /// Нажатие на кнопку вычисления /// </summary> /// <param name="sender">объект</param> /// <param name="e">событие</param> private void clickOnBtn(object sender, RoutedEventArgs e) { try { // Парсинг строки PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(textBox.Text); // Компиляция распарсеных данных CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); // Creating list of variables specified List <VariableValue> variables = new List <VariableValue>(); try { // Рассчёт double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); // Отображение результата result.Content = String.Format("Результат: {0}", res); } catch { }; } catch (CompilerSyntaxException ex) { result.Content = String.Format("Ошибка синтаксиса: {0}", ex.Message); } catch (MathProcessorException ex) { result.Content = String.Format("Ошибка: {0}", ex.Message); } }
private void button_Click(object sender, RoutedEventArgs e) { try { // Парсим строку с математическим выражением PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(textBox.Text); // Компиляция распарсеных данных CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); // Создание списка переменных List <VariableValue> variables = new List <VariableValue>(); // Рассчёт double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); // Отображение результата result.Content = String.Format("Результат: {0}", res); } catch (CompilerSyntaxException ex) { result.Content = String.Format("Ошибка синтаксиса: {0}", ex.Message); } catch (MathProcessorException ex) { result.Content = String.Format("Ошибка: {0}", ex.Message); } catch (ArgumentException) { result.Content = "Ошибка в входных данных"; } }
private double EvaluateExpressionWithVariables(string expression, List <VariableValue> variables) { try { // Compiling an expression PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(expression); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); // Do it ! double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); return(res); } catch (CompilerSyntaxException ex) { //MessageBox.Show(String.Format("Compiler syntax error: {0}", ex.Message)); throw; } catch (MathProcessorException ex) { //MessageBox.Show(String.Format("Error: {0}", ex.Message)); throw; } catch (ArgumentException) { //MessageBox.Show("Error in input data."); throw; } catch (Exception) { //MessageBox.Show("Unexpected exception."); throw; } }
/////////////////////////////////////////// /// <summary> /// Prepares expression for faster calculation. Use when you need calculate one expression with different parameters many times. /// </summary> /// <param name="expression"></param> /// <param name="parameterNames"></param> /// <param name="error"></param> /// <returns></returns> public PreparedExpression Prepare(string expression, ICollection <string> parameterNames, out string error) { error = null; try { Dictionary <string, int> parameterNamesLowerCase = null; //Set<string> parameterNamesLowerCase = null; if (parameterNames != null) { parameterNamesLowerCase = new Dictionary <string, int>(parameterNames.Count); foreach (string parameterName in parameterNames) { parameterNamesLowerCase[parameterName.ToLower()] = 0; } } List <Symbol> symbols = Separate(expression, parameterNamesLowerCase); List <Symbol> postfix = ConvertToPostfixNotation(symbols); PreparedExpression preparedExpression = new PreparedExpression(this, postfix); return(preparedExpression); } catch (Exception ex) { error = ex.Message; return(null); } }
/// <summary> /// Матиматическое вычисление выражения /// </summary> /// <param name="variables">Список параметров</param> /// <param name="Expression">Текст выражения</param> /// <returns>Результат вычисления</returns> public static double Calc(List <VariableValue> variables, string Expression) { double result = 0; try { // Compiling an expression PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(Expression); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); // Optimizing an expression CompiledExpression optimizedExpression = ToolsHelper.Optimizer.Optimize(compiledExpression); // Creating list of variables specified // List<VariableValue> variables = new List<VariableValue>(); // double firstValue; // if (!Double.TryParse(textBoxValue1.Text, out firstValue)) // { // MessageBox.Show("Error converting first variable value."); // return; // } // variables.Add(new VariableValue(firstValue, textBoxVariable1.Text)); // double secondValue; // if (!Double.TryParse(textBoxValue2.Text, out secondValue)) // { // MessageBox.Show("Error converting second variable value."); // return; // } // variables.Add(new VariableValue(secondValue, textBoxVariable2.Text)); // Do it ! result = ToolsHelper.Calculator.Calculate(compiledExpression, variables); // Show the result. // MessageBox.Show(String.Format("Result: {0}\nOptimized: {1}", res, ToolsHelper.Decompiler.Decompile(optimizedExpression))); } catch (CompilerSyntaxException ex) { Errors.Add("Ошибка компиляции выражения:" + ex.Message); } catch (MathProcessorException ex) { Errors.Add("Ошибка:" + ex.Message); } catch (ArgumentException) { Errors.Add("Ошибка переданных параметров"); } catch (Exception) { Errors.Add("Неизвестная ошибка"); throw; } return(result); }
private void button1_Click(object sender, EventArgs e) { //Проверка входных данных. int isOkay = 0; float s = 0; float[] inputs = new float[10]; float from = 1, to = -1, step = 0; if (!(float.TryParse(FromX.Text.Replace(".", ","), out from) && float.TryParse(ToX.Text.Replace(".", ","), out to))) //|| from > to) { isOkay = 1; } else if (from > to) { isOkay = 2; } else if (!float.TryParse(Step.Text.Replace(".", ","), out step)) { isOkay = 3; } else if (step > to - from) { isOkay = 4; } //Проверка на правильность ввода функции. try { preparedExpression = ToolsHelper.Parser.Parse(FuncBox.Text.Replace(" ", "")); compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); F = (xx) => { vars[0] = new VariableValue(xx, VarName.Text); return((float)ToolsHelper.Calculator.Calculate(compiledExpression, vars)); }; F(0.332f); } catch (Exception) { isOkay = 5; } //Вывод сообщения об ошибке или построение графика. switch (isOkay) { case 0: PackIntoListBox(VarName.Text, FuncBox.Text, from, to, step); Calculate(from, to, step); break; case 1: MessageBox.Show("Неверно введены границы интервала.", "Ошибка.", MessageBoxButtons.OK); break; case 2: MessageBox.Show("Левая граница должна быть меньше правой границы.", "Ошибка.", MessageBoxButtons.OK); break; case 3: MessageBox.Show("Неверно введен шаг.", "Ошибка.", MessageBoxButtons.OK); break; case 4: MessageBox.Show("Длина шага не должна превышать длину интервала.", "Ошибка.", MessageBoxButtons.OK); break; case 5: MessageBox.Show("Неверно введена функция или название параметра.", "Ошибка.", MessageBoxButtons.OK); break; } }
public DecompiledExpressionItem(bool isComplex, PreparedExpression expression, Operation lastOperation) : this(isComplex, expression) { if (lastOperation == null) { throw new ArgumentNullException("lastOperation"); } this.lastOperation = lastOperation; }
public DecompiledExpressionItem(bool isComplex, PreparedExpression expression) { if (expression == null) { throw new ArgumentNullException("expression"); } this.isComplex = isComplex; this.expression = expression; }
private async Task <double> H(double x, string function) { List <VariableValue> variables = new List <VariableValue> { new VariableValue(x, "x") }; PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(function); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); return(await Task.FromResult(ToolsHelper.Calculator.Calculate(compiledExpression, variables))); }
static public double calculate(string input, double value) { PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(input); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); List <VariableValue> variables = new List <VariableValue>(); variables.Add(new VariableValue(value, "x")); double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); return(res); }
void UnpackFromListBox(int index) { //Получение значения из текущего элемента списка. string[] ins = listBox1.Items[index].ToString().Replace(" ", "").Split('|'); string varstr = ins[0].Substring(ins[0].IndexOf("(") + 1, ins[0].IndexOf(")") - ins[0].IndexOf("(") - 1); ins[0] = ins[0].Remove(0, ins[0].IndexOf('=') + 1); FuncBox.Text = ins[0]; FromX.Text = ins[1]; ToX.Text = ins[2]; Step.Text = ins[3]; preparedExpression = ToolsHelper.Parser.Parse(ins[0]); compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); F = (xx) => { vars[0] = new VariableValue(xx, varstr); return((float)ToolsHelper.Calculator.Calculate(compiledExpression, vars)); }; }
private bool checkExpression(string function) { try { PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(function); return(true); } catch (CompilerSyntaxException ex) { System.Windows.MessageBox.Show(String.Format("Неверно задана функция: {0}", ex.Message)); } return(false); }
private double f(double x, double y) { PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(Integral); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); List <VariableValue> variables = new List <VariableValue>(); variables.Add(new VariableValue(x, "x")); variables.Add(new VariableValue(y, "y")); double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); return(res); }
private Double CalcExp(string exp) { try { exp = exp.Replace(" ", "").Replace("\r", "").Replace("\n", ""); // Compiling an expression PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(exp); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); CompiledExpression optimizedExpression = ToolsHelper.Optimizer.Optimize(compiledExpression); // Creating list of variables specified List <VariableValue> variables = new List <VariableValue>(); foreach (KeyValuePair <string, string> pair in GroupValue) { double val; string var = pair.Value.Replace(" ", "").Replace("\r", "").Replace("\n", "").Replace(".", System.Globalization.CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator).Replace(",", System.Globalization.CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator); if (!Double.TryParse(var, out val)) { Log($"{pair.Key} = {var} - не число"); } else { variables.Add(new VariableValue(val, pair.Key)); } } return(ToolsHelper.Calculator.Calculate(compiledExpression, variables)); } catch (CompilerSyntaxException ex) { Log(String.Format("Compiler syntax error: {0}", ex.Message)); } catch (MathProcessorException ex) { Log(String.Format("Error: {0}", ex.Message)); } catch (ArgumentException) { Log("Error in input data."); } catch (Exception) { Log("Unexpected exception."); } return(Double.NaN); }
private bool trytocalculateExpression() { try { PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(function.Text.Replace(',', '.').ToLower()); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); CompiledExpression optimizedExpression = ToolsHelper.Optimizer.Optimize(compiledExpression); List <VariableValue> variables = new List <VariableValue>(); variables.Add(new VariableValue(0, "x")); double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); } catch { return(false); } return(true); }
private double calculate(string input, Hashtable args) { int n = (int)NewtonUpDown.Value; PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(input); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); List <VariableValue> variables = new List <VariableValue>(); for (int i = 0; i < n; ++i) { variables.Add(new VariableValue((double)args[variable[i].ToString()], variable[i].ToString())); } double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); return(res); }
private double[] calc(string function, int step, double min, double max, out double[] xData) { xData = new double[step]; double[] yData = new double[step]; try { double delta = (max - min) / step; double tmp = min; List <VariableValue> values = new List <VariableValue>(); for (int i = 0; i < step; i++) { values.Add(new VariableValue(tmp, "x")); xData[i] = tmp; PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(function); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); yData[i] = ToolsHelper.Calculator.Calculate(compiledExpression, values); values.Clear(); tmp += delta; } return(yData); } catch (MathProcessorException ex) { System.Windows.MessageBox.Show(String.Format("Error: {0}", ex.Message)); } catch (ArgumentException) { System.Windows.MessageBox.Show("Error in input data."); } catch (ArithmeticException ex) { System.Windows.MessageBox.Show(String.Format("Error: {0}", ex.Message)); } catch (Exception) { System.Windows.MessageBox.Show("Unexpected exception."); throw; } isError = true; return(null); }
// взято с http://habrahabr.ru/blogs/net/50158/ private double calculateExpression(double firstValue) { /*try * {*/ // Compiling an expression PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(function.Text.Replace(',', '.').ToLower()); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); // Optimizing an expression CompiledExpression optimizedExpression = ToolsHelper.Optimizer.Optimize(compiledExpression); // Creating list of variables specified List <VariableValue> variables = new List <VariableValue>(); variables.Add(new VariableValue(firstValue, "x")); // Do it ! double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); return(res); /*} * catch (CompilerSyntaxException ex) * { * MessageBox.Show(String.Format("Compiler syntax error: {0}", ex.Message)); * * } * catch (MathProcessorException ex) * { * MessageBox.Show(String.Format("Error: {0}", ex.Message)); * * } * catch (ArgumentException) * { * MessageBox.Show("Error in input data."); * * } * catch (Exception) * { * MessageBox.Show("Unexpected exception."); * throw; * }*/ //return 0.0; }
public ClassFormulaParsing(string formula, ELW.Library.Math.Tools.VariableValue[] args) { try { // Compiling an expression PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(formula); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); // Optimizing an expression CompiledExpression optimizedExpression = ToolsHelper.Optimizer.Optimize(compiledExpression); // Creating list of variables specified List <VariableValue> variables = new List <VariableValue>(); foreach (VariableValue arg in args) { variables.Add(arg); } // Do it ! double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); // Show the result. Console.WriteLine(String.Format("Result: {0}\nOptimized: {1}", res, ToolsHelper.Decompiler.Decompile(optimizedExpression))); } catch (CompilerSyntaxException ex) { Console.WriteLine(String.Format("Compiler syntax error: {0}", ex.Message)); } catch (MathProcessorException ex) { Console.WriteLine(String.Format("Error: {0}", ex.Message)); } catch (ArgumentException) { Console.WriteLine("Error in input data."); } catch (Exception) { Console.WriteLine("Unexpected exception."); throw; } }
/// <summary> /// Calculates expression. Example: "1 + (2 * 3)", "5 * x + y". /// </summary> /// <param name="expression"></param> /// <param name="parameters"></param> /// <param name="result"></param> /// <param name="error"></param> /// <returns></returns> public bool Calculate(string expression, Dictionary <string, double> parameters, out double result, out string error) { error = null; result = 0; ICollection <string> parameterNames = null; if (parameters != null) { parameterNames = parameters.Keys; } PreparedExpression preparedExpression = Prepare(expression, parameterNames, out error); if (preparedExpression == null) { return(false); } return(preparedExpression.Calculate(parameters, out result, out error)); }
private void Button_Enter(object sender, RoutedEventArgs e) { try { PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(TextBox_In.Text); CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); List <VariableValue> variables = new List <VariableValue>(); double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables); TextBox_Resul.Text = String.Format("Результат: {0}", res); } catch (CompilerSyntaxException ex) { TextBox_Resul.Text = String.Format("Ошибка: {0}", ex.Message); } catch (MathProcessorException ex) { TextBox_Resul.Text = String.Format("Ошибка: {0}", ex.Message); } catch (ArgumentException) { TextBox_Resul.Text = "Ошибка"; } }
/// <summary> /// Returns a compiled expression for specified source string. /// </summary> public CompiledExpression Compile(PreparedExpression preparedExpression) { if (preparedExpression == null) { throw new ArgumentNullException("preparedExpression"); } // OperationsStack operationsStack = new OperationsStack(operationsRegistry); // for (int itemIndex = 0; itemIndex < preparedExpression.PreparedExpressionItems.Count; itemIndex++) { PreparedExpressionItem item = preparedExpression.PreparedExpressionItems[itemIndex]; // If constant or variable - add to result if (item.Kind == PreparedExpressionItemKind.Constant) { operationsStack.PushConstant(item.Constant); } if (item.Kind == PreparedExpressionItemKind.Variable) { operationsStack.PushVariable(item.VariableName); } // If delimiter if (item.Kind == PreparedExpressionItemKind.Delimiter) { operationsStack.PushDelimiter(item.DelimiterKind); } // Signature (operator signature / part of signature / function) if (item.Kind == PreparedExpressionItemKind.Signature) { List <Operation> operations = new List <Operation>(operationsRegistry.GetOperationsUsingSignature(item.Signature)); operations.Sort(new Comparison <Operation>(compareOperationsByOperandsCount)); // for (int i = 0; i < operations.Count; i++) { Operation operation = operations[i]; // Operator if (operation.Kind == OperationKind.Operator) { // Unary operator if (operation.OperandsCount == 1) { // If operator placed at the start of subexpression if ((itemIndex == 0) || ((itemIndex > 0) && (preparedExpression.PreparedExpressionItems[itemIndex - 1].Kind == PreparedExpressionItemKind.Delimiter) && (preparedExpression.PreparedExpressionItems[itemIndex - 1].DelimiterKind == DelimiterKind.OpeningBrace) || (preparedExpression.PreparedExpressionItems[itemIndex - 1].DelimiterKind == DelimiterKind.Comma))) { // operationsStack.PushUnaryOperator(operation); break; } } // Binary operator if (operation.OperandsCount == 2) { operationsStack.PushBinaryOperator(operation); break; } // Ternary and more if (operation.OperandsCount > 2) { int partNumber = 0; for (int k = 0; k < operation.Signature.Length; k++) { if (operation.Signature[k] == item.Signature) { partNumber = k + 1; break; } } // If it is start part in signature if (partNumber == 1) { operationsStack.PushComplexOperatorFirstSignature(operation); break; } // operationsStack.PushComplexOperatorNonFirstSignature(operation, partNumber); break; } } // Function if (operation.Kind == OperationKind.Function) { operationsStack.PushFunction(operation); break; } } } } // operationsStack.DoFinalFlush(); // CompiledExpression res = operationsStack.GetResult(); if (!isCompiledExpressionStackBalanced(res)) { throw new CompilerSyntaxException("Operands disbalance detected."); } return(res); }
public Function(String expression) { PreparedExpression preparedExpression = ToolsHelper.Parser.Parse(expression); compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression); }