private EventHandler <VariableFoundEventArgs <Derivatives <Func <double> > > > OnVariableFound(EvaluationContext context, bool @throw)
{
return((sender, args) =>
{
if (context.Arguments.Any(a => a.Key == args.Name))
{
var d = new DoubleDerivatives(2)
{
[0] = () =>
{
var expression = context.Arguments.First(a => a.Key == args.Name).Value;
var value = context.Evaluate(expression);
return value;
},
[1] = () => 1,
};
args.Result = d;
return;
}
if (context.Parameters.ContainsKey(args.Name))
{
var d = new DoubleDerivatives(2)
{
[0] = () =>
{
var parameter = context.Parameters[args.Name];
var value = context.Evaluate(parameter);
return value;
},
[1] = () => 0,
};
args.Result = d;
return;
}
if (@throw)
{
throw new SpiceSharpParserException($"Parameter not found {args.Name}");
}
else
{
var d = new DoubleDerivatives(1)
{
[0] = () => double.NaN
};
args.Result = d;
}
});
}
public double?input(string input)
{
var tokens = Tokenize(input);
if (!tokens.Any())
{
return(null);
}
var ast = _parser.Parse(tokens);
try
{
return(_evalCtx.Evaluate(ast, _parser.Context));
}
catch (Exception ex)
{
if (ex.Message == "Expression does not conform to given grammar")
{
return(null);
}
throw;
}
}
public async Task <SatisfactionStatus> EvaluateCondition(Condition condition)
{
IEnumerable <string> requiredFactIds = condition.GetRequiredFactIds();
List <Task <Fact> > requestFactTasks = requiredFactIds
.Where(fact => !mFactContainer.IsCached(fact, EngineClock.Default.Now()))
.Select(fact => mFactSourceContainer.RequestNonGenericFact(fact))
.ToList();
await Task.WhenAll(requestFactTasks);
List <Fact> generatedFacts = requestFactTasks
.Select(task => task.Result)
.ToList();
mFactContainer.AddFactRange(requestFactTasks.Select(t => t.Result));
SatisfactionStatus result = SatisfactionStatus.Unknown;
using (EvaluationContext ctx = condition.StartEvaluation(mFactContainer))
{
result = await ctx.Evaluate();
}
if (result != SatisfactionStatus.Unknown)
{
return(result);
}
throw new Exception(
$"Got a SatisfactionStatus.Unknown after finishing evaluation!");
}
private IEnumerable <Statement> ComputeIfResult(Statements result, int ifIndex, int endIfIndex)
{
var ifControl = (Control)result[ifIndex];
var ifCondition = (Models.Netlist.Spice.Objects.Parameters.ExpressionParameter)ifControl.Parameters[0];
Control elseControl = null;
Control elseIfControl = null;
var elseControlIndex = FindFirstMatched(result, ifIndex + 1, "else");
if (elseControlIndex != result.Count)
{
elseControl = result[elseControlIndex] as Control;
}
var elseIfControlIndex = FindFirstMatched(result, ifIndex + 1, "elseif");
if (elseIfControlIndex != result.Count)
{
elseIfControl = result[elseIfControlIndex] as Control;
}
if (EvaluationContext.Evaluate(ifCondition.Image) >= 1.0)
{
if (elseIfControl != null)
{
return(result.Skip(ifIndex + 1).Take(elseIfControlIndex - ifIndex - 1).ToList());
}
else
{
if (elseControl == null)
{
return(result.Skip(ifIndex + 1).Take(endIfIndex - ifIndex - 1).ToList());
}
else
{
return(result.Skip(ifIndex + 1).Take(elseControlIndex - ifIndex - 1).ToList());
}
}
}
else
{
if (elseIfControl != null)
{
return(ComputeIfResult(result, elseIfControlIndex, endIfIndex));
}
else
{
if (elseControl == null)
{
return(new List <Statement>());
}
else
{
return(result.Skip(elseControlIndex + 1).Take(endIfIndex - elseControlIndex - 1).ToList());
}
}
}
}
public override double GetValue(EvaluationContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.Evaluate(Expression));
}
/// <summary>
/// Evaluates the template against the specified value and options.
/// </summary>
/// <param name="template">A string that represents a valid waterpipe template.</param>
/// <param name="value">An object defining the root context.</param>
/// <param name="options">Options that alter rendering behaviors.</param>
/// <returns></returns>
public static XmlDocument EvaluateAsXml(string template, object value, EvaluateOptions options)
{
CommonHelper.ConfirmNotNull(options, "options");
PipeExecutionException[] exceptions;
options.OutputXml = true;
XmlNode result = (XmlNode)EvaluationContext.Evaluate(template, new PipeValue(value), options, out exceptions);
return(result.OwnerDocument);
}
/// <summary>
/// Evaluates the template against the specified value and options.
/// </summary>
/// <param name="template">A string that represents a valid waterpipe template.</param>
/// <param name="value">An object defining the root context.</param>
/// <param name="options">Options that alter rendering behaviors.</param>
/// <returns></returns>
public static string Evaluate(string template, object value, EvaluateOptions options)
{
PipeExecutionException[] exceptions;
object result = EvaluationContext.Evaluate(template, new PipeValue(value), options, out exceptions);
if (options.OutputXml)
{
return(((XmlNode)result).OuterXml);
}
return(result.ToString());
}
public DataTypeValue Evaluate(EvaluationContext ctx, string SchemeID)
{
BagDataType ret = ctx.Evaluate(
this._category, this._attributeId, this._dataType, this._mustBePresent, this._issuer);
if (ret.Empty && this._mustBePresent.EqualsIgnoreCase("true"))
{
throw new Indeterminate(Indeterminate.IndeterminateProcessingError);
}
return(ret);
}
private static string CreatePolyExpression(
int dimension,
ParameterCollection coefficients,
List <string> variables,
EvaluationContext context)
{
if (coefficients.Count == 1 && coefficients[0] is PointParameter pp)
{
var result = PolyFunction.GetExpression(
dimension,
pp.Values.Items.Select(c => context.Evaluate(c.Image)).ToList(),
variables);
return(result);
}
else
{
var result = PolyFunction.GetExpression(
dimension,
coefficients.Select(c => context.Evaluate(c.Image)).ToList(),
variables);
return(result);
}
}
public override PipeValue Invoke(PipeContext context)
{
PipeExecutionException[] exceptions;
object result = EvaluationContext.Evaluate(tokens, context.Value, context.EvaluationContext.Options, out exceptions);
foreach (PipeExecutionException ex in exceptions)
{
context.EvaluationContext.AddException(ex);
}
if (context.EvaluationContext.Options.OutputXml)
{
context.EvaluationContext.CurrentXmlElement.AppendChild((XmlNode)result);
return(PipeValue.Undefined);
}
return(result.ToString());
}
private ParameterCollection GetSpicePropertyParameters(EvaluationContext context, SpicePropertyFoundEventArgs <double> arg)
{
var vectorParameter = new VectorParameter(new List <SingleParameter>());
for (var i = 0; i < arg.Property.ArgumentCount; i++)
{
var argumentName = arg.Property[i];
if (context.Parameters.ContainsKey(argumentName))
{
var val = context.Evaluate(argumentName);
vectorParameter.Elements.Add(new WordParameter(val.ToString(CultureInfo.InvariantCulture), null));
}
else
{
vectorParameter.Elements.Add(new WordParameter(argumentName, null));
}
}
var parameters = new ParameterCollection(new List <Parameter> {
vectorParameter
});
return(parameters);
}
internal DbConstraint ActionEvaluator(string parameter, EvaluationContext context)
{
return(context.Evaluate(parameter, Evaluator.HowToDoQ));
}
internal DbConstraint ValueEvaluator(string parameter, EvaluationContext context)
{
return(context.Evaluate(parameter, Evaluator.HowToEvaluateQ));
}
protected override void SetParameter(string parameterName, string parameterExpression, EvaluationContext context)
{
context.SetParameter(parameterName, context.Evaluate(parameterExpression));
}
