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);
}
