public IExpressionNode Simplify()
{
LeftOperand = LeftOperand.Simplify();
RightOperand = RightOperand.Simplify();
if (!LeftOperand.ContainsVariable() && !RightOperand.ContainsVariable())
{
return(new Constant(this.Evaluate(null)));
}
else if (!LeftOperand.ContainsVariable() && RightOperand.ContainsVariable())
{
if (LeftOperand.Evaluate(null) == 0)
{
return(new Constant(0));
}
}
else if (LeftOperand.ContainsVariable() && !RightOperand.ContainsVariable())
{
if (RightOperand.Evaluate(null) == 0)
{
throw new DivideByZeroException();
}
if (RightOperand.Evaluate(null) == 1)
{
return(LeftOperand.DeepCopy());
}
}
return(this);
}
public IExpressionNode Simplified()
{
if (this.IsConstant)
{
return(new Constant(this.Evaluate(null)));
}
if (condition.IsConstant)
{
return((condition.Evaluate(null) >= 0) ? trueNode : falseNode);
}
return(this);
}
public IExpressionNode Simplified()
{
if (indexNode.isConstant)
{
double t = indexNode.Evaluate(null);
int leftIndex = leftPointIndex(t);
if (segmentPoints[leftIndex].isConstant && segmentPoints[leftIndex + 1].isConstant)
{
return(new Constant(this.Evaluate(null)));
}
}
return(this);
}
public double Evaluate(IDictionary <string, double> variables)
{
double leftValue = leftSide.Evaluate(variables);
double rightValue = rightSide.Evaluate(variables);
return(compare(leftValue, rightValue, Math.Abs(leftValue - rightValue) <= tolerance) ? 1 : -1);
}
public double Evaluate()
{
var rhsVal = _rhs.Evaluate();
var result = _operation(rhsVal);
return(result);
}
public double Evaluate(IDictionary <string, double> variables)
{
double x = argument.Evaluate(variables);
double min = minNode.Evaluate(variables);
double max = maxNode.Evaluate(variables);
return((x < min) ? min : (x > max) ? max : x);
}
public override IValueNode Evaluate(params IVariable[] variables)
{
switch (Operator)
{
default:
case Operators.Add:
return(Left.Evaluate(variables).Add(Right.Evaluate(variables), variables));
case Operators.Substract:
return(Left.Evaluate(variables).Substract(Right.Evaluate(variables), variables));
case Operators.Multiply:
return(Left.Evaluate(variables).Multiply(Right.Evaluate(variables), variables));
case Operators.Divide:
return(Left.Evaluate(variables).Divide(Right.Evaluate(variables), variables));
}
}
public double Evaluate()
{
var lhsVal = _leftNode.Evaluate();
var rhsVal = _rightNode.Evaluate();
var result = _operation(lhsVal, rhsVal);
return(result);
}
//TODO(v0.8) add trivial variable overload or maybe for multiple variables in alphabetical order
public double Evaluate(IDictionary <string, double> variables)
{
try {
return(Root.Evaluate(variables));
}
catch (KeyNotFoundException)
{
ErrorReporter.Get.Report(new KeyNotFoundException("Missing vars: " + string.Join(" ", this.Variables.Where(x => !variables.ContainsKey(x)).ToArray())));
}
return(double.NaN);
}
public ConditionResult Evaluate(IExecutionContext executionContext, IExpressionNode tree, bool hostTracingOnly = false)
{
ArgUtil.NotNull(executionContext, nameof(executionContext));
ArgUtil.NotNull(tree, nameof(tree));
ConditionResult result = new ConditionResult();
var expressionTrace = new TraceWriter(Trace, hostTracingOnly ? null : executionContext);
result.Value = tree.Evaluate <bool>(trace: expressionTrace, secretMasker: HostContext.SecretMasker, state: executionContext);
result.Trace = expressionTrace.Trace;
return(result);
}
public double Evaluate(IDictionary <string, double> variables)
{
#if DEBUG
try {
#endif
return(root.Evaluate(variables));
#if DEBUG
}
catch (KeyNotFoundException)
{
System.Diagnostics.Trace.WriteLine("Missing vars: " + string.Join(" ", this.Variables.Where(x => !variables.ContainsKey(x)).ToArray()));
throw;
}
#endif
}
public double Evaluate()
{
return(_leftExpression.Evaluate() - _rightExpression.Evaluate());
}
public double Evaluate(IDictionary <string, double> variables)
{
return(Math.Sign(argument.Evaluate(variables)));
}
public double Evaluate(IDictionary <string, double> variables)
{
return(Math.Round(argument.Evaluate(variables), MidpointRounding.AwayFromZero));
}
public double Evaluate(Dictionary <string, double> input)
{
return(root.Evaluate(input));
}
