public static void Load(int factPriority = FactPriority) { LoadPostFactorial(factPriority); numE = new CalcNumber((decimal)Math.E); numPI = new CalcNumber((decimal)Math.PI); E = new CLCodeFunction("e", (pars, vars, context) => numE); PI = new CLCodeFunction("pi", (pars, vars, context) => numPI); Abs = new CLCodeFunction("abs", AbsFunction); Acos = new CLCodeFunction("acos", AcosFunction); Acosh = new CLCodeFunction("acosh", AcoshFunction); Asin = new CLCodeFunction("asin", AsinFunction); Asinh = new CLCodeFunction("asinh", AsinhFunction); Atan = new CLCodeFunction("atan", AtanFunction); Atan2 = new CLCodeFunction("atan2", Atan2Function); Atanh = new CLCodeFunction("atanh", AtanhFunction); Cos = new CLCodeFunction("cos", CosFunction); Cosh = new CLCodeFunction("cosh", CoshFunction); Sin = new CLCodeFunction("sin", SinFunction); Sinh = new CLCodeFunction("sinh", SinhFunction); Tan = new CLCodeFunction("tan", TanFunction); Tanh = new CLCodeFunction("tanh", TanhFunction); Ceiling = new CLCodeFunction("ceiling", CeilingFunction); CopySign = new CLCodeFunction("copysign", CopySignFunction); Floor = new CLCodeFunction("floor", FloorFunction); Log = new CLCodeFunction("log", LogFunction); Max = new CLCodeFunction("max", MaxFunction); MaxMagnitude = new CLCodeFunction("maxmagnitude", MaxMagnitudeFunction); Min = new CLCodeFunction("min", MinFunction); MinMagnitude = new CLCodeFunction("minmagnitude", MinMagnitudeFunction); Sign = new CLCodeFunction("sign", SignFunction); }
/// <summary> /// Creates a new <c>CalcCodeFunction</c>. /// </summary> /// <param name="name">The name of the function to call.</param> /// <param name="pars">The parameters for the called function.</param> public CalcCodeFunction(string name, CalcObject[] pars) { Function = CLCodeFunction.Get(name); Params = pars; }
public static void Load() { // First we need some local types Type num = typeof(CalcNumber); Type lst = typeof(CalcList); Type val = typeof(CalcValue); Type obj = typeof(CalcObject); // The binary "d" operator. BinaryDice = CLOperators.BinaryOperators.GetOrNull("d") ?? new CLBinaryOperator("d", DicePriority, true, true); BinaryDice.AddFunction(num, num, BinDice); BinaryDice.AddFunction(num, lst, BinDice); BinaryDice.AddFunction(lst, num, (left, right, vars, context) => BinDice(ListToNum(left), right, vars, context)); BinaryDice.AddFunction(lst, lst, (left, right, vars, context) => BinDice(ListToNum(left), right, vars, context)); // The prefix "d" operator. PrefixDie = CLOperators.PrefixOperators.GetOrNull("d") ?? new CLPrefixOperator("d", DicePriority, true); PrefixDie.AddFunction(num, (oper, vars, context) => ((CalcList)BinDice(new CalcNumber(1), oper, vars, context))[0]); PrefixDie.AddFunction(lst, (oper, vars, context) => ((CalcList)BinDice(new CalcNumber(1), oper, vars, context))[0]); // The comparison "u" operator. ComparisonUntil = (CLOperators.BinaryOperators.GetOrNull("u=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("u", DicePriority, true, true); ComparisonUntil.AddFunction(num, num, CompUntil); ComparisonUntil.AddFunction(lst, num, CompUntil); ComparisonUntil.AddFunction(num, lst, (left, comp, right, vars, context) => CompUntil(left, comp, ListToNum(right), vars, context)); ComparisonUntil.AddFunction(lst, lst, (left, comp, right, vars, context) => CompUntil(left, comp, ListToNum(right), vars, context)); // The binary "r" operator. BinaryReroll = (CLOperators.BinaryOperators.GetOrNull("r")) ?? new CLBinaryOperator("r", RerollPriority, true, true); BinaryReroll.AddFunction(num, num, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, right, vars, context, false, false)); BinaryReroll.AddFunction(lst, num, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, right, vars, context, false, false)); BinaryReroll.AddFunction(num, lst, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, ListToNum(right), vars, context, false, false)); BinaryReroll.AddFunction(lst, lst, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, ListToNum(right), vars, context, false, false)); // The binary "x" operator. BinaryExplode = (CLOperators.BinaryOperators.GetOrNull("x")) ?? new CLBinaryOperator("x", RerollPriority, true, true); BinaryExplode.AddFunction(num, num, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, right, vars, context, true, false)); BinaryExplode.AddFunction(lst, num, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, right, vars, context, true, false)); BinaryExplode.AddFunction(num, lst, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, ListToNum(right), vars, context, true, false)); BinaryExplode.AddFunction(lst, lst, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, ListToNum(right), vars, context, true, false)); // The binary "xr" operator. BinaryExplodeRecursive = (CLOperators.BinaryOperators.GetOrNull("xr")) ?? new CLBinaryOperator("xr", RerollPriority, true, true); BinaryExplodeRecursive.AddFunction(num, num, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, right, vars, context, true, true)); BinaryExplodeRecursive.AddFunction(lst, num, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, right, vars, context, true, true)); BinaryExplodeRecursive.AddFunction(num, lst, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, ListToNum(right), vars, context, true, true)); BinaryExplodeRecursive.AddFunction(lst, lst, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, ListToNum(right), vars, context, true, true)); // The comparison "r" operator. ComparisonReroll = (CLOperators.BinaryOperators.GetOrNull("r=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("r", RerollPriority, true, true); ComparisonReroll.AddFunction(num, num, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, right, vars, context, false, false)); ComparisonReroll.AddFunction(lst, num, (left, comp, right, vars, context) => CompRerolls(left, comp, right, vars, context, false, false)); ComparisonReroll.AddFunction(num, lst, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, ListToNum(right), vars, context, false, false)); ComparisonReroll.AddFunction(lst, lst, (left, comp, right, vars, context) => CompRerolls(left, comp, ListToNum(right), vars, context, false, false)); // The comparison "x" operator. ComparisonExplode = (CLOperators.BinaryOperators.GetOrNull("x=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("x", RerollPriority, true, true); ComparisonExplode.AddFunction(num, num, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, right, vars, context, true, false)); ComparisonExplode.AddFunction(lst, num, (left, comp, right, vars, context) => CompRerolls(left, comp, right, vars, context, true, false)); ComparisonExplode.AddFunction(num, lst, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, ListToNum(right), vars, context, true, false)); ComparisonExplode.AddFunction(lst, lst, (left, comp, right, vars, context) => CompRerolls(left, comp, ListToNum(right), vars, context, true, false)); // The comparison "xr" operator. ComparisonExplodeRecursive = (CLOperators.BinaryOperators.GetOrNull("xr=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("xr", RerollPriority, true, true); ComparisonExplodeRecursive.AddFunction(num, num, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, right, vars, context, true, true)); ComparisonExplodeRecursive.AddFunction(lst, num, (left, comp, right, vars, context) => CompRerolls(left, comp, right, vars, context, true, true)); ComparisonExplodeRecursive.AddFunction(num, lst, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, ListToNum(right), vars, context, true, true)); ComparisonExplodeRecursive.AddFunction(lst, lst, (left, comp, right, vars, context) => CompRerolls(left, comp, ListToNum(right), vars, context, true, true)); // The binary "k" operator. BinaryKeep = CLOperators.BinaryOperators.GetOrNull("k") ?? new CLBinaryOperator("k", KeepPriority, true, true); BinaryKeep.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, true, true, vars)); BinaryKeep.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, true, true, vars)); BinaryKeep.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), true, true, vars)); BinaryKeep.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), true, true, vars)); // The binary "kh" operator. BinaryKeepHigh = CLOperators.BinaryOperators.GetOrNull("kh") ?? new CLBinaryOperator("kh", KeepPriority, true, true); BinaryKeepHigh.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, true, true, vars)); BinaryKeepHigh.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, true, true, vars)); BinaryKeepHigh.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), true, true, vars)); BinaryKeepHigh.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), true, true, vars)); // The binary "kl" operator. BinaryKeepLow = CLOperators.BinaryOperators.GetOrNull("kl") ?? new CLBinaryOperator("kl", KeepPriority, true, true); BinaryKeepLow.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, true, false, vars)); BinaryKeepLow.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, true, false, vars)); BinaryKeepLow.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), true, false, vars)); BinaryKeepLow.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), true, false, vars)); // The binary "dh" operator. BinaryDropHigh = CLOperators.BinaryOperators.GetOrNull("dh") ?? new CLBinaryOperator("dh", KeepPriority, true, true); BinaryDropHigh.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, false, true, vars)); BinaryDropHigh.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, false, true, vars)); BinaryDropHigh.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), false, true, vars)); BinaryDropHigh.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), false, true, vars)); // The binary "dl" operator. BinaryDropLow = CLOperators.BinaryOperators.GetOrNull("dl") ?? new CLBinaryOperator("dl", KeepPriority, true, true); BinaryDropLow.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, false, false, vars)); BinaryDropLow.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, false, false, vars)); BinaryDropLow.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), false, false, vars)); BinaryDropLow.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), false, false, vars)); // The comparison "k" operator. ComparisonKeep = (CLOperators.BinaryOperators.GetOrNull("k=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("k", KeepPriority, true, true); ComparisonKeep.AddFunction(num, num, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp, right, vars)); ComparisonKeep.AddFunction(lst, num, (left, comp, right, vars, context) => KeepCompare(left, comp, right, vars)); ComparisonKeep.AddFunction(num, lst, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp, ListToNum(right), vars)); ComparisonKeep.AddFunction(lst, lst, (left, comp, right, vars, context) => KeepCompare(left, comp, ListToNum(right), vars)); // The comparison "d" operator. ComparisonDrop = (CLOperators.BinaryOperators.GetOrNull("d=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("d", KeepPriority, true, true); ComparisonDrop.AddFunction(num, num, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp.Opposite, right, vars)); ComparisonDrop.AddFunction(lst, num, (left, comp, right, vars, context) => KeepCompare(left, comp.Opposite, right, vars)); ComparisonDrop.AddFunction(num, lst, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp.Opposite, ListToNum(right), vars)); ComparisonDrop.AddFunction(lst, lst, (left, comp, right, vars, context) => KeepCompare(left, comp.Opposite, ListToNum(right), vars)); // The binary "**" operator. BinaryRepeat = CLOperators.BinaryOperators.GetOrNull("**") ?? new CLBinaryOperator("**", RepeatPriority, false, true); BinaryRepeat.AddFunction(obj, num, BinRepeat); BinaryRepeat.AddFunction(obj, lst, (left, right, vars, context) => BinRepeat(left, ListToNum(right), vars, context)); // The "!die" function FuncDie = new CLCodeFunction("die", FunctionDie); }
/// <summary> /// Returns the object referenced by the name. /// </summary> /// <param name="vars">A <c>CLLocalStore</c> that stores local /// variables.</param> /// <param name="context">The object representing the context in which /// the expression is being evaluated.</param> public CalcObject GetObject(CLLocalStore vars = null, CLContextProvider context = null) { vars ??= new CLLocalStore(); context ??= new CLContextProvider(); if (Name.StartsWith("!")) { if (CLCodeFunction.Exists(Name.Substring(1))) { return(new CalcCodeFunction(Name.Substring(1), Params)); } } if (Name.StartsWith("_") || Name.StartsWith("^")) { if (!(vars.ContainsVar(Name))) { throw new CLException("No variable named " + Name + " exists."); } else { return(vars[Name]); } } int count = 0; if (Int32.TryParse(Name, out count)) { if (count == 0) { return(new CalcString(Name)); } if (vars.ParamCount >= count) { return(vars[count - 1]); } else if (Params.Length > 0) { return(Params[0]); } else { throw new CLException("No parameter #" + count + " exists."); } } if (Name == "...") { return(new CalcListExpression(vars.CopyParams())); } CalcObject ret = CLVariables.Load(Name, context); if (ret != null) { return(ret); } throw new CLException("No variable named " + Name + " exists."); }