protected override Datum eval(Datum arg1, Datum arg2) { if ((arg1 as Pair) != null || (arg2 as Pair) != null) return DatumHelpers.atom(ReferenceEquals(arg1, arg2)); return DatumHelpers.atom(arg1.Equals(arg2)); }
public override Continuation Evaluate(Continuation oldContinuation, Datum args) { // Replace the old continuation with the new continuation - but pass in the // supplied argument as the 'return value' of the new continuation. var returnValue = args.ToArray()[0]; return c.PushResult(returnValue); }
public override Continuation Evaluate(Continuation c, LexicalEnvironment env, Datum args) { var argArray = DatumHelpers.enumerate(args).ToArray(); Array.Reverse(argArray); c = c.PushTask(new InvokeFunction(function, argArray.Length)); return argArray.Aggregate(c, (current, arg) => current.Evaluate(env, arg)); }
public static Datum car(Datum d) { var pair = d as Pair; if (pair == null) throw error("'{0}' is not a pair", d); return pair.First; }
public Datum Evaluate(Datum args) { var argDatums = args.ToArray(); if (argDatums.Length != 2) throw DatumHelpers.error("Exactly 2 arguments expected"); return eval(argDatums[0], argDatums[1]); }
private static Continuation asContinuation(Datum arg) { var cfunction = arg as CallCC.ContinuationFunction; if (cfunction == null) throw DatumHelpers.error("'{0}' is not a continuation", arg); return cfunction.Continuation; }
public override Continuation Evaluate(Continuation s, Datum args) { var argArray = args.ToArray(); var expression = argArray[0]; var environment = (Environment) argArray[1].CastObject(); return s.Evaluate(environment, expression); }
private static Datum evaluate(Continuation c, Datum args) { var argList = args.ToArray(); if (argList.Length != 1) throw c.error("invalid syntax '{0}'", args); return argList[0]; }
public Datum Evaluate(Datum args) { var argArray = args.ToArray(); var names = argArray.Select(x => x.CastString()).ToArray(); var fullname = string.Join(".", names); return GetTypeEx(fullname).ToAtom(); }
public static object castObject(Datum d) { var a = d as Atom; if (a == null) throw error("Expected '{0}' to be an atom, but got '{1}' instead", d, d.GetType().Name); return a.Value; }
public override void Write(Datum aggregatedDatum) { if (!App.Available) return; if (UseLog) base.Write(aggregatedDatum); var node = ReceiverNode; if (node.IsNullOrWhiteSpace()) return; string site; if (SiteName.IsNotNullOrWhiteSpace()) site = SiteName; else site = "{0}::{1}@{2}".Args(App.Name, App.InstanceID, System.Environment.MachineName); try { if (m_Client==null) m_Client = new TelemetryReceiverClient(ReceiverNode); m_Client.Send(site, aggregatedDatum); } catch(Exception error) { cleanupClient(); WriteLog(MessageType.Error, error.ToMessageWithType(), from: "{0}.{1}".Args(GetType().Name, "Write(datum)") ); } }
public Datum Evaluate(Datum args) { var argArray = args.ToArray(); if (argArray.Length != 1) throw DatumHelpers.error("Expected a single argument. Got {0}", argArray.Length); return eval(argArray[0]); }
public Datum Evaluate(Datum args) { var function = UnaryFunction.GetSingle(args) as StackFunction; if (function == null) throw error("Expected function argument"); return ToMacro(function); }
public static Datum GetSingle(Datum args) { var argArray = args.ToArray(); if (argArray.Length != 1) throw DatumHelpers.error("Expected a single argument. Got {0}", argArray.Length); return argArray[0]; }
// Create a "special form" for a symbol that has either "." or "/" inside it. private static Datum buildSymbolForm(Datum name, IEnumerable<string> contents) { // "prefix" with a 'dot' so that higher level macros can interpret it. // This means you can't have normal symbols containing dots, which is a // small price to pay IMO. var args = compound(contents.Select(c => c == "" ? nil : parseSymbol(c)).ToArray()); return cons(name, args); }
public Datum Evaluate(Environment env, Datum datum) { var c = StackContinuation.Empty .PushTask(null) .PushResult(null) .Evaluate(env, datum); return Evaluate(c); }
/// <summary> /// 拷贝构造函数。 /// </summary> /// <param name="datum">大地坐标系对象。</param> /// <exception cref="ArgumentNullException">当大地坐标系对象为 Null 时抛出异常。</exception> public Datum(Datum datum) { if (datum == null) throw new ArgumentNullException(); this.Name = datum.Name; if (datum.Spheroid != null) this.Spheroid = new Spheroid(datum.Spheroid); this.Type = datum.Type; }
public void Set(string name, Datum newValue) { IEnvironment p; var e = find(name, out p); if(e == null) p.Set(name, newValue); else e.value = newValue; }
public Datum Evaluate(Statistics statistics, LexicalEnvironment env, Datum datum) { env.Statistics = statistics; var c = Continuation.Create(statistics) .PushTask(null) .PushResult(null) .Evaluate(env, datum); return Evaluate(c); }
public Datum Evaluate(Datum args) { var argArray = args.ToArray(); var target = unwrapDatum(argArray[0]); var methodArgs = unwrap(args.Enumerate().Skip(1)); var result = target.GetType().InvokeMember(name, BindingFlags.Default | BindingFlags.InvokeMethod, null, target, methodArgs); return result.ToAtom(); }
public override Continuation Evaluate(Continuation c, Datum args) { var argArray = args.ToArray(); if (argArray.Length != 2) throw DatumHelpers.error("Invalid syntax. ArgCount ({0}) != 2. Usage: (execute-with-error-handler <error-function> <fn>)", argArray.Length); var errorHandler = makeErrorHandler(c.ErrorHandler, (StackFunction)argArray[0]); var fn = (StackFunction)argArray[1]; return fn.Evaluate(c.NewErrorHandler(errorHandler), DatumHelpers.compound()); }
private static object unwrapDatum(Datum d) { var atom = d as Atom; if (atom != null) return atom.Value; // For now, assume that if anything other than atom is // passed into the .Net layer then the target function // actually expects a Datum. return d; }
public Continuation Perform(Continuation c) { var args = new Datum[argCount]; for (var i = 0; i < argCount; ++i) { args[i] = c.Result; c = c.PopResult(); } return function.Evaluate(c, DatumHelpers.compound(args)); }
public override Continuation Evaluate(Continuation c, Environment env, Datum args) { var argList = args.ToArray(); if (argList.Length != 2) throw c.error("Expected 2 arguments: (set! <symbol> <expression>). Got {0} instead", argList.Length); var name = argList[0].CastIdentifier(); var expression = argList[1]; c = c.PushTask(new SetName(env, name)); return c.Evaluate(env, expression); }
private static bool[] Classify(SVInfo[] sVecs, Datum[] testData, Func<Rational[], Rational[], Rational> kernel, Rational w0) { var foo = testData .Select(d => { var tmp = sVecs.Select(sv => sv.alpha * sv.y * kernel(sv.x, d.x)).Aggregate((acc, r) => acc + r) + w0; return tmp * d.y > 0;//numeric instability mignt make tmp not qute be -1/+1. }) .ToArray(); return foo; }
/* メソッド ***********************************************/ /// <summary> /// コンストラクタ /// </summary> /// <param name="datum">測地系の種類</param> public GlobalDatum(Datum datum) { datumKind = datum; if (datum == Datum.WGS84) _datum = new Wgs84(); else if (datum == Datum.GRS80) _datum = new Grs80(); else throw new ArgumentException("GlobalDatumクラスのコンストラクタにてエラーがスローされました。不明な測地系が指定されています。"); }
public override Continuation Evaluate(Continuation c, Datum args) { var datumArgs = args.ToArray(); if (datumArgs.Length != 2) throw c.error("Apply expects 2 arguments. {0} passed", datumArgs.Length); var function = datumArgs[0] as StackFunction; if (function == null) throw c.error("'{0}' is not a function", datumArgs[0]); return function.Evaluate(c, datumArgs[1]); }
/** メソッド ********************************************************************/ /// <summary> /// コンストラクタ /// </summary> /// <param name="unit">単位(°or rad)</param> /// <param name="datum">測地系</param> public FieldParameter(AngleUnit unit = AngleUnit.Degree, Datum datum = Datum.WGS84) { this.unit = unit; this.datum = datum; this.upperLat = double.NaN; this.eastLon = double.NaN; this.lowerLat = double.NaN; this.westLon = double.NaN; this.centerLon = double.NaN; }
public Datum Evaluate(Datum args) { var a = args.ToArray(); if (a.Length != 1) // TODO: Move this error boiler plate into DatumHelpers throw error("Incorrect arguments. Expected {0}, got {1}", 1, a.Length); var function = a[0] as StackFunction; if (function == null) throw error("Expected function argument"); return ToMacro(function); }
public override Continuation Evaluate(Continuation c, Datum args) { var argArray = args.ToArray(); if(argArray.Length != 1) throw DatumHelpers.error("call/cc: expect a single function as an argument. Got {0}", argArray.Length); var arg = argArray[0]; var function = arg as StackFunction; if(function == null) throw DatumHelpers.error("call/cc: {0} must be a function", arg); return function.Evaluate(c, DatumHelpers.compound(new ContinuationFunction(c))); }
protected override Datum eval(Datum arg) { var macro = arg as MacroClosure; return(macro == null ? nil : macro.Function); }