public bool Sense(EvalContext context, EntityType entityToBeDetected) { IfDetector detector = context.Target.GetComponent <IfDetector>(); if (detector == null) { detector = context.Target.gameObject.AddComponent <IfDetector>(); } Moveable moveable = context.Target.GetComponent <Moveable>(); Rigidbody rb = context.Target.GetComponent <Rigidbody>(); if (moveable != null) { //block된 상황에서 부들거리는 현상을 없애기 위해 iskinematic 변환 효과 없앰 bool current = rb.isKinematic; moveable.Ungravitate(); rb.isKinematic = current; } bool value = detector.Detect(entityToBeDetected); if (moveable != null) { moveable.Gravitate(); } return(value); }
public object Next(FunctionArgument _args, EvalContext cal) { StringBuilder sb = new StringBuilder(); char? c = null; while (!sr.EndOfStream) { c = (char)sr.Read(); if (!char.IsWhiteSpace(c.Value)) { break; } } if (c.HasValue == false) { return((StringValue)(sb.ToString())); } sb.Append(c.Value); while (!sr.EndOfStream) { c = (char)sr.Read(); if (char.IsWhiteSpace(c.Value)) { break; } sb.Append(c); } return((StringValue)sb.ToString()); }
public override async Task <StmtResult> Eval(EvalContext context) { //Debug.Log("if begins"); await base.Eval(context); //object condResult = Cond.Eval(); object condResult = Inst.CommandMgr.Sense(context, Cond.type); if (condResult is bool) { bool condValue = (bool)condResult; if ((condValue ^ Cond.Value) && Then != null) { return(await Then.Eval(context)); } if (Else != null) { return(await Else.Eval(context)); } return(StmtResult.None); } else { throw new LangException("condition in if is not boolean"); } }
//[CascadingParameter] //protected EditContext CurrentEditContext { get; set; } protected async override Task OnInitializedAsync() { //todo: allow upload of fitness //FitnessTypeNameOptions = Jtc.Optimization.Objects.FitnessTypeNameOptions.Options; assembly.GetTypes().Where(w => w.GetInterfaces().Contains(typeof(IFitness))).Select(s => s.FullName).OrderBy(o => o); using (dynamic context = new EvalContext(JSRuntime)) { (context as EvalContext).Expression = () => context.ClientStorage.fetchConfig(); var json = await(context as EvalContext).InvokeAsync <string>(); if (!string.IsNullOrEmpty(json)) { Config = JsonSerializer.Deserialize <Models.OptimizerConfiguration>(json); } } ToggleFitness(); using (dynamic context = new EvalContext(JSRuntime)) { (context as EvalContext).Expression = () => context.jQuery("body").css("overflow-y", "scroll"); } await base.OnInitializedAsync(); }
protected async Task UpdateChart() { await Wait.Show(); try { _stopWatch.Start(); await BindRemote(); //todo: reinstate new only if (NewOnly) { throw new NotImplementedException(); } else { var settings = new EvalContextSettings(); settings.SerializableTypes.Add(typeof(PlotlyData[])); using (dynamic context = new EvalContext(JSRuntime)) { (context as EvalContext).Expression = () => context.PlotlyInterop.newPlot(Config); } } } finally { await Wait.Hide(); } }
protected async Task GetStoredChart() { _stopWatch.Start(); await Wait.Show(); StateHasChanged(); //todo: reinstate new only //if (!NewOnly) //{ // Config.Data.Datasets.Clear(); // await JsRuntime.SetupChart(Config); //} try { dynamic context = new EvalContext(JSRuntime); (context as EvalContext).Expression = () => context.ClientStorage.fetchChartData(); var log = await(context as EvalContext).InvokeAsync <string>(); using (var reader = new SwitchReader(new StringReader(log))) { var data = await PlotlyBinder.Read(reader, SampleRate == 0? 1 : SampleRate, false, NewOnly?NewestTimestamp : DateTime.MinValue, minimumFitness : MinimumFitness); await ShowChart(data); } } catch (Exception ex) { ShowError(ex, "An error occurred attempting to bind."); } finally { await Wait.Hide(); } }
private bool GetHasChartData() { dynamic context = new EvalContext(JSRuntime); (context as EvalContext).Expression = () => context.ClientStorage.hasChartData(); return((context as EvalContext).Invoke <bool>()); }
protected async override Task OnAfterRenderAsync(bool firstRender) { if (firstRender) { using (dynamic context = new EvalContext(JSRuntime)) { (context as EvalContext).Expression = () => context.ace.edit("editor").setTheme("ace/theme/monokai"); await(context as EvalContext).InvokeAsync <dynamic>(); context.Reset(); (context as EvalContext).Expression = () => context.ace.edit("editor").session.setMode("ace/mode/javascript"); await(context as EvalContext).InvokeAsync <dynamic>(); } } using (dynamic context = new EvalContext(JSRuntime)) { (context as EvalContext).Expression = () => context.ace.edit("editor").session.setValue(MinimizeFunctionCode.Code); await(context as EvalContext).InvokeAsync <dynamic>(); context.Reset(); (context as EvalContext).Expression = () => context.ClientStorage.fetchConfig("config"); var raw = await(context as EvalContext).InvokeAsync <string>(); if (raw != null) { _config = JsonSerializer.Deserialize <Objects.OptimizerConfiguration>(raw); } } await base.OnAfterRenderAsync(firstRender); }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 1) throw new Exception("Invalid number of parameters."); context.DoOutputText(p[0].Evaluate(context).ToString()); return null; }
public override void Execute(EvalContext context) { if ((NumberType)Conditional.Evaluate(context) != FALSE) TStmtList.Excecute(context); else FStmtList.Excecute(context); }
public void Hide() { using (dynamic context = new EvalContext(JsRuntime)) { (context as EvalContext).Expression = () => context.jQuery(Selector).hide(); } }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 1) throw new Exception("Invalid number of parameters."); var n = p[0].Evaluate(context) as NumberType; return new NumberType(Math.Ceiling(n.value), n.Unit); }
public override EvalType Evaluate(EvalContext context) { NumberType[] n = new NumberType[Parameters.Length]; for (int i = 0; i < n.Length; i++) n[i] = NT(Parameters[i].Evaluate(context)); return new NumberListType(n); }
private dynamic RenderSeries(dynamic req) { try { var model = new RenderSeriesModel(); this.BindTo(model, new BindingConfig { BodyOnly = false }); var tgt = (string)Request.Form.target; var now = DateTime.UtcNow; var from = DateTimeParser.ParseDateTime(model.From, now, now.AddHours(-1)); var until = DateTimeParser.ParseDateTime(model.Until, now, now); var targets = string.Join("', '", model.Target); log.Debug("started rendering metrics using '{0}' from {1:s} to {2:s} ({3})", targets, from, until, until - from); var environment = new Statsify.Core.Expressions.Environment { MetricRegistry = metricRegistry, QueuedMetricDatapoints = metricAggregator.Queue }; var evalContext = new EvalContext(@from, until); var expressions = expressionCompiler.Parse(model.Target). Select(e => e is MetricSelectorExpression ? new EvaluatingMetricSelectorExpression(e as MetricSelectorExpression) : e). ToList(); log.Debug("started evaluating expression"); var r = expressions.SelectMany(e => (Core.Model.Metric[])e.Evaluate(environment, evalContext)).ToArray(); log.Debug("evaluated expression"); var metrics = new List <Core.Model.Metric>(r); var seriesViewList = metrics. Select(m => new SeriesView { Target = m.Name, Datapoints = m.Series.Datapoints. Select(d => new[] { d.Value, d.Timestamp.ToUnixTimestamp() }). ToArray() }). ToArray(); log.Debug("rendered {0} metrics using '{1}' from {2:s} to {3:s}", seriesViewList.Length, targets, from, until); return(Response.AsJson(seriesViewList)); } catch (Exception e) { return(Response.AsJson(new { e.Message, e.StackTrace }, HttpStatusCode.InternalServerError)); } }
public void Register(EvalContext c) { c.RegisterAssembly(typeof(Startup).Assembly); c.RegisterAssembly(typeof(Utilities.ReflectionUtils).Assembly); c.RegisterExtensionMethod(typeof(EntityFrameworkQueryableExtensions)); c.RegisterType(typeof(JsonConvert)); }
public async Task Hide() { using (dynamic context = new EvalContext(JsRuntime)) { (context as EvalContext).Expression = () => context.jQuery("#wait").hide(); await(context as EvalContext).InvokeAsync <dynamic>(); } }
private string GetChartDataSaved() { using (dynamic context = new EvalContext(JSRuntime)) { (context as EvalContext).Expression = () => context.ClientStorage.hasChartData(); return((context as EvalContext).Invoke <bool>() ? null : "d-none"); } }
public IExpr Calculate(EvalContext cal, IExpr[] exps) { /*if (QuantityNumber != -1) * { * if (exps.Length != QuantityNumber) throw new Exception("The number of quantitys is wrong. It should be " + QuantityNumber.ToString()); * }*/ return(EvaluateFunc.Invoke(exps, cal)); }
public virtual async Task <StmtResult> Eval(EvalContext context) { if (Inst.CancelAllPrograms) { throw new CancelException(); } return(StmtResult.None); }
public override void Prepare(EvalContext ctx, string path) { base.Prepare(ctx, path); foreach (var statement in Statements) { statement.Prepare(ctx, m_Path); } }
/// <summary> /// </summary> /// <exception cref="ApiException">Thrown when fails to make API call</exception> /// <param name="body">evalution batch request</param> /// <returns>Task of ApiResponse (EvaluationBatchResponse)</returns> public async Task <ApiResponse <EvalResult> > PostEvaluationAsync(EvalContext body) { if (body == null) { throw new ApiException(400, "Missing required parameter 'body' when calling EvaluationApi->PostEvaluationBatch"); } return(await _httpClient.PostAsync("evaluation").WithBody((x) => x.Model(body)).AsApiResponse <EvalResult>()); }
public EvalContext CreateFreshEvalContext() { PackageGlobals.VSMultiInstanceInfo multi_instance_info; GetVSMultiInstanceInfo(out multi_instance_info); EvalContext eval_ctx = new EvalContext(); SetVariableValuesFromIDEState(eval_ctx, multi_instance_info); return(eval_ctx); }
public override async Task <StmtResult> Eval(EvalContext context) { await base.Eval(context); Expr.Eval(); await new WaitForSeconds(Inst.Delay); Inst.Nounce++; return(StmtResult.None); }
public void Eval(EvalContext <TInput, TOutput> context, object value) { foreach (var converter in Converters) { value = converter.Convert(value); } SetValue(context, value); }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { context.DoOutputText(context.FunctionList.functions.Count + " functions defined."); foreach (var f in context.FunctionList.functions) { context.DoOutputText(f.Key + ":" + f.Value.Name + "=>" + f.Value); } return null; }
public ModuleValue(string name, string author, string version, EvalContext context = null) : base(context) { Author = author; Name = name; Version = version; this.author = new ReadOnlyConcreteValue(author); this.version = new ReadOnlyConcreteValue(version); this.name = new ReadOnlyConcreteValue(name); }
public void Eval(EvalContext <TInput, TOutput> context) { var value = GetValue(context); foreach (var target in _targets) { target.Eval(context, value); } }
public override void Execute(EvalContext ctx) { Operation.GetValue(ctx); //ignore the resulting abort if (ResetAbort) { ctx.ResetAbort(); } }
public object Has(FunctionArgument _args, EvalContext cal) { var args = _args.Arguments; OperationHelper.AssertArgsNumberThrowIf(this, 1, args); OperationHelper.AssertCertainValueThrowIf(this, args); var ov = cal.GetValue <IValue>(args[0]); return(this.Contains(ov)); }
public void Given_a_dynamic_expression_And_multiline_string_argument_When_invoked_Then_should_execute_evaluation(string argument, string expected) { var runtime = new Mock <IJSRuntime>(); using (dynamic context = new EvalContext(runtime.Object)) { (context as EvalContext).Expression = () => context.alert(argument); } Verify(runtime, $"alert({expected})"); }
public static TupleValue Split(FunctionArgument _args, EvalContext cal) { var args = _args.Arguments; OperationHelper.AssertArgsNumberThrowIf(null, 2, args); OperationHelper.AssertCertainValueThrowIf(null, args); var ov = cal.GetValue <StringValue>(args); return(new TupleValue(ov[0].Value.Split(ov[1].Value[0]).Select(x => new iExpr.Values.ConcreteValue(new StringValue(x))))); }
public static number Cos(FunctionArgument _args, EvalContext cal) { var args = _args.Arguments; OperationHelper.AssertArgsNumberThrowIf(null, 1, args); OperationHelper.AssertCertainValueThrowIf(null, args); var ov = cal.GetValue <number>(args[0]); return(new number(System.Math.Cos(ov))); }
private string GetConfigSaved() { using (dynamic context = new EvalContext(JSRuntime)) { (context as EvalContext).Expression = () => context.ClientStorage.fetchConfig(); var json = (context as EvalContext).Invoke <string>(); return(string.IsNullOrEmpty(json) ? "d-none" : null); } }
public static bool Exists(FunctionArgument _args, EvalContext cal) { var args = _args.Arguments; OperationHelper.AssertArgsNumberThrowIf(null, 1, args); OperationHelper.AssertCertainValueThrowIf(null, args); var ov = cal.GetValue <StringValue>(args)[0]; return(File.Exists(ov)); }
public static FileEasyWriter OpenEasyWrite(FunctionArgument _args, EvalContext cal) { var args = _args.Arguments; OperationHelper.AssertArgsNumberThrowIf(null, 1, args); OperationHelper.AssertCertainValueThrowIf(null, args); var ov = cal.GetValue <StringValue>(args)[0]; return(new FileEasyWriter(ov)); }
public EvalType Excecute(EvalContext context) { for (int i = 0; i < Statements.Count; i++) { if (Statements[i] is ReturnStatement) return (Statements[i] as ReturnStatement).Expression.Evaluate(context); else Statements[i].Execute(context); } return null; }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 1) throw new Exception("Invalid number of parameters."); var en = p[0].Evaluate(context); if (en is NumberType) return new NumberType(1, UnitType.Empty()); if (en is StringType) return new NumberType((en as StringType).Value.Length, UnitType.Empty()); return new NumberType(((NumberListType)en).Length, UnitType.Empty()); }
public override void Execute(EvalContext context) { int lc = 0; for (var n = ((NumberType)FromExpr.Evaluate(context)).Copy(); n <= ((NumberType)ToExpr.Evaluate(context)); n = n + (NumberType)IncExpr.Evaluate(context)) { context.VariableList[VarName] = n; StmtList.Excecute(context); lc++; if (lc > Globals.MAX_LOOP) throw new Exception("Max loops reached."); } }
public override void Execute(EvalContext context) { int lc = 0; while ((NumberType)Conditional.Evaluate(context) != FALSE) { StmtList.Excecute(context); lc++; if (lc > Globals.MAX_LOOP) throw new Exception("Max loops reached."); } }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { //TODO: Check range. var inc = new NumberType("1", UnitType.Empty()); var mv = p[0].Evaluate(context); var tv = new NumberType("1", UnitType.Empty()); for (NumberType i = new NumberType("1", UnitType.Empty()); i.LessEql(mv); i += inc) { tv *= i; } return tv; }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 1) throw new Exception("Invalid number of parameters."); var en = p[0].Evaluate(context); if (en is NumberType) return en; var nl = en as NumberListType; NumberType mag = new NumberType(0, UnitType.Empty()); for (int i = 0; i < nl.Length; i++) mag += nl[i]; return mag; }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 4) throw new Exception("Invalid number of parameters."); NumberType sum = new NumberType("0", UnitType.Empty()); NumberType inc = new NumberType("1", UnitType.Empty()); //EvalContext c = new EvalContext(context, ((VariableNode)p[1]).Variable) for (NumberType i = (p[2].Evaluate(context) as NumberType).Copy(); i.LessEql(p[3].Evaluate(context)); i += inc) { context.VariableList[((VariableNode)p[1]).Variable] = i; sum += p[0].Evaluate(context) as NumberType; } return sum; }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 1) throw new Exception("Invalid number of parameters."); var en = p[0].Evaluate(context); if (en is NumberType) return new NumberType(Math.Abs((en as NumberType).value), (en as NumberType).Unit); var nl = en as NumberListType; NumberType mag = new NumberType(0, UnitType.Empty()); NumberType two = new NumberType(2, UnitType.Empty()); NumberType oneOverTwo = new NumberType(.5, UnitType.Empty()); for (int i = 0; i < nl.Length; i++) mag += nl[i] ^ two; return mag ^ oneOverTwo; }
public override EvalType Evaluate(EvalContext context) { switch (Type) { case CompareType.Equal: return Left.Evaluate(context).Equals(Right.Evaluate(context)) ? NumberType.TRUE : NumberType.FALSE; case CompareType.NotEqual: return !Left.Evaluate(context).Equals(Right.Evaluate(context)) ? NumberType.TRUE : NumberType.FALSE; case CompareType.Less: return Left.Evaluate(context).Less(Right.Evaluate(context)) ? NumberType.TRUE : NumberType.FALSE; case CompareType.LessEqual: return Left.Evaluate(context).LessEql(Right.Evaluate(context)) ? NumberType.TRUE : NumberType.FALSE; case CompareType.Greater: return Left.Evaluate(context).Greater(Right.Evaluate(context)) ? NumberType.TRUE : NumberType.FALSE; case CompareType.GreaterEqual: return Left.Evaluate(context).GreaterEql(Right.Evaluate(context)) ? NumberType.TRUE : NumberType.FALSE; } throw new Exception("Invalid compare type."); }
/// <summary> /// Evaluates the node. /// </summary> /// <param name="context">The context to use.</param> /// <returns></returns> public abstract EvalType Evaluate(EvalContext context);
public override EvalType Evaluate(EvalContext context) { return context.VariableList[Variable]; }
public EvalContext CreateFreshEvalContext() { PackageGlobals.VSMultiInstanceInfo multi_instance_info; GetVSMultiInstanceInfo(out multi_instance_info); EvalContext eval_ctx = new EvalContext(); SetVariableValuesFromIDEState(eval_ctx, multi_instance_info); return eval_ctx; }
/// <summary> /// Evaluates the function to an EvalType. /// </summary> /// <param name="context">The context to use in evaluation.</param> /// <param name="p">The parameters.</param> /// <returns></returns> public virtual EvalType Evaluate(EvalContext context, params ExprNode[] p) { throw new Exception("Function left undefined."); }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 1) throw new Exception("Invalid number of parameters."); return p[0].Evaluate(context).Pow(new NumberType(".5", UnitType.Empty()));//new NumberType(Math.Sqrt(p[0].Evaluate(context).value)); }
public abstract void Execute(EvalContext context);
void Evaluate(string expression_str, Expression expr, string label) { EvalContext ctx = new EvalContext(); ctx.SetVariable("x", "XXX"); ctx.SetVariable("y", "YYY"); ctx.SetVariable("true", "SSS"); SafeEvalContext safe_ctx = new SafeEvalContext(ctx); Value v = expr.Evaluate(safe_ctx); Console.WriteLine("{0}: {1}", label, v.ToString()); List<Variable> unresolved_variables = expr.CollectUnresolvedVariables(ctx); if (unresolved_variables.Count > 0) { Console.WriteLine("Unresolved variables in the expression: {0}", unresolved_variables.Count); Console.WriteLine(expression_str); foreach (Variable var in unresolved_variables) { Console.WriteLine(new string(' ', var.Position) + "^"); Console.WriteLine(new string(' ', var.Position) + var.Name); } } }
public override void Execute(EvalContext context) { context.VariableList[Variable] = context.VariableList[Variable].Div(Expression.Evaluate(context)); }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 2) throw new Exception("Invalid number of parameters."); var ie = p[1].Evaluate(context); if (!(ie is NumberType)) throw new Exception("Index must be a number."); var index = ie as NumberType; var ti = p[0].Evaluate(context); if (ti is NumberType) { if (index.value == 1) return ti; throw new Exception("Index out of range."); } if (ti is NumberListType) { var i = (int)Math.Floor(index.value); return (ti as NumberListType)[i - 1]; } if (ti is StringType) { var i = (int)Math.Floor(index.value); return new StringType((ti as StringType).Value[i].ToString()); } throw new Exception("Invalid type to index."); }
public EvalContext eval() { EvalContext _localctx = new EvalContext(Context, State); EnterRule(_localctx, 0, RULE_eval); try { EnterOuterAlt(_localctx, 1); { State = 44; exp(0); State = 45; Match(Eof); } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return _localctx; }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 2) throw new Exception("Invalid number of parameters."); var left = p[0].Evaluate(context) as NumberListType; var right = p[1].Evaluate(context) as NumberListType; if (left.Length != 3 || right.Length != 3) throw new Exception("NumberList must be length 3."); return new NumberListType( left[1] * right[2] - left[2] * right[1], left[2] * right[0] - left[0] * right[2], left[0] * right[1] - left[1] * right[0]); }
public override void Execute(EvalContext context) { context.FunctionList.Set(new StatementFunction(FctName, ParamNames, StatementList)); }
public override EvalType Evaluate(EvalContext context) { return Left.Evaluate(context).Div(Right.Evaluate(context)); }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { if (p.Length != 2) throw new Exception("Invalid number of parameters."); var left = p[0].Evaluate(context) as NumberListType; var right = p[1].Evaluate(context) as NumberListType; return ls.Evaluate(context, new ListNode((left * right).Numbers)); }
public override EvalType Evaluate(EvalContext context, params ExprNode[] p) { var c = new EvalContext(context, ParamNames, p); return StmtList.Excecute(c); }
public override EvalType Evaluate(EvalContext context) { return context.FunctionList[Function].Evaluate(context, Parameters); }