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);
}
