private void ProcessFormula() { Expression e; try { e = new Expression( FormulaString.ToLower() .Replace(" and ", "+").Replace("&&", "+") .Replace(" or ", "+").Replace("||", "+"), EvaluateOptions.IgnoreCase); } catch (Exception ex) { Error(ex.Message); return; } if (e.HasErrors()) { Error(e.Error); return; } var parameters = new List <string>(); var paramSet = new HashSet <string>(); e.EvaluateParameter += delegate(string name, ParameterArgs args) { if (!paramSet.Contains(name) && !reservedParamNames.Contains(name)) { paramSet.Add(name); parameters.Add(name); } args.Result = 0; }; try { e.Evaluate(); } catch { } InPortData.Clear(); foreach (var p in parameters) { InPortData.Add(new PortData(p, "variable")); } RegisterInputPorts(); ClearError(); }
private bool CanExecuteScript() { if (string.IsNullOrWhiteSpace(this.Script.Text)) { return false; } var expression = new Expression(this.Script.Text); if (expression.HasErrors()) { this.ScriptError = expression.Error; return false; } else { this.ScriptError = string.Empty; return true; } }
public override string RunSingle(MultiboxFunctionParam args) { try { string rval; Expression tmp = new Expression(intToDec.Replace(prefixDec.Replace(args.MultiboxText, PrefixDecHelper), IntToDecHelper), EvaluateOptions.IgnoreCase); if (tmp.HasErrors()) rval = tmp.Error; else { try { rval = ((int)tmp.Evaluate()).ToString("#,##0.#########"); } catch { try { rval = ((float)tmp.Evaluate()).ToString("#,##0.#########"); } catch { try { rval = ((double)tmp.Evaluate()).ToString("#,##0.#########"); } catch { rval = double.Parse("" + tmp.Evaluate()).ToString("#,##0.#########"); } } } } return rval; //return intToDec.Replace(prefixDec.Replace(args.MultiboxText, PrefixDecHelper), IntToDecHelper); } catch { } return ""; }
public ActionResult Calculate(string calculation) { dynamic response = new CalculationResult(); Expression expression = new Expression(calculation); if (expression.HasErrors()) { response.success = false; response.errors = expression.Error; } try { response.result = expression.Evaluate(); response.success = true; } catch (Exception ex) { response.success = false; response.errors = ex.Message; } return Json(response); }
private void processFormula() { Expression e; try { e = new Expression(Formula); } catch (Exception ex) { Error(ex.Message); return; } if (e.HasErrors()) { Error(e.Error); return; } var parameters = new SortedList<int, Tuple<string, Type>>(); var paramSet = new HashSet<string>(); e.EvaluateFunction += delegate(string name, FunctionArgs args) { if (!paramSet.Contains(name) && !RESERVED_NAMES.Contains(name)) { paramSet.Add(name); parameters.Add(Formula.IndexOf(name), Tuple.Create(name, typeof(Value.Function))); } foreach (var p in args.Parameters) { p.Evaluate(); } args.Result = 0; }; e.EvaluateParameter += delegate(string name, ParameterArgs args) { if (!paramSet.Contains(name)) { paramSet.Add(name); parameters.Add(Formula.IndexOf(name), Tuple.Create(name, typeof(Value.Number))); } args.Result = 0; }; try { e.Evaluate(); } catch { } InPortData.Clear(); foreach (var p in parameters.Values) { InPortData.Add(new PortData(p.Item1, "variable", p.Item2)); } RegisterInputs(); }
public void ShouldDetectSyntaxErrorsBeforeEvaluation() { var e = new Expression("a + b * ("); Assert.IsNull(e.Error); Assert.IsTrue(e.HasErrors()); Assert.IsTrue(e.HasErrors()); Assert.IsNotNull(e.Error); e = new Expression("+ b "); Assert.IsNull(e.Error); Assert.IsTrue(e.HasErrors()); Assert.IsNotNull(e.Error); }
private void ProcessFormula() { Expression e; try { e = new Expression( FormulaString.ToLower() .Replace(" and ", "+").Replace("&&", "+") .Replace(" or ", "+").Replace("||", "+"), EvaluateOptions.IgnoreCase); } catch (Exception ex) { Error(ex.Message); return; } if (e.HasErrors()) { Error(e.Error); return; } var parameters = new List<string>(); var paramSet = new HashSet<string>(); e.EvaluateParameter += delegate(string name, ParameterArgs args) { if (!paramSet.Contains(name) && !reservedParamNames.Contains(name)) { paramSet.Add(name); parameters.Add(name); } args.Result = 0; }; e.EvaluateFunction += delegate(string name, FunctionArgs args) { foreach (var p in args.Parameters) { p.Evaluate(); } args.Result = 0; }; try { e.Evaluate(); } catch { } InPorts.Clear(); foreach (var p in parameters) { InPorts.Add(new PortModel(PortType.Input, this, new PortData(p, "variable"))); } ClearRuntimeError(); }
private void ProcessFormula() { Expression e; try { e = new Expression( FormulaString.ToLower() .Replace(" and ", "+").Replace("&&", "+") .Replace(" or ", "+").Replace("||", "+"), EvaluateOptions.IgnoreCase); } catch (Exception ex) { Error(ex.Message); return; } if (e.HasErrors()) { Error(e.Error); return; } var parameters = new List<Tuple<string, Type>>(); var paramSet = new HashSet<string>(); e.EvaluateFunction += delegate(string name, FunctionArgs args) { if (!paramSet.Contains(name) && !ReservedFuncNames.Contains(name)) { paramSet.Add(name); parameters.Add(Tuple.Create(name, typeof(Value.Function))); } foreach (var p in args.Parameters) { p.Evaluate(); } args.Result = 0; }; e.EvaluateParameter += delegate(string name, ParameterArgs args) { if (!paramSet.Contains(name) && !ReservedParamNames.Contains(name)) { paramSet.Add(name); parameters.Add(Tuple.Create(name, typeof(Value.Number))); } args.Result = 0; }; try { e.Evaluate(); } catch { } InPortData.Clear(); foreach (var p in parameters) { InPortData.Add(new PortData(p.Item1, "variable", p.Item2)); } RegisterInputs(); ClearError(); }
static Formulas() { if (DamageModelConfig.Formulas != null) { if (!string.IsNullOrEmpty(DamageModelConfig.Formulas.Accuracy)) { AccuracyExpression = new Expression(DamageModelConfig.Formulas.Accuracy, EvaluateOptions.IgnoreCase); if (AccuracyExpression.HasErrors()) { HasErrors = true; Errors.Add($"Accuracy expression error: {AccuracyExpression.Error}."); AccuracyExpression = null; } else AccuracyExpression.CutOffUnknownParameters(); } if (!string.IsNullOrEmpty(DamageModelConfig.Formulas.Alacrity)) { AlacrityExpression = new Expression(DamageModelConfig.Formulas.Alacrity, EvaluateOptions.IgnoreCase); if (AlacrityExpression.HasErrors()) { HasErrors = true; Errors.Add($"Alacrity expression error: {AlacrityExpression.Error}."); AlacrityExpression = null; } else AlacrityExpression.CutOffUnknownParameters(); } if (!string.IsNullOrEmpty(DamageModelConfig.Formulas.Critical)) { CriticalExpression = new Expression(DamageModelConfig.Formulas.Critical, EvaluateOptions.IgnoreCase); if (CriticalExpression.HasErrors()) { HasErrors = true; Errors.Add($"Critical expression error: {CriticalExpression.Error}."); CriticalExpression = null; } else CriticalExpression.CutOffUnknownParameters(); } if (!string.IsNullOrEmpty(DamageModelConfig.Formulas.Surge)) { SurgeExpression = new Expression(DamageModelConfig.Formulas.Surge, EvaluateOptions.IgnoreCase); if (SurgeExpression.HasErrors()) { HasErrors = true; Errors.Add($"Surge expression error: {SurgeExpression.Error}."); SurgeExpression = null; } else SurgeExpression.CutOffUnknownParameters(); } if (!string.IsNullOrEmpty(DamageModelConfig.Formulas.MasteryCritical)) { MasteryCriticalExpression = new Expression(DamageModelConfig.Formulas.MasteryCritical, EvaluateOptions.IgnoreCase); if (MasteryCriticalExpression.HasErrors()) { HasErrors = true; Errors.Add($"Mastery critical expression error: {MasteryCriticalExpression.Error}."); MasteryCriticalExpression = null; } else MasteryCriticalExpression.CutOffUnknownParameters(); } if (!string.IsNullOrEmpty(DamageModelConfig.Formulas.BonusDamage)) { BonusDamageExpression = new Expression(DamageModelConfig.Formulas.BonusDamage, EvaluateOptions.IgnoreCase); if (BonusDamageExpression.HasErrors()) { HasErrors = true; Errors.Add($"Bonus damage expression error: {BonusDamageExpression.Error}."); BonusDamageExpression = null; } else BonusDamageExpression.CutOffUnknownParameters(); } if (!string.IsNullOrEmpty(DamageModelConfig.Formulas.SpellBonusDamage)) { SpellBonusDamageExpression = new Expression(DamageModelConfig.Formulas.SpellBonusDamage, EvaluateOptions.IgnoreCase); if (SpellBonusDamageExpression.HasErrors()) { HasErrors = true; Errors.Add($"Spell bonus damage expression error: {SpellBonusDamageExpression.Error}."); SpellBonusDamageExpression = null; } else SpellBonusDamageExpression.CutOffUnknownParameters(); } } }
private void ExecuteScriptAction() { var expression = new Expression(this.Script.Text); if (expression.HasErrors()) { this.ScriptResult = string.Empty; this.ScriptError = expression.Error; } else { try { foreach (var parameter in this.Parameters.Where(x => !string.IsNullOrWhiteSpace(x.Label))) { expression.Parameters.Add(parameter.Label, parameter.Value); } this.ScriptResult = expression.Evaluate(); this.ScriptError = string.Empty; } catch (Exception ex) { this.ScriptError = ex.Message; this.ScriptResult = string.Empty; } } }
private async Task<string> Calculator(string text) { NCalc.Expression exp; string setString = text; bool flag = false; Regex reg = new Regex(@"^\d|\)|\("); if (text.Length != 0 && reg.IsMatch(text)) { mode = "calc"; if (text.Substring(text.Length - 1, 1).Equals("=")) { text = text.Substring(0, text.Length - 1); flag = true; } exp = new NCalc.Expression(text, EvaluateOptions.IgnoreCase); if (!exp.HasErrors()) { try { setString = exp.Evaluate().ToString(); if (flag) { if (!Dispatcher.CheckAccess()) { Dispatcher.Invoke(() => TextBar1.Text = setString, DispatcherPriority.Normal); Dispatcher.Invoke(() => TextBar1.Select(TextBar1.Text.Length, 0), DispatcherPriority.Normal); } else { TextBar1.Text = setString; //sets cursor TextBar1.Select(TextBar1.Text.Length, 0); } } } catch (Exception ex) { } } else setString = "Please use a valid expression"; } return setString; }
private void calcApplicationEnergy(string path, Expression e, ref double appEnergy) { string[] lineValue; string[] currFile = File.ReadAllLines(path); string[] varNames = currFile[0].Split(delimiter); for (int i = 1; i < currFile.Length; i++) { lineValue = currFile[i].Split(delimiter); for (int j = 0; j < varNames.Length; j++) { double value = Double.Parse(lineValue[j].ToString()); if (value < 0) value = 0; e.Parameters[varNames[j]] = value; } if (e.HasErrors()) updateStatus("e has error " + e.Error); try { double x = double.Parse(e.Evaluate().ToString()); appEnergy += float.Parse(e.Evaluate().ToString()) / 1000; } catch (EvaluationException ee) { updateStatus("Error catched: " + ee.Message); } } }
protected ReturnStatus<Expression> CreateExpressionFromString(string expressionStr, EvalType evalType) { string formattedExpressionStr; switch (evalType) { case EvalType.ControlPoint: formattedExpressionStr = EvaluationJob.FUNC_NAME_LIMIT + "(" + expressionStr + ")"; break; case EvalType.Curve: formattedExpressionStr = EvaluationJob.FUNC_NAME_LIMIT + "(" + EvaluationCurveJob.FUNC_NAME_SNAP + "(" + expressionStr + "))"; break; default: Debug.Assert(false); formattedExpressionStr = expressionStr.ToLower(); break; } //Even though we use EvaluateOptions.IgnoreCase when we construct an expression //it still seems to be necessary to convery everything to lower case. Other //parameters will not be evaluated. formattedExpressionStr = formattedExpressionStr.ToLower(); Expression expression = null; if (this.expressionCache.ContainsKey(formattedExpressionStr) == false) { expression = new Expression(formattedExpressionStr, EvaluateOptions.IgnoreCase); //Calling HasErrors() will cause expression.ParsedExpression to be set. if (expression.HasErrors()) { //Cache this expression that causes a syntax error as null so that it doesn't have to be parsed again. this.expressionCache.GetAndAddValue(formattedExpressionStr, () => null); expression = null; } else { this.expressionCache.GetAndAddValue(formattedExpressionStr, () => expression.ParsedExpression); } } else { //We have already ensured that the key is in the cache so the createValue function should not be called. LogicalExpression parsedExpression = this.expressionCache.GetAndAddValue(formattedExpressionStr, () => { Debug.Assert(false); return null; }); if (parsedExpression != null) { expression = new Expression(parsedExpression, EvaluateOptions.IgnoreCase); } } if (expression == null) { return new ReturnStatus<Expression>(); } else { SetExpressionConstants(expression); return new ReturnStatus<Expression>(expression); } }
public static List<string> ListParameters(Equation Equ) { List<string> param = new List<string>(); Expression ex = new Expression(Equ.EquationText); ex.EvaluateFunction += delegate(string name, FunctionArgs args) { if (name == "Length") param.Add(args.Parameters[0].ToString()); args.Result = 1; }; ex.EvaluateParameter += delegate(string name, ParameterArgs args) { param.Add(name); args.Result = 1; }; if (ex.HasErrors()) MessageBox.Show(ex.Error); ex.Evaluate(); return param; }
static void Main(string[] args) { string rootPath = @"D:\[BACKUP][POWER][20140220]\SamsungS3\line\voice\"; //string rootPath2 = @"D:\skype_idle\"; string modelFile = rootPath + "model.txt"; int numOfTest = 5; string[] testFile = new string[numOfTest]; string[] model = File.ReadAllLines(modelFile); string[] formula = model[0].Split('='); string input = formula[1].Replace("sin", "Sin") .Replace("cos", "Cos"); ArrayList al = new ArrayList(); for (int i = 0; i < input.Length; i++) { if (input[i] == '+' || input[i] == '-' || input[i] == '*' || input[i] == '/' || input[i] == '%') { al.Add(input[i]); } } string[] sArray = input.Split(new char[5]{'+','-','*','/','%'}); //float offset = float.Parse(sArray[0]); string equation = ""; for (int i = 0; i < al.Count; i++) { if (sArray[i].Contains('^')) { //Console.WriteLine("modify"); string[] pow = sArray[i].Split('^'); if (!pow[0].Contains('(')) equation += "Pow(" + pow[0] + "," + pow[1] + ")"; else { string[] sub1 = pow[0].Split('('); string[] sub2 = pow[1].Split(')'); equation += sub1[0] + "(" + "Pow(" + sub1[1] + "," + sub2[0] + "))"; } equation += " " + al[i]; } else { equation += sArray[i] + " " + al[i]; } } if (sArray[sArray.Length - 1].Contains('^')) { //Console.WriteLine("modify"); string[] pow = sArray[sArray.Length - 1].Split('^'); if (!pow[0].Contains('(')) equation += "Pow(" + pow[0] + "," + pow[1] + ")"; else { string[] sub1 = pow[0].Split('('); string[] sub2 = pow[1].Split(')'); equation += sub1[0] + "(" + "Pow(" + sub1[1] + "," + sub2[0] + "))"; } } else { equation += sArray[sArray.Length - 1]; } float avgEnergy = 0; double avgTotalEnergy = 0; double avgAsyncEnergy = 0; TextWriter tw = new StreamWriter(rootPath + "energy.txt"); for (int n = 0; n < numOfTest; n++) { string[] sampleFile = File.ReadAllLines(rootPath + (n + 1) + @"\sample.txt"); string[] samVars = sampleFile[0].Split('\t'); if (samVars.Length == 1) samVars = sampleFile[0].Split(' '); string[] currFile = File.ReadAllLines(rootPath + (n + 1) + @"\test.txt"); string[] varNames = currFile[0].Split('\t'); if (varNames.Length == 1) varNames = currFile[0].Split(' '); Expression e = new Expression(equation); float energy = 0; double totalEnergy = 0; //Calculate total energy (joule) for (int k = 1; k < sampleFile.Length; k++) { string[] sampleValues = sampleFile[k].Split('\t'); if (sampleValues.Length == 1) sampleValues = sampleFile[k].Split(' '); double power = double.Parse(sampleValues[sampleValues.Length - 1]) / 1000.0; totalEnergy += power; } //Calculate asynchronous energy (joule) double asyncTotal = 0; if (n == 0) { string[] asyncFile = File.ReadAllLines(rootPath + (n + 1) + @"\asyncTable.txt"); for (int aNum = 1; aNum < asyncFile.Length; aNum++) { string line = asyncFile[aNum]; string[] lines = line.Split('\t'); if (lines.Length == 1) lines = line.Split(' '); asyncTotal += (double.Parse(lines[1]) / 1000); } } for (int i = 1; i < currFile.Length; i++) { string[] lineValue = currFile[i].Split('\t'); if (lineValue.Length == 1) lineValue = currFile[i].Split(' '); for (int j = 0; j < varNames.Length; j++) { double value = Double.Parse(lineValue[j].ToString()); if (value < 0) value = 0; e.Parameters[varNames[j]] = value; } if (e.HasErrors()) { Console.WriteLine("e has error " + e.Error); } try { double x = double.Parse(e.Evaluate().ToString()); Console.WriteLine(e.Evaluate()); energy += float.Parse(e.Evaluate().ToString())/1000; } catch (EvaluationException ee) { Console.WriteLine("Error catched: " + ee.Message); } } Console.WriteLine("Test " + (n+1) + " = " + energy); tw.WriteLine("Test " + (n+1) + " = " + energy); Console.WriteLine("Total energy = " + totalEnergy); avgEnergy += energy; avgTotalEnergy += totalEnergy; avgAsyncEnergy += asyncTotal; } Console.WriteLine("average energy = " + (avgEnergy / numOfTest)); Console.WriteLine("average total energy = " + (avgTotalEnergy / numOfTest)); tw.WriteLine(""); tw.WriteLine("Average energy " + avgEnergy / numOfTest + " joules"); tw.WriteLine("average async energy = " + (avgAsyncEnergy / numOfTest) + " joules"); tw.WriteLine("average total energy = " + (avgTotalEnergy / numOfTest) + " joules"); tw.Close(); //Console.ReadKey(); }