Пример #1
0
            public static object AGGR(CallExpr call, Generator.Ctx ctx)
            {
                CallExpr ce;
                {
                    var dict = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
                    ce = Filter.ReplaceValueInfoRefsWithData(call, DataLoader.sData, dict);
                    ctx.CreateValue(DataLoader.sUsedParamsDict, dict);
                }

                var args = new List <Expr>();

                args.Add(CallExpr.let(new ReferenceExpr(sFactory),
                                      new CallExpr(FuncDefs_Solver.SolverWeightedSumsFactory, ce.args[0], new ReferenceExpr(sTimeA), new ReferenceExpr(sTimeB))));
                args.Add(CallExpr.let(new ReferenceExpr(sWithKey), ce.args[1]));

                for (int i = 2; i < ce.args.Count; i++)
                {
                    args.Add(ce.args[i]);
                }
                var exprAgg = CallExpr.Eval(args.ToArray());

                var expr = new CallExpr(FuncDefs_Solver.SolverTimedObjects,
                                        new CallExpr((Fx)FuncDefs_Solver.SolverWeightedSumsFactoryTimes, new ReferenceExpr(sFactory)), exprAgg);

                return(Generator.Generate(expr, ctx));
            }
Пример #2
0
        public static object letLookupFunc(CallExpr ce, Generator.Ctx ctx)
        {
            var    arg0 = ce.args[0];
            object name;
            var    ref0 = arg0 as ReferenceExpr;

            if (ref0 != null)
            {
                name = ref0.name;
            }
            else
            {
                name = Generator.Generate(arg0, ctx);
                if (OPs.KindOf(name) != ValueKind.Const)
                {
                    throw new SolverException("letLookupFunc(name, ...) : name must be constant");
                }
            }
            var keysDescriptorObjs = Generator.Generate(ce.args[1], ctx);
            var keysDescriptors    = keysDescriptorObjs as IList;

            if (OPs.KindOf(keysDescriptorObjs) != ValueKind.Const || keysDescriptors == null)
            {
                throw new SolverException("letLookupFunc(...,keysDescrs ...) : keysDescrs must be list of constants");
            }
            var valsDescriptorObjs = Generator.Generate(ce.args[2], ctx);
            var valsDescriptors    = valsDescriptorObjs as IList;

            if (OPs.KindOf(valsDescriptorObjs) != ValueKind.Const || valsDescriptors == null)
            {
                throw new SolverException("letLookupFunc(...,...,valuesDescrs ...) : valuesDescrs must be list of constants");
            }
            var body = ce.args[3];
            var func = (Macro)((expr, gctx) =>
                               Generator.Generate(body, gctx)
                               );
            var keys = keysDescriptors.Cast <object>().Select(Convert.ToString);
            var vals = valsDescriptors.Cast <object>().Select(Convert.ToString);
            var fd   = GetLookupFuncDef(Convert.ToString(name), keys, vals, func);

            return(Generator.Generate(CallExpr.let(ce.args[0], new ConstExpr(fd)), ctx));
        }