public static object GetConstant(this Generator.Ctx ctx, string valueName) { int i = ctx.IndexOf(valueName); var val = (i < 0) ? null : ctx[i]; if (val == null) { return(null); } var expr = val as Expr; if (expr != null) { val = Generator.Generate(expr, ctx); } if (OPs.KindOf(val) == ValueKind.Const) { return(val); } else if (expr != null) { return(ctx.Error(string.Format("Constant expected as value of '{0}' // {1}", valueName, expr))); } else { return(ctx.Error(string.Format("Constant expected as value of '{0}'", valueName))); } }
public static object SolverWeightedSumsFactory(IList args) { var periodInDays = Convert.ToDouble(args[0]); var startTime = OPs.FromExcelDate(Convert.ToDouble(args[1])); var endTime = OPs.FromExcelDate(Convert.ToDouble(args[2])); return(new WeightedSums.Factory(startTime, endTime, TimeSpan.FromDays(periodInDays))); }
public static object DAY(object date) { if (W.Common.Utils.IsEmpty(date)) { return(DBNull.Value); } return(OPs.FromExcelDate(OPs.xl2dbl(date)).Day); }
public static object MOD(object _x, object _y) { var x = OPs.xl2dbl(_x); var y = OPs.xl2dbl(_y); var d = Math.Truncate(x / y); return(x - d * y); }
public static object UseSqlAsFuncsFrom(CallExpr ce, Generator.Ctx ctx) { var arg0 = Generator.Generate(ce.args[0], ctx); if (OPs.KindOf(arg0) != ValueKind.Const) { ctx.Error("Constant value expected"); } var arg1 = (ce.args.Count < 2) ? null : Generator.Generate(ce.args[1], ctx); var sqlFileName = Convert.ToString(arg0); DbFuncType forKinds; if (arg1 == null) { forKinds = DbFuncType.TimeSlice | DbFuncType.TimeInterval; } else { var lst = arg1 as IList ?? new object[] { arg1 }; forKinds = DbFuncType.None; foreach (var v in lst) { forKinds |= (DbFuncType)Enum.Parse(typeof(DbFuncType), Convert.ToString(v)); } } var dbConnName = (ce.args.Count < 3) ? DefaultDbConnName : OPs.TryAsName(ce.args[2], ctx); if (string.IsNullOrEmpty(dbConnName)) { ctx.Error($"Connection name must be nonempty: {ce.args[2]}"); } var fullFileName = Path.IsPathRooted(sqlFileName) ? sqlFileName : Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Convert.ToString(sqlFileName)); var cacheKey = $"FuncDefs:{fullFileName}:{forKinds.ToString()}"; Func <object> ldfsFunc = () => { var sqlCtx = new W.Expressions.Sql.Preprocessing.PreprocessingContext() { sqlFileName = fullFileName, cacheSubdomain = "DB", dbConnValueName = dbConnName, forKinds = forKinds, ctx = ctx, cachingExpiration = TimeSpan.FromMinutes(5), defaultLocationForValueInfo = (ce.args.Count < 4) ? null : OPs.TryAsString(ce.args[3], ctx) }; return(sqlCtx.LoadingFuncs()); }; var lfds = (IEnumerable <FuncDef>)FuncDefs_Core._Cached(cacheKey, ldfsFunc, DateTimeOffset.MaxValue, TimeSpan.FromMinutes(5)); return(lfds); }
public Task <object> Aggregate(AsyncExprCtx parent, IList data) { int i = aggCtx.name2ndx[sData]; var vals = new object[aggCtx.values.Count]; aggCtx.values.CopyTo(vals, 0); vals[i] = data; var aec = new AsyncExprCtx(aggCtx, vals, parent); return(OPs.ConstValueOf(aec, aggCode)); }
public static object TIMEVALUE(object arg) { DateTime dt; if (!TryCastAsDateTime(arg, out dt)) { return(new ArgumentException("TIMEVALUE")); } double v = OPs.ToExcelDate(dt); return(v - Math.Truncate(v)); }
public static object GetConstant(this Generator.Ctx ctx, Expr expr) { var val = Generator.Generate(expr, ctx); if (OPs.KindOf(val) == ValueKind.Const) { return(val); } else { return(ctx.Error("Constant expected as value of " + expr.ToString())); } }
public IEnumerable <FuncDef> GetFunc(string name, int arity) { if (name == null) { var ctx = this; while (ctx != null) { foreach (var v in ctx.values) { var fd = v as FuncDef; if (fd != null) { yield return(fd); } } ctx = ctx.parent; } } else { int i = IndexOf(name); if (i >= 0) { var v = this[i]; if (v is FuncDef) { var def = (FuncDef)v; if (def.minArity <= arity && arity <= def.maxArity) { yield return(def); } } else if (v is LazyAsync) { AsyncFn f = (ae, args) => { return(OPs._call_func(ae, i, args)); }; yield return(new FuncDef(f, 0, int.MaxValue, name)); } } } for (int i = externalFuncs.Count - 1; i >= 0; i--) { foreach (var fd in externalFuncs[i](name, arity)) { yield return(fd); } } }
public static object MAX(IList args) { double max = double.MinValue; foreach (object v in OPs.Flatten(args)) { double?tmp = OPs.xl2dbl2(v); if (tmp.HasValue && tmp > max) { max = tmp.Value; } } return(max); }
public static object MIN(IList args) { double min = double.MaxValue; foreach (object v in OPs.Flatten(args)) { double?tmp = OPs.xl2dbl2(v); if (tmp.HasValue && tmp < min) { min = tmp.Value; } } return(min); }
public CtxValue(object valueToCalc, AsyncExprCtx context) { this.value = (LazyAsync) delegate(AsyncExprCtx ae) { if (ae != context) { return(OPs.ConstValueOf(context, valueToCalc)); } else { return(OPs.ConstValueOf(ae, valueToCalc)); } }; }
//[Arity(2, 3)] //public static object IF(CallExpr ce, Generator.Ctx ctx) //{ return FuncDefs_Core.IF(ce, ctx); } public static object SUM(IList args) { double sum = 0; foreach (object v in OPs.Flatten(args)) { double?tmp = OPs.xl2dbl2(v); if (tmp.HasValue) { sum += tmp.Value; } } return(sum); }
public static object GenFxyCall(FuncDef fd, object a, object b) { ValueKind kind = OPs.MaxKindOf(a, b); if (fd.resultCanBeLazy) { kind = ValueKind.Async; } else if (kind == ValueKind.Const && fd.isNotPure) { kind = ValueKind.Sync; } return(GenFxyCall((Fxy)fd.func, a, b, kind, fd.resultCanBeLazy)); }
public static object DATEVALUE(object arg) { if (arg == null) { return(null); } DateTime dt; if (!TryCastAsDateTime(arg, out dt)) { return(new ArgumentException("DATEVALUE")); } return(OPs.ToExcelDate(dt.Date)); }
public static object Divide(object arg) { return(Utils.Calc(arg, 2, 1, data => { var r = OPs.xl2dbl(data[0]) / OPs.xl2dbl(data[1]); if (double.IsNaN(r)) { return null; } else { return OPs.WithTime(data[0], data[1], r); } })); }
public static string TryAsString(Expr expr, Generator.Ctx ctx) { var ce = expr as ConstExpr; if (ce != null) { return(Convert.ToString(ce.value)); } var val = Generator.Generate(expr, ctx); if (OPs.KindOf(val) == ValueKind.Const && val != null) { return(Convert.ToString(val)); } return(null); }
public static object FindDependencies(CallExpr ce, Generator.Ctx ctx) { var arg0 = Generator.Generate(ce.args[0], ctx); if (OPs.KindOf(arg0) != ValueKind.Const || arg0 == null) { throw new SolverException("FindDependencies: list of source params must be constant and not null"); } var arg1 = (ce.args.Count > 1) ? Generator.Generate(ce.args[1], ctx) : null; if (OPs.KindOf(arg1) != ValueKind.Const) { throw new SolverException("FindDependencies: optional list of dependent params must be constant"); } var arg2 = (ce.args.Count > 2) ? Generator.Generate(ce.args[2], ctx) : null; if (OPs.KindOf(arg2) != ValueKind.Const) { throw new SolverException("FindDependencies: optional list of unusable params must be constant"); } var srcPrms = ((IList)arg0).Cast <object>().Select(o => o.ToString()).ToArray(); var depPrms = (arg1 == null) ? null : ((IList)arg1).Cast <object>().Select(o => o.ToString()).ToArray(); var unusables = (arg2 == null) ? new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) : ((IList)arg2).Cast <object>().Select(o => o.ToString()).ToDictionary(s => s, StringComparer.OrdinalIgnoreCase); var aliasOf = GetAliases(ctx); var funcs = Dependecies.GetFuncInfos(ctx.GetFunc(null, 0), aliasOf, fi => !fi.inputs.Any(inp => unusables.ContainsKey(inp))); var dependencies = Dependecies.Find(funcs, aliasOf, int.MaxValue, srcPrms, depPrms); var resDict = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase); var resParams = (depPrms == null) ? dependencies.Keys.Except(srcPrms, StringComparer.OrdinalIgnoreCase) : depPrms.Where(s => dependencies.ContainsKey(s)); var res = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); foreach (var prmName in resParams) { var deps = dependencies[prmName]; var srcs = srcPrms.Where(s => deps.ContainsKey(s)).ToArray(); if (srcs.Length > 0) { res.Add(prmName, srcs); } } return(res); }
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)); }
public static async Task <object> ISERR(AsyncExprCtx ctx, IList args) { try { object value = await OPs.ConstValueOf(ctx, args[0]); var lst = value as IList; if (lst != null) { var res = lst.ToArray(item => item is Exception || item is W.Common.ErrorWrapper); return(res); } else { return(value is Exception || value is W.Common.ErrorWrapper); } } catch (OperationCanceledException) { throw; } catch { return(True); } }
public static object SolverTimedTabulation(IList args) { var items = Utils.ToIList(args[0]) ?? new object[0]; var timeA = Convert.ToDouble(args[1]); var timeB = Convert.ToDouble(args[2]); var nParts = Convert.ToInt32(args[3]); var what = (args.Count > 4) ? Convert.ToString(args[4]) : null; var f = new WeightedSums.Factory(OPs.FromExcelDate(timeA), OPs.FromExcelDate(timeB), nParts); var sums = f.NewSums(); sums.Add(items); var data = sums.Get(what ?? "AVGS"); // prepare result array var res = new object[data.Length]; for (int i = 0; i < data.Length; i++) { res[i] = double.IsNaN(data[i]) ? null : (object)data[i]; } return(res); }
public async Task <object> Get(AsyncExprCtx ae) { var s = sema; if (s != null) { if (s == errFlag) { throw (Exception)value; } await s.WaitAsync(ae.Cancellation); try { if (sema != null) { // enter here only once if (sema == errFlag) { throw (Exception)value; } try { value = await OPs.VectorValueOf(ae, value); sema = null; } catch (OperationCanceledException) { throw; } catch (Exception ex) { value = ex; var tmp = sema; sema = errFlag; //tmp.Dispose(); throw; } } } finally { s.Release(); } } return(value); }
static object solverAliasImpl(CallExpr ce, Generator.Ctx ctx) { var alias = OPs.TryAsName(ce.args[0], ctx); if (alias == null) { throw new SolverException(string.Format(ce.funcName + "(alias ...): alias must be constant or name instead of [{0}]", ce.args[0])); } var target = (ce.args.Count > 1) ? OPs.TryAsName(ce.args[1], ctx) : string.Empty; if (target == null) { throw new SolverException(string.Format(ce.funcName + "(..., target ...): target must be constant or name instead of [{0}]", ce.args[0])); } int priority = (ce.args.Count > 2) ? Convert.ToInt32(ctx.GetConstant(ce.args[2])) : 255; int i = ctx.GetOrCreateIndexOf(optionSolverAliases); var aliases = ctx[i] as SolverAliases; if (aliases == null) { aliases = new SolverAliases(); ctx[i] = aliases; } switch (ce.funcName) { case nameof(solverAlias): return(aliases.Set(alias, target, priority)); case nameof(solverAliasPush): return(aliases.Push(alias, target)); case nameof(solverAliasPop): return(aliases.Pop(alias)); default: throw new NotImplementedException(ce.funcName); } }
public Task LoadData(AsyncExprCtx rootAec, Expr loadingExpr, CancellationToken ct) { int i = aggCtx.IndexOf(sFactory); if (i >= 0) { var f = (WeightedSums.Factory)aggCtx[i]; foreach (var n2i in aggCtx.name2ndx) { if (n2i.Key.StartsWith(sAkk)) { aggCtx[n2i.Value] = f.NewSums(); } } } var loadingCtx = new Generator.Ctx(aggCtx.parent); loadingCtx.CreateValue(sUsedParamsDict, aggCtx[aggCtx.IndexOf(sUsedParamsDict)]); loadingCtx.CreateValue(sLoadingInfo, this); var loadingCode = Generator.Generate(loadingExpr, loadingCtx); var ae = new AsyncExprCtx(loadingCtx, loadingCtx.values, rootAec); return(OPs.ConstValueOf(ae, loadingCode)); }
public static object LN(object x) { return(Math.Log(OPs.xl2dbl(x))); }
public static object SQRT(object x) { return(Math.Sqrt(OPs.xl2dbl(x))); }
public static object POWER(object x, object y) { return(Math.Pow(OPs.xl2dbl(x), OPs.xl2dbl(y))); }
static IEnumerable <FuncDef> DefineProjectionFuncsImpl(CallExpr ce, Generator.Ctx ctx, bool acceptVector) { var inpParams = ((IList)OPs.GetConstant(ctx, ce.args[0])).Cast <object>().Select(Convert.ToString).ToArray(); var inpParamsParts = inpParams.Select(s => s.Split('_')).ToArray(); var inpParamsMasks = inpParamsParts.Where(parts => parts.Any(string.IsNullOrEmpty)).ToArray(); var outParams = ((IList)OPs.GetConstant(ctx, ce.args[1])).Cast <object>().Select(Convert.ToString).ToArray(); var outParamsMasks = outParams.Select(s => Convert.ToString(s).Split('_')).ToArray(); var newFuncName = "@projfunc:" + ce.args[ce.args.Count - 1].ToString().Replace('(', '_').Replace(')', '_').Replace('"', '_').Replace('\'', '_'); #region Collect suitable parameters from all functions outputs var suitableParams = new Dictionary <string, string[]>(StringComparer.OrdinalIgnoreCase); foreach (var f in ctx.GetFunc(null, 0)) { foreach (var prm in f.resultsInfo) { var prmParts = prm.Parts(); for (int i = 0; i < inpParamsMasks.Length; i++) { var maskParts = inpParamsMasks[i]; var details = GetDetailsIfMatched(prmParts, maskParts); if (details == null) { continue; } if (!suitableParams.TryGetValue(details, out var suitables)) { suitables = new string[inpParamsMasks.Length]; suitableParams.Add(details, suitables); } suitables[i] = details; } } } #endregion #region Return FuncDef for each suitable params set foreach (var suitable in suitableParams.Where(prms => prms.Value.All(s => s != null))) { var details = suitable.Key; var inps = new string[inpParamsParts.Length]; for (int i = 0; i < inpParamsParts.Length; i++) { var ip = inpParamsParts[i]; if (ip.Any(string.IsNullOrEmpty)) { // one or more parts masked inps[i] = ParamFromMaskAndDetails(details, ip); } else { inps[i] = inpParams[i]; } } var outs = new string[outParams.Length]; for (int i = 0; i < outParamsMasks.Length; i++) { outs[i] = ParamFromMaskAndDetails(details, outParamsMasks[i]); } yield return(FuncDefs_Core.macroFuncImpl( context: ctx, nameForNewFunc: new ConstExpr(newFuncName + details), inpsDescriptors: new ArrayExpr(inps.Select(ReferenceExpr.Create).Cast <Expr>().ToList()), outsDescriptors: new ArrayExpr(outs.Select(ReferenceExpr.Create).Cast <Expr>().ToList()), funcBody: ce.args[ce.args.Count - 1], inputParameterToSubstitute: (ce.args.Count > 3) ? ce.args[2] : null, funcAcceptVector: acceptVector )); } #endregion }
public static object ROUND(object x, object nDigits) { return(Math.Round(OPs.xl2dbl(x), Convert.ToInt32(nDigits))); }
public static object LOG(object x, object y) { return(Math.Log(OPs.xl2dbl(x), OPs.xl2dbl(y))); }