public void MultiValuedParametersTest() { var expr = new Expression("Pow((a * b), c)", EvaluateOptions.IgnoreCase | EvaluateOptions.IterateParameters); expr.Parameters["a"] = new[] { 1, 2, 3, 4, 5 }; expr.Parameters["b"] = new[] { 6, 7, 8, 9, 0 }; expr.Parameters["c"] = 3; foreach(var result in (IList)expr.Evaluate()) { Console.WriteLine(result); } }
public static IEnumerable<double> UnaryEvaluate(this string expression, string parameterName, Func<double[]> parameterFunc) { expression.ShouldNotBeWhiteSpace("expression"); var expr = new NCalc.Expression(expression, EvaluateOptions.IgnoreCase | EvaluateOptions.IterateParameters); expr.Parameters["x"] = parameterFunc(); return ((IList)expr.Evaluate()).Cast<object>().Select(result => result.AsDouble()); }
public void ClickEqualButton(object sender, EventArgs e) { isChengeOp = false; int amount = 0; for (int i = 0; i < eText.Length; i++) { if (eText[i] == '(') { amount++; } else if (eText[i] == ')') { amount--; } } for (int i = 0; i < amount; i++) { eText += ")"; Field.Text += ")"; } Calculate(); try { expression = new NCalc.Expression(eText); expression.Parameters["p"] = 3.14; expression.Parameters["e"] = 2.71828; Field.Text = expression.Evaluate().ToString().Replace(",", "."); eText = expression.Evaluate().ToString().Replace(",", "."); } catch { } }
public void DynamicParametersTest() { var expr = new Expression("Round(Pow(Pi, 2) + Pow(Pi, 2) + x, 2)"); expr.Parameters["Pi2"] = new Expression("Pi * Pi"); expr.Parameters["x"] = 10; expr.EvaluateParameter += delegate(string name, ParameterArgs args) { if(name == "Pi") args.Result = Math.PI; }; Console.WriteLine("value = " + expr.Evaluate().AsDouble()); expr.Evaluate().AsDouble().Should().Be.GreaterThan(0); }
public void Test1() { var expr = new Expression("cos([t])", EvaluateOptions.IgnoreCase); expr.Parameters["t"] = 0; var result = expr.Evaluate(); Assert.AreEqual(1d, result); expr.Parameters["t"] = Math.PI; result = expr.Evaluate(); Assert.AreEqual(-1d, result); }
public void HandleMessage(string command, string args, object clientData, Action<string, AnswerBehaviourType> sendMessageFunc) { Expression expr = new Expression(args); var exprAnswer = expr.Evaluate(); string messageAuthor = string.Empty; string answer = string.Empty; var skypeData = clientData as ISkypeData; if (skypeData!=null) { messageAuthor = skypeData.FromName; } if (!string.IsNullOrEmpty(messageAuthor)) { answer = string.Format("Мсье {0}, ответ равен : {1}", messageAuthor, exprAnswer); } else { answer = string.Format("Ответ равен : {0}", exprAnswer); } sendMessageFunc(answer, AnswerBehaviourType.Text); }
/// <summary> /// Setts up the Arcade. /// </summary> /// <param name='screen'> /// Screen. /// </param> public static void Loading(int arcadeOrArendelle) { Console.Title = " "; Console.Clear (); if (arcadeOrArendelle == 0) { string loadingText = "A R C A D E I D E " + InterfaceView.ArcadeVersion () + " "; string show = ""; for (int i = 0; i < loadingText.Length; i++) { Console.Clear (); show = show + loadingText[i].ToString(); InterfaceView.CenterWriter (-1, show); System.Threading.Thread.Sleep (50); } } else { InterfaceView.CenterWriter (-1, "L O A D I N G "); } // running a very easy problem with NCalc // so the runtime loads NCalc ( if we don't // do the very first Spaces.calculate will // take seconds! Expression vari = new Expression ("2*3+1"); vari.Evaluate (); if (arcadeOrArendelle == 0) System.Threading.Thread.Sleep (1000); }
private void buttonTest_Click(object sender, EventArgs e) { float textValue; float start; float end; try { textValue = float.Parse(textBoxTestInput.Text); start = float.Parse(textBoxRangeStart.Text); end = float.Parse(textBoxRangeEnd.Text); } catch (Exception) { MessageBox.Show("不正确的输入", "Error"); return; } if (textValue < start || textValue > end) { labelTestResult.Text = "not in range, did not cal"; return; } String realExp = textBoxExp.Text.Replace("t", textBoxTestInput.Text); try { Expression ex = new Expression(realExp); labelTestResult.Text = ex.Evaluate().ToString(); } catch(Exception excep) { MessageBox.Show(excep.ToString(), "Error"); } }
public void IterationTest() { var expr = new Expression("Sin(x)", EvaluateOptions.IgnoreCase | EvaluateOptions.IterateParameters); expr.Parameters["x"] = Enumerable.Range(0, 1000).Select(x => x / Math.PI).ToArray(); foreach(var result in (IList)expr.Evaluate()) Console.WriteLine(result.AsDouble()); }
/// <summary> /// 公式轉數值 /// </summary> /// <param name="rules">公式</param> /// <param name="array">陣列</param> /// <returns>數值</returns> public static double RulesToDouble(String rules, ref double[] array) { if (String.IsNullOrEmpty(rules)) return 0.0d; String rule = rules .Replace("@3", array[3].ToString()) .Replace("@4", array[4].ToString()) .Replace("@5", array[5].ToString()) .Replace("@6", array[6].ToString()) .Replace("@7", array[7].ToString()) .Replace("@8", array[8].ToString()) .Replace("@9", array[9].ToString()) .Replace("@10", array[10].ToString()) .Replace("@11", array[11].ToString()) .Replace("@12", array[12].ToString()) .Replace("@2", array[2].ToString()) .Replace("@1", array[1].ToString()) .Replace("@0", array[0].ToString()); try { Expression number = new Expression(rule); return Double.Parse(number.Evaluate().ToString()); } catch { } return 0.0d; }
/// <summary> /// Creates a new instance of the FunctionConverterClass /// </summary> /// <param name="function">The function as a string</param> /// <param name="length"></param> /// <param name="interval"></param> /// <param name="type">The type of data the function represents</param> public FunctionConverter(String function, double length, double interval, int type) { int size = Convert.ToInt32(length / interval) + 1; //_time = new List<double>(); //_value = new List<double>(); _time = new double[size]; _value = new double[size]; for (int i = 0; i < size; i++) { _time[i] = (i * interval); String TempString = function.Replace("x", System.Convert.ToString(_time[i])); Expression e = new Expression(TempString); try { object result = e.Evaluate(); _value[i] = (Convert.ToDouble(result)); } catch(Exception a) { MessageBox.Show("Error caught: " + a.Message); } } SetProperties((FunctionType)type); }
private void Calculate() { try { string tmp = Field.Text; int amount = 0; for (int i = 0; i < tmp.Length; i++) { if (tmp[i] == '(') { amount++; } else if (tmp[i] == ')') { amount--; } } for (int i = 0; i < amount; i++) { tmp += ")"; } expression = new NCalc.Expression(tmp); expression.Parameters["π"] = 3.14; //expression.Parameters["e"] = 2.71828; Answer.Text = expression.Evaluate().ToString(); } catch { Answer.Text = ""; } }
public void ClickEqualButton(object sender, EventArgs e) { int amount = 0; for (int i = 0; i < Field.Text.Length; i++) { if (Field.Text[i] == '(') { amount++; } else if (Field.Text[i] == ')') { amount--; } } for (int i = 0; i < amount; i++) { Field.Text += ")"; } Calculate(); try { expression = new NCalc.Expression(Answer.Text); expression.Parameters["π"] = 3.14; expression.Parameters["e"] = 2.718281828459045; Field.Text = expression.Evaluate().ToString(); } finally { } }
protected void Page_Load(object sender, EventArgs e) { string equation = getRandomEquation(5); lblRandomEquation.Text = equation; NCalc.Expression ex = new NCalc.Expression(equation); lblResult.Text = (ex.Evaluate().ToString()); }
private void EQUALS() { if (InProgress == true) { try { SecondNumber = Convert.ToDouble(Display.Text); } catch (Exception ex) { MessageBox.Show(ex.Message); } } else { try { FirstNumber = Convert.ToDouble(Display.Text); InProgress = true; } catch (Exception ex) { MessageBox.Show(ex.Message); } } // calculates both numbers using the set operator, Using NClac Library NCalc.Expression ee = new NCalc.Expression(FirstNumber + Operation + SecondNumber); Result = Convert.ToDouble(ee.Evaluate()); Display.Text = Convert.ToString(Result); LastResult.Content = "Current Result: " + FirstNumber + Operation + SecondNumber + " = " + Result; SecondNumber = Result; }
private void btnCalculate_Click(object sender, EventArgs e) { #if !DEBUG try { #endif string format = txtFormat.Text; IEnumerable<string> expressions = GetExpressions(format); foreach (string expression in expressions) { Expression expr = new Expression(MakeParseable(expression)) { Parameters = GetParameters() }; string result = expr.Evaluate().ToString(); format = format.Replace(expression, result); } txtCalculated.Text = format; #if !DEBUG } catch (Exception ex) { MessageBox.Show(ex.Message + "\n\n" + ex.StackTrace, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } #endif }
public static EDataTable CalculateTimeSliceTable() { foreach (var simpleFormulaModel in _timeSliceFormulas) { _timeSliceTable.Columns.Add(simpleFormulaModel.Name, typeof(double)); foreach (DataRow row in _timeSliceTable.Rows) { _expression = new Expression(simpleFormulaModel.Formula); foreach (var column in simpleFormulaModel.UsedColumns) { double rowValue; if (double.TryParse(row[column].ToString(), out rowValue)) _expression.Parameters[column] = rowValue; } try { var result = _expression.Evaluate(); row[simpleFormulaModel.Name] = result; } catch (Exception) { row[simpleFormulaModel.Name] = -1; } } } return _timeSliceTable; }
public void PlusMinusTest() { var expr = new Expression("2 + 3 * 5"); expr.Evaluate().Should().Be(17); expr = new Expression("48/(2*(9+3))"); expr.Evaluate().Should().Be(2d); }
public bool ParseInt(out int value) { bool parsed = false; value = 0; if (IsValid) { try { NCalc.Expression expr = new NCalc.Expression(Expression); LogicalExpression pexpr = NCalc.Expression.Compile(Expression, false); ExprVisitor v = new ExprVisitor(); pexpr.Accept(v); if (!v.ComplexExpression) { value = Convert.ToInt32(expr.Evaluate()); parsed = true; } } catch (Exception) { } } return(parsed); }
public static bool Eval(object parameterValue, string strExpression) { Expression expression = new Expression(strExpression); expression.Parameters["p"] = parameterValue; bool flag = true; return flag.Equals(expression.Evaluate()); }
private void btnCalcul_Click(object sender, EventArgs e) { EvalCalculation evalCalcul = new EvalCalculation(); NCalc.Expression exp = new NCalc.Expression(evalCalcul.RebuildForm(txtInputCalcul.Text).ToString()); rttResultsDisplay.Text = exp.Evaluate().ToString(); }
public async void Execute(Dictionary<string, object> context) { Update update = context["update"] as Update; CommandEntity commandEntity = context["commandEntity"] as CommandEntity; Expression mathExpression=new Expression(commandEntity.Parameter,EvaluateOptions.IgnoreCase); var message = mathExpression.Evaluate().ToString(); await _bot.SendTextMessage(update.Message.Chat.Id,message); }
public static IEnumerable <double> UnaryEvaluate(this string expression, string parameterName, Func <double[]> parameterFunc) { expression.ShouldNotBeWhiteSpace("expression"); var expr = new NCalc.Expression(expression, EvaluateOptions.IgnoreCase | EvaluateOptions.IterateParameters); expr.Parameters["x"] = parameterFunc(); return(((IList)expr.Evaluate()).Cast <object>().Select(result => result.AsDouble())); }
public static decimal Evaluate(String input) { NCalc.Expression e = new NCalc.Expression(input); var result = e.Evaluate(); decimal h2 = Decimal.Parse(result.ToString(), System.Globalization.NumberStyles.Any); return(Convert.ToDecimal(h2)); }
public Double Evaluate(List <int> population) { #region Function Variables var op1 = GenerateOperator(); var op2 = GenerateOperator(); var op3 = GenerateOperator(); var op4 = GenerateOperator(); var v1 = GenerateVariable(); var v2 = GenerateVariable(); var v3 = GenerateVariable(); var v4 = GenerateVariable(); var s1 = GenerateSign(); var s2 = GenerateSign(); var s3 = GenerateSign(); var s4 = GenerateSign(); var s5 = GenerateSign(); var s6 = GenerateSign(); var s7 = GenerateSign(); var s8 = GenerateSign(); var s9 = GenerateSign(); var s10 = GenerateSign(); var n1 = RandomFromPop(population); var n2 = RandomFromPop(population); var n3 = RandomFromPop(population); var n4 = RandomFromPop(population); var n5 = RandomFromPop(population); var n6 = RandomFromPop(population); var n7 = RandomFromPop(population); var n8 = RandomFromPop(population); var n9 = RandomFromPop(population); var n10 = RandomFromPop(population); var trig = GenerateTrig(); #endregion var s = $"Pow((Pow({s1}{n1} {v1} , {s2}{n2}) {op1} Pow({s3}{n3} {v2} , {s4}{n4})), {s5}{n5}) {op2} Pow({s6}{n6} {v3} , {s7}{n7}) {op3} Exp({s8}{n8}) {op4} {trig}(Pow({s9}{n9} {v4} , {s10}{n10}))"; s = s.Replace(" x ", "*-7.62"); s = s.Replace(" y ", "*11.43"); s = s.Replace(" z ", "*1.06"); NCalc.Expression e = new NCalc.Expression(s); e.Parameters["x"] = X; e.Parameters["y"] = Y; e.Parameters["z"] = Z; var result = e.Evaluate(); Console.WriteLine($"The function evaluated is {s}"); return(Convert.ToDouble(result)); }
public static object Evalulate(JToken token, string expression) { var e = new Expression(expression); e.EvaluateParameter += (name, args) => { args.Result = GetValue(token, name); args.HasResult = true; }; return e.Evaluate(); }
public double evaluate(Expression exp, double value) { exp.Parameters["x"] = value; Object EvaluatedExpression = exp.Evaluate(); double result = double.Parse(EvaluatedExpression.ToString()); addToLog("Evaluating: x=" + RoundDigit(value, 4) + tab + "Result: " + RoundDigit(result, 4)); return result; }
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(); }
public static bool IsIgnoredDecl(IReadOnlyCollection<string> ifStack, IReadOnlyCollection<Definition> defns) { foreach (var s in ifStack) { try { Action<string, FunctionArgs> evalFunc = null; Action<string, ParameterArgs> evalParam = null; evalFunc = (name, args) => { var def = defns.FirstOrDefault(d => d.Identifier == name && d.Arguments != null && d.Arguments.Count == args.Parameters.Length); if (def != null) { var e2 = new Expression(def.Replacement); for (int i = 0; i < def.Arguments.Count; ++i) e2.Parameters.Add(def.Arguments[i], args.Parameters[i].Evaluate()); e2.EvaluateFunction += new EvaluateFunctionHandler(evalFunc); e2.EvaluateParameter += new EvaluateParameterHandler(evalParam); args.Result = e2.Evaluate(); } }; evalParam = (name, args) => { var def = defns.FirstOrDefault(d => d.Identifier == name && d.Arguments == null); if (def != null) { var e2 = new Expression(def.Replacement); e2.EvaluateFunction += new EvaluateFunctionHandler(evalFunc); e2.EvaluateParameter += new EvaluateParameterHandler(evalParam); args.Result = e2.Evaluate(); } }; var e = new Expression(s); e.EvaluateFunction += new EvaluateFunctionHandler(evalFunc); e.EvaluateParameter += new EvaluateParameterHandler(evalParam); var result = e.Evaluate(); if (!Convert.ToBoolean(result)) return true; } catch { // Empty catch, this is non-trivial, just print it out. } } return false; }
public static Double Calculate(string argExpression) { //get the user passed string string ExpressionToEvaluate = argExpression; //pass string in the evaluation object declaration. Expression z = new Expression(ExpressionToEvaluate); //command to evaluate the value of the **************string expression var result = z.Evaluate(); Double results = Convert.ToDouble(result.ToString()); return results; }
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 static Object CalculateValue(String key, Object rawValue) { Object returnValue = rawValue; if (ValueRecalculation.ContainsKey(key)) { var szExpress = ValueRecalculation[key].Replace("x", rawValue.ToString()); var express = new NCalc.Expression(szExpress); decimal tmp = Convert.ToDecimal(express.Evaluate()); returnValue = Math.Round(tmp, 2); } return(returnValue); }
public static void espr1() { Console.WriteLine("Inserisci espressione:"); try { Expression e = new Expression(Console.ReadLine()); Console.WriteLine(e.Evaluate()); } catch (Exception) { Console.WriteLine("Espressione invalida."); } Console.Write("00 per tornare al menù o INVIO per continuare: "); string b = Console.ReadLine(); if (b == "00") { Program.Main(); } }
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { try { string val = value.ToString().Replace(',', '.'); NCalc.Expression e = new NCalc.Expression(val); return(e.Evaluate()); } catch (Exception) { return(0); } }
public static bool Eval(DataTable dt, string strExpression) { if (dt.Rows.Count == 0) { return false; } Expression expression = new Expression(strExpression); foreach (DataColumn column in dt.Columns) { expression.Parameters[column.ColumnName] = dt.Rows[0][column.ColumnName]; } bool flag = true; return flag.Equals(expression.Evaluate()); }
public void CustomParametersShouldReturnNull() { var e = new Expression("x"); e.EvaluateParameter += delegate(string name, ParameterArgs args) { Assert.IsFalse(args.HasResult); if (name == "x") args.Result = null; Assert.IsTrue(args.HasResult); }; Assert.AreEqual(null, e.Evaluate()); }
/// <summary> /// Evaluates an NCalc formula with given parameter mappings. /// </summary> /// <param name="formulaString">NCalc formula</param> /// <param name="parameters">Variable names</param> /// <param name="args">Variable bindings</param> /// <returns name="result">Result of the formula calculation.</returns> public static object Evaluate(string formulaString, string[] parameters, object[] args) { var e = new Expression(formulaString.ToLower(), EvaluateOptions.IgnoreCase); e.Parameters["pi"] = 3.14159265358979; foreach (var arg in args.Select((arg, i) => new { Value = arg, Index = i })) { var parameter = parameters[arg.Index]; e.Parameters[parameter] = arg.Value; } return e.Evaluate(); }
public void CustomFunctionShouldReturnNull() { var e = new Expression("SecretOperation(3, 6)"); e.EvaluateFunction += delegate(string name, FunctionArgs args) { Assert.IsFalse(args.HasResult); if (name == "SecretOperation") args.Result = null; Assert.IsTrue(args.HasResult); }; Assert.AreEqual(null, e.Evaluate()); }
public object Calculate(CalculationContext context, Calculation calculation) { Expression expression = new Expression(calculation.Formula); var regex = new Regex(@"\[(.*?)\]"); var parameters = regex.Matches(calculation.Formula); GetValue(context, expression, parameters); var result = expression.Evaluate(); SetValue(result, calculation, context); return result; }
/// <summary> /// Evaluates an NCalc formula with given parameter mappings. /// </summary> /// <param name="formulaString">NCalc formula</param> /// <param name="parameters">Variable names</param> /// <param name="args">Variable bindings</param> /// <returns name="result">Result of the formula calculation.</returns> public static object Evaluate(string formulaString, string[] parameters, object[] args) { var e = new Expression(formulaString.ToLower(), EvaluateOptions.IgnoreCase); e.Parameters["pi"] = 3.14159265358979; foreach (var arg in args.Select((arg, i) => new { Value = arg, Index = i })) { var parameter = parameters[arg.Index]; var value = DynamoUnits.SIUnit.ToSIUnit(arg.Value); e.Parameters[parameter] = value == null ? arg.Value : value.Value * DynamoUnits.BaseUnit.UiLengthConversion; } return e.Evaluate(); }
//########################################################################## #region Methods //-------------------------------------------------------------------------- public void ValueTextChanged() { float value = 0f; try { var exp = new NCalc.Expression(ValueText); var obj = exp.Evaluate(); if (obj is double) { value = (float)(double)obj; } else if (obj is int) { value = (float)(int)obj; } else if (obj is bool) { value = (bool)obj ? 1 : 0; } else { value = (float)obj; } } catch (Exception) { HasError = true; return; } if (UseIntegers) { value = (int)value; } if (value < MinValue || value > MaxValue) { HasError = true; return; } cameFromUs = true; HasError = false; Value = value; }
public Vector<double> ToVector(double t = 0) { var values = new List<double>(); for (int i = 0; i < Vector.Length; i++) { var fn = PrepareParameters(Vector[i]); var expr = new Expression(fn, EvaluateOptions.IgnoreCase); if (fn.Contains("[t]")) { expr.Parameters["t"] = t; } values.Add((double)expr.Evaluate()); } return DenseVector.OfArray(values.ToArray()); }
/// <summary> /// /// </summary> /// <param name="element"></param> /// <param name="evp"></param> public override void Visit(IFStatement element, EvaluationParam evp) { NCalc.Expression e = new NCalc.Expression(element.Text); e.EvaluateFunction += delegate(string name, FunctionArgs args) { if (name.ToLower() == "mod") { args.Result = (int)args.Parameters[0].Evaluate() % (int)args.Parameters[1].Evaluate(); } }; var a = e.Evaluate(); result = new Result(); result.Value = a; // throw new NotImplementedException(); }
static void Main(string[] args) { //ExpTreeMap(10000); //ExpTreeMap(10000); //ExpTreeMap(10000); int a1 = 4, a2 = 5; string exp1 = "[a1]*[Pi]"; NCalc.Expression e = new NCalc.Expression(exp1); e.Parameters["a1"] = a1; e.Parameters["a2"] = a2; e.EvaluateParameter += delegate(string name, ParameterArgs arg) { if (name == "Pi") { arg.Result = 2; } }; var r = e.Evaluate(); //string exp2 = $"tag(\"tag1\",123)"; //NCalc.Expression e2 = new NCalc.Expression(exp2); //e2.EvaluateFunction += (name, arg) => //{ // if(name== "tag") // { // var p= arg.Parameters; // } //}; //e2.Evaluate(); Console.ReadLine(); //IProducerConsumerCollection //ConcurrentBag BlockingCollection }
private void Grid_Click(object sender, RoutedEventArgs e) { // обработчик работает только для кнопок Button btn = e.Source as Button; if (btn == null) { return; } // обработчик работает только для кнопок у которых есть значение (контент) string value = btn.Content.ToString(); if (String.IsNullOrEmpty(value)) { return; } switch (value) { // стираем текстовое поле case "C": TextBoxMain.Text = "0"; break; // считаем выражение с помощью библиотеки NCalc // https://ncalc.codeplex.com/ case "=": try { NCalc.Expression exp = new NCalc.Expression(TextBoxMain.Text); TextBoxMain.Text = exp.Evaluate().ToString(); } catch { TextBoxMain.Text = "Error"; } break; // добавялем новое значение в текстовое поле и удаляем стартовый 0 default: TextBoxMain.Text = TextBoxMain.Text.TrimStart('0') + value; break; } }
private void BuildExpressionGraph(SingleSeriesChart chart) { var expr = new NCalc.Expression(Expression, EvaluateOptions.IgnoreCase | EvaluateOptions.IterateParameters); var step = (Upper - Lower) / VarCount; var x = EnumerableTool.Step(Lower, Upper, step).ToArray(); expr.Parameters["x"] = x; var y = ((IEnumerable)expr.Evaluate()).ToListUnsafe <double>(); for (var i = 0; i < x.Length; i++) { chart.SetElements.Add(new ValueSetElement(y[i]) { Label = x[i].ToString("#.0") }); } }
public static decimal LeerConcepto(string conceptvalue, int idx) { if (conceptvalue == string.Empty || conceptvalue == null) { return(0); } var conceptvaluex = conceptvalue.Replace(" ", ""); var divconcept = conceptvaluex.Split('*', '+', '-', '/', '(', ')'); string valorconvertido = conceptvaluex; nominaEntities paraconcepto = new nominaEntities(); foreach (var item in divconcept) { if (item.Contains('$')) { var y = LeerCampo(item, idx); valorconvertido = valorconvertido.Replace(item, y); } if (item.Contains('@')) { var itemn = item.Remove(0, 1); var j = EjecutarProc(itemn, idx.ToString()); valorconvertido = valorconvertido.Replace(item, j); } } valorconvertido = valorconvertido.Replace(',', '.'); NCalc.Expression e = new NCalc.Expression(valorconvertido); decimal evaluation = 0; try { evaluation = decimal.Parse(e.Evaluate().ToString()); } catch (System.ArgumentException x) { Datos.Msg("Error en Concepto Numero " + idx.ToString() + ". El parametro " + x.ParamName + " no existe o esta mal escrito."); } return(Decimal.Round(evaluation, 2));; }
private void Result() { if (tb_result.Text.Length <= 0) { Debug.WriteLine("Operation Not Allowed"); return; } String lastChar = tb_result.Text.Substring(tb_result.Text.Length - 1, 1); if (lastChar.Equals("/") || lastChar.Equals("*") || lastChar.Equals("+") || lastChar.Equals("-")) { Debug.WriteLine("Operation Not Allowed"); return; } NCalc.Expression e = new NCalc.Expression(tb_result.Text); tb_result.Text = e.Evaluate().ToString(); // clears displays next evaluation resultCalculated = true; }
private void Calculate() { try { string tmp = eText; if (LastSymbol == ".") { tmp += "0"; } int amount = 0; for (int i = 0; i < tmp.Length; i++) { if (tmp[i] == '(') { amount++; } else if (tmp[i] == ')') { amount--; } } for (int i = 0; i < amount; i++) { tmp += ")"; } expression = new NCalc.Expression(tmp); expression.Parameters["p"] = 3.14; expression.Parameters["e"] = 2.71828; Answer.Text = expression.Evaluate().ToString().Replace(",", "."); } catch { Answer.Text = ""; } }
public static NChartControl GenerateChart(string func) { NZoomTool zt = new NZoomTool(); zt.BeginDragMouseCommand = new NMouseCommand(MouseAction.Wheel, (MouseButton)System.Windows.Forms.MouseButtons.Middle, 0); zt.ZoomStep = 16; NChartControl nChartControl1 = new NChartControl(); nChartControl1.Controller.Tools.Add(new NSelectorTool()); nChartControl1.Controller.Tools.Add(new NTrackballTool()); nChartControl1.Controller.Tools.Add(zt); nChartControl1.Legends[0].Mode = LegendMode.Disabled; NTriangulatedSurfaceSeries triangulatedSurface = new NTriangulatedSurfaceSeries(); triangulatedSurface.UsePreciseGeometry = true; triangulatedSurface.AutomaticPalette = true; triangulatedSurface.SyncPaletteWithAxisScale = false; triangulatedSurface.PaletteSteps = 6; triangulatedSurface.FrameMode = SurfaceFrameMode.Mesh; NCartesianChart chart = (NCartesianChart)nChartControl1.Charts[0]; chart.Enable3D = true; chart.Width = width; chart.Depth = depth; chart.Height = height; chart.BoundsMode = BoundsMode.Fit; chart.Projection.Type = ProjectionType.Perspective; chart.Projection.Elevation = 30; chart.Projection.Rotation = -60; chart.LightModel.SetPredefinedLightModel(PredefinedLightModel.NorthernLights); chart.Series.Add(triangulatedSurface); string[] f2 = func.Split(Char.Parse("=")); if (f2.Length == 2) { if (f2[0] == "y" || f2[0] == "f(x)") // f-cja w postaci y=costam { float x, z; try { for (x = startx; x < width; x++) //x { for (z = startz; z < depth; z++) //z { NCalc.Expression ex = new NCalc.Expression(f2[1]); ex.Parameters["x"] = x; ex.Parameters["z"] = z; ex.EvaluateParameter += delegate(string name, ParameterArgs args) { if (name == "x") { args.Result = x; } else if (name == "z") { args.Result = z; } }; var y = ex.Evaluate(); triangulatedSurface.XValues.Add(x); triangulatedSurface.ZValues.Add(z); triangulatedSurface.Values.Add(y); } } } catch (Exception e) { MessageBox.Show("Sprawdź, czy poprawnie wpisałeś równanie!", "Nie pykło"); return(null); } } else { MessageBox.Show("Niepoprawny zapis funkcji!", "Nie pykło"); } } else { MessageBox.Show("Niepoprawny zapis funkcji!", "Nie pykło"); } return(nChartControl1); }
private double calculateY(double x, double y) { e2.Parameters["X"] = x; e2.Parameters["Y"] = y; return((double)e2.Evaluate()); }
private double calculateExact(double x) { exact.Parameters["X"] = x; return((double)exact.Evaluate()); }
private double calculatePervisna(double x) { //return 1 / Math.Sqrt(5) * (Math.Log(x + Math.Sqrt(Math.Pow(x, 2) - 0.08))); perv.Parameters["X"] = x; return((double)perv.Evaluate()); }
bool verifySymbols(string eq) { bool result = false; // Expression must contain at least one operator if (eq.IndexOfAny(_operators) == -1) { return(result); } if (eq.IndexOf("^") > -1) { int startInx1 = eq.IndexOf("^"); int startInx2 = eq.IndexOf("^") + 2; int endInx1 = eq.IndexOf(" ", startInx1); int endInx2 = eq.IndexOf(" ", startInx2); string leftOfPow = (startInx1 > 0 ? eq.Substring(0, startInx1) : ""); if (leftOfPow != "") { startInx1 = leftOfPow.LastIndexOf(" ", leftOfPow.Length - 2); if (startInx1 != -1) { leftOfPow = leftOfPow.Substring(startInx1); } else { startInx1 = 0; } string powLeftVal = leftOfPow.Trim(); string powRightVal = eq.Substring(startInx2, endInx2 - startInx2); eq = eq.Replace(powLeftVal + " ^ " + powRightVal, "Pow(" + powLeftVal + "," + powRightVal + ")"); } } if (eq.IndexOf("√") > -1) { int startInx = eq.IndexOf("√") + 2; int endInx = eq.IndexOf(" ", startInx); string sqrtVal = eq.Substring(startInx, endInx - startInx); eq = eq.Replace("√ " + sqrtVal, "Sqrt(" + sqrtVal + ")"); } eq = eq.Replace("x", "*"); NCalc.Expression expr; try { if (eq.IndexOf("=") != eq.Length - 1) { expr = new NCalc.Expression(eq); result = (bool)expr.Evaluate(); } } catch (Exception ex) { Debug.Log(ex.Message); } return(result); }
private double calculateFunction(double x, double y) { funct.Parameters["X"] = x; funct.Parameters["Y"] = y; return((double)funct.Evaluate()); }
private double calculateFunction(double x) { func.Parameters["X"] = x; return((double)func.Evaluate()); }
private double calculateFx(double x) { exp.Parameters["X"] = x; return((double)exp.Evaluate()); }
public void Square() { var expr = new Expression("[t]*[t]"); expr.Parameters["t"] = 2; var result = expr.Evaluate(); Assert.AreEqual(4, result); }