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