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