public IBlauSpaceEvaluation MeanEvaluation(IBlauSpaceLattice lattice) { IAgentEvaluationBundleCollapser meanCalculator = AgentEvaluationBundleCollapser_Mean.Instance(); IBlauSpaceEvaluation mean = meanCalculator.eval(this, lattice); return(mean); }
public IBlauSpaceEvaluation AssignmentCounts(IBlauSpaceLattice lattice) { IAgentEvaluationBundleCollapser countsCalculator = AgentEvaluationBundleCollapser_Counts.Instance(); IBlauSpaceEvaluation counts = countsCalculator.eval(this, lattice); return(counts); }
public IBlauSpaceEvaluation eval(IAgentEvaluationBundle aeb, IBlauSpaceLattice lattice) { IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(lattice); IBlauSpaceMultiEvaluation bsme = new BlauSpaceMultiEvaluation(aeb.Name, lattice); IBlauSpaceEvaluation bse = new BlauSpaceEvaluation(aeb.Name + "-Std", lattice); foreach (IAgentEvaluation ae in aeb.Evaluations) { ae.AddToBlauSpaceMultiEvaluation(bsme); } foreach (IBlauPoint p in bsme.AssignedLatticePoints) { LinkedList <IScore> scores = bsme.eval(p); double meanValue = meanEval.eval(p); double total = 0.0; int count = 0; foreach (IScore s in scores) { double delta = (s.Value - meanValue); total += (delta * delta); count++; } double mean = Math.Sqrt(total) / (double)count; bse.set(p, mean); } return(bse); }
public IBlauSpaceEvaluation StdEvaluation(IBlauSpaceLattice lattice) { IAgentEvaluationBundleCollapser stdCalculator = AgentEvaluationBundleCollapser_Std.Instance(); IBlauSpaceEvaluation std = stdCalculator.eval(this, lattice); return(std); }
/* * protected override int RecalculateHashCode() { * int val = 0; * int digit = 1; * for (int i=0; i<this.Space.Dimension; i++) { * val += getQuantizedCoordinate(i) * digit; * val = val % Int16.MaxValue; * * digit *= _quantizer.getSteps(i); * digit = digit % Int16.MaxValue; * } * return val; * } */ public QuantizedBlauPoint(IBlauSpace space, IBlauSpaceLattice quantizer) : base(space) { _quantizer = quantizer; _quantizedCoords = new int [space.Dimension]; for (int i = 0; i < space.Dimension; i++) { this.setQuantizedCoordinate(i, 0); } }
public void BlauSpaceLatticeSerializationTest() { Console.WriteLine("BlauSpaceLatticeSerializationTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 200.0, 300.0 }; IBlauSpace bs = BlauSpace.create(dim, names, mins, maxs); int [] steps1 = new int [3] { 10, 10, 10 }; IBlauSpaceLattice bsl1a = BlauSpaceLattice.create(bs, steps1); IBlauSpaceLattice bsl1b = BlauSpaceLattice.create(bs, steps1); Assert.AreEqual(bsl1a == bsl1b, true); int [] steps2 = new int [3] { 20, 20, 20 }; IBlauSpaceLattice bsl2 = BlauSpaceLattice.create(bs, steps2); Assert.AreEqual(bsl1a == bsl2, false); FileStream fs = new FileStream("bsl1.xml", FileMode.Create); SoapFormatter formatter = new SoapFormatter(); formatter.Serialize(fs, bsl1a); fs.Flush(); fs.Close(); SingletonLogger.Instance().DebugLog(typeof(blau_tests), "bsl1a => " + bsl1a.ToString()); FileStream fs2 = new FileStream("bsl1.xml", FileMode.Open); BlauSpaceLattice bsl1read = (BlauSpaceLattice)formatter.Deserialize(fs2); fs2.Close(); SingletonLogger.Instance().DebugLog(typeof(blau_tests), "bs1read => " + bsl1read.ToString()); IBlauSpaceLattice bsl3 = BlauSpaceLatticeRegistry.Instance().validate(bsl1read); Assert.AreEqual(bsl1a == bsl3, true); SingletonLogger.Instance().DebugLog(typeof(blau_tests), "bs1a agrees with validated bs1read"); Assert.AreEqual(bsl1a == bsl1read, true); SingletonLogger.Instance().DebugLog(typeof(blau_tests), "bs1a agrees with bs1read"); }
public void QuantizedBlauPointTest() { Console.WriteLine("QuantizedBlauPointTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 100.0, 100.0 }; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); int STEPS = 10; int[] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); IBlauSpaceLattice bsl2 = BlauSpaceLattice.create(s, STEPSarray); IBlauPoint bp = new QuantizedBlauPoint(s, bsl); IBlauPoint bp2 = new QuantizedBlauPoint(s, bsl2); IBlauPoint bp3 = new QuantizedBlauPoint(s, bsl); bp.setCoordinate(0, 10.0); bp.setCoordinate(1, 20.0); bp.setCoordinate(2, 30.0); bp2.setCoordinate(0, 9.99); bp2.setCoordinate(1, 19.99); bp2.setCoordinate(2, 29.99); bp3.setCoordinate(0, 10.01); bp3.setCoordinate(1, 20.01); bp3.setCoordinate(2, 30.01); Assert.AreEqual(bp.CompareTo(bp2), 0); Assert.AreEqual(bp.CompareTo(bp3), 0); Assert.AreEqual(bp2.CompareTo(bp), 0); Assert.AreEqual(bp.CompareTo(bp), 0); Assert.AreEqual(bp3.CompareTo(bp), 0); Assert.AreEqual(bp3.CompareTo(bp2), 0); }
public IBlauSpaceEvaluation eval(IAgentEvaluationBundle aeb, IBlauSpaceLattice lattice) { IBlauSpaceMultiEvaluation bsme = new BlauSpaceMultiEvaluation(aeb.Name, lattice); IBlauSpaceEvaluation bse = new BlauSpaceEvaluation(aeb.Name + "-Mean", lattice); foreach (IAgentEvaluation ae in aeb.Evaluations) { ae.AddToBlauSpaceMultiEvaluation(bsme); } foreach (IBlauPoint p in bsme.AssignedLatticePoints) { LinkedList <IScore> scores = bsme.eval(p); double count = (double)scores.Count; bse.set(p, (double)count); } return(bse); }
public IBlauSpaceLattice getLattice(IDistribution d, IAgentEvaluationBundle aeb) { IAgentEvaluationFactory aef = null;; foreach (IAgentEvaluation iae in aeb.Evaluations) { aef = iae.Creator; break; } int[] steps = new int[d.SampleSpace.Dimension]; for (int j = 0; j < d.SampleSpace.Dimension; j++) { steps[j] = getAgentEvaluationConfig(aef).BlauSpaceGridding; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(d.SampleSpace, steps); return(bsl); }
public IBlauSpaceEvaluation eval(IAgentEvaluationBundle aeb, IBlauSpaceLattice lattice) { IBlauSpaceMultiEvaluation bsme = new BlauSpaceMultiEvaluation(aeb.Name, lattice); IBlauSpaceEvaluation bse = new BlauSpaceEvaluation(aeb.Name + "-Mean", lattice); foreach (IAgentEvaluation ae in aeb.Evaluations) { ae.AddToBlauSpaceMultiEvaluation(bsme); } foreach (IBlauPoint p in bsme.AssignedLatticePoints) { LinkedList <IScore> scores = bsme.eval(p); double total = 0.0; int count = 0; foreach (IScore s in scores) { total += s.Value; count++; } double mean = total / (double)count; bse.set(p, mean); } return(bse); }
public void BlauSpaceLatticeTest() { Console.WriteLine("BlauSpaceLatticeTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 100.0, 100.0 }; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); int STEPS = 10; int[] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); Assert.AreEqual(bsl.getStepSize(0), 100.0 / (double)STEPS); Assert.AreEqual(bsl.getStepSize(1), 100.0 / (double)STEPS); Assert.AreEqual(bsl.getStepSize(2), 100.0 / (double)STEPS); Assert.AreEqual(bsl.getSteps(0), STEPS); Assert.AreEqual(bsl.getSteps(1), STEPS); Assert.AreEqual(bsl.getSteps(2), STEPS); IBlauPoint bp = new BlauPoint(s); bp.setCoordinate(0, 11.0); bp.setCoordinate(1, 22.0); bp.setCoordinate(2, 33.0); IBlauPoint bpq = bsl.quantize(bp); Assert.AreNotEqual(bp.CompareTo(bpq), 0); IBlauPoint bp2 = new BlauPoint(s); bp2.setCoordinate(0, 10.0); bp2.setCoordinate(1, 20.0); bp2.setCoordinate(2, 30.0); IBlauPoint bpq2 = bsl.quantize(bp2); Assert.AreEqual(bp2.CompareTo(bpq2), 0); Assert.AreEqual(bpq.CompareTo(bp2), 0); Assert.AreEqual(bpq.CompareTo(bpq2), 0); IBlauPoint bp3 = new BlauPoint(s); bp3.setCoordinate(0, 9.0); bp3.setCoordinate(1, 19.0); bp3.setCoordinate(2, 29.0); IBlauPoint bpq3 = bsl.quantize(bp3); Assert.AreEqual(bpq3.CompareTo(bpq), 0); Assert.AreEqual(bpq3.CompareTo(bp2), 0); Assert.AreEqual(bpq3.CompareTo(bpq2), 0); }
public void QuantizedBlauPointSerializationTest() { Console.WriteLine("QuantizedBlauPointSerializationTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 200.0, 300.0 }; IBlauSpace bs = BlauSpace.create(dim, names, mins, maxs); SoapFormatter formatter = new SoapFormatter(); // BinaryFormatter formatter = new BinaryFormatter(); BlauPoint p1 = new BlauPoint(bs); p1.setCoordinate(0, 11.0); p1.setCoordinate(1, 21.0); p1.setCoordinate(2, 31.0); BlauPoint p2 = new BlauPoint(bs); p2.setCoordinate(0, 21.0); p2.setCoordinate(1, 31.0); p2.setCoordinate(2, 41.0); int [] steps = new int[3]; steps[0] = 10; steps[1] = 20; steps[2] = 30; IBlauSpaceLattice bsl = BlauSpaceLattice.create(bs, steps); IBlauPoint qp1 = bsl.quantize(p1); IBlauPoint qp2 = bsl.quantize(p2); FileStream fs = new FileStream("p1.xml", FileMode.Create); formatter.Serialize(fs, p1); fs.Close(); fs = new FileStream("p2.xml", FileMode.Create); formatter.Serialize(fs, p2); fs.Close(); fs = new FileStream("qp1.xml", FileMode.Create); formatter.Serialize(fs, qp1); fs.Close(); fs = new FileStream("qp2.xml", FileMode.Create); formatter.Serialize(fs, qp2); fs.Close(); fs = new FileStream("qp1.xml", FileMode.Open); IBlauPoint p1r = (IBlauPoint)formatter.Deserialize(fs); fs.Close(); fs = new FileStream("qp2.xml", FileMode.Open); IBlauPoint p2r = (IBlauPoint)formatter.Deserialize(fs); fs.Close(); Assert.AreEqual(p1r.Space == p1.Space, true); Assert.AreEqual(p2r.Space == p2.Space, true); Assert.AreEqual(p1r.Space == p2r.Space, true); Assert.AreEqual(p1.Space == p2.Space, true); Assert.AreEqual(qp1 is QuantizedBlauPoint, true); Assert.AreEqual(qp2 is QuantizedBlauPoint, true); Assert.AreEqual(qp2.Space == p2.Space, true); Assert.AreEqual(qp1.Space == p1.Space, true); Assert.AreEqual(qp1.CompareTo(p1r), 0); Assert.AreEqual(qp2.CompareTo(p2r), 0); Assert.AreNotEqual(qp1.CompareTo(p1), 0); Assert.AreNotEqual(qp2.CompareTo(p2), 0); SingletonLogger.Instance().DebugLog(typeof(blau_tests), "Quantized points are as expected"); }
public override void run() { LoggerInitialization.SetThreshold(typeof(SingleDistributionExperiment), LogLevel.Debug); SingletonLogger.Instance().DebugLog(typeof(SingleDistributionExperiment), "run()"); SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "distribution => " + theActualDistribution); IAgentFactory af = CreateAgentFactory(theActualDistribution, theTableConfig.AgentFactoryClassName); SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "agent factory => " + theTableConfig.AgentFactoryClassName); af.Initialize(theTableConfig); SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "creating initial orderbook"); IOrderbook_Observable ob = new Orderbook(); /* No Burnin at this point * * SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "Executing burnin..."); * IPopulation popburn = CreatePopulation(af, theTableConfig.NumAgents, Path.Combine(ApplicationConfig.ROOTDIR, theTableConfig.InitialOrderbook)); * ISimulation simburn = new Simulation(popburn, ob, 0.0, COMMON_BURNIN_TIME_SECONDS, false, "burnin") ; * ISimulationResults resultsburn = simburn.run(); * ob = (IOrderbook_Observable)simburn.Orderbook; * SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "Done with burnin."); */ ISimulationBundle accumulated_simb = null; ISimulationResultsBundle accumulated_resb = null; for (int popi = 0; popi < theTableConfig.Populations; popi++) { SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "creating population... " + theTableConfig.NumAgents); // Populations all contain an OrderBookLoader agent IPopulation pop = CreatePopulation(af, theTableConfig.NumAgents, Path.Combine(ApplicationConfig.ROOTDIR, theTableConfig.InitialOrderbook)); // SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "done."); string popname = POP_FILE_PREFIX + "." + popi + ".Validation"; string poppath = Path.Combine(_popdir, popname); SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "population " + popi + " => " + poppath); savePopulation(poppath, pop); _simb = new SimulationBundle(pop, ob, 0.0, theTableConfig.DurationHours * 3600.0, LOG_FRAMES, "pop-" + popi); if (accumulated_simb == null) { accumulated_simb = _simb; } foreach (TrajectoryFactoryConfig tfc in theTrajConfig.getTrajectories()) { IPassiveTrajectoryFactory tf = CreatePassiveTrajectoryFactory(tfc); tf.Initialize(theTableConfig); _simb.add(tf); } /* * foreach (IAgent ag in pop) { * if (ag is IAgent_NonParticipant) continue; * * _simb.add (new TrajectoryFactory_AgentNamedMetric(ag, Agent1x0.NetWorth_METRICNAME, 1.0, 0.0)); * } */ double MAX_ALPHA = 0.10; double TEMPORAL_GRANULARITY_FOR_ALPHA_SLICES = 1.0; for (double alpha = 0.0; alpha <= MAX_ALPHA; alpha += MAX_ALPHA / (double)theTableConfig.NumCombs) { TrajectoryFactory_AlphaSlice tf = new TrajectoryFactory_AlphaSlice(TEMPORAL_GRANULARITY_FOR_ALPHA_SLICES, 0.0, alpha, true); tf.Initialize(theTableConfig); _simb.add(tf); TrajectoryFactory_AlphaSlice tf2 = new TrajectoryFactory_AlphaSlice(TEMPORAL_GRANULARITY_FOR_ALPHA_SLICES, 0.0, alpha, false); tf2.Initialize(theTableConfig); _simb.add(tf2); } foreach (AgentEvaluationConfig aefc in theAgentEvaluationFactorySetConfig.getAgentEvaluations()) { IAgentEvaluationFactory aef = CreateAgentEvaluationFactory(aefc); _simb.add(aef, aefc); } _resb = _simb.run(theTableConfig.Trials); //popname = POP_FILE_PREFIX+"."+popi+".Validation-Post"; //poppath = Path.Combine(_popdir, popname); //SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "population post "+popi+" => "+poppath); //savePopulation(poppath, pop); if (accumulated_resb == null) { accumulated_resb = _resb; } else { accumulated_resb.add(_resb); } //WriteTrajectories(popi, _simb, _resb); } //WriteTrajectories(-1, accumulated_simb, accumulated_resb); PresentationConfig.Directory = Path.Combine(OutputDirectory, "results"); if (!Directory.Exists(PresentationConfig.Directory)) { Directory.CreateDirectory(PresentationConfig.Directory); } Latex.ClearImages(); SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "Writing BlauSpaceEvaluations."); foreach (IAgentEvaluationBundle aeb in accumulated_resb.getAgentEvaluationBundles()) { IBlauSpaceLattice bsl = accumulated_simb.getLattice(theActualDistribution, aeb); IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(bsl); IBlauSpaceEvaluation stdEval = aeb.StdEvaluation(bsl); BlauSpaceEvaluationGnuplotPresenter pres = new BlauSpaceEvaluationGnuplotPresenter(_bsedir, PresentationConfig.Directory); pres.Present(this, meanEval, stdEval); } SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "Writing TrajectoryBundles."); foreach (ITrajectoryBundle tb in accumulated_resb.getTrajectoryBundles()) { TrajectoryBundleGnuplotPresenter pres = new TrajectoryBundleGnuplotPresenter(_trajdir, PresentationConfig.Directory); pres.Present(this, tb); } SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "Writing Latex."); Latex.Instance().Present(this); CreateReport(this); SingletonLogger.Instance().InfoLog(typeof(SingleDistributionExperiment), "Done."); }
public void Agent0x1Simulation_TrajectoryBundles() { Console.WriteLine("Agent0x1Simulation_TrajectoryBundles"); LoggerInitialization.SetThreshold(typeof(sim_tests), LogLevel.Debug); //LoggerInitialization.SetThreshold(typeof(Agent0x1), LogLevel.Info); //LoggerInitialization.SetThreshold(typeof(AbstractAgent), LogLevel.Info); //LoggerInitialization.SetThreshold(typeof(SimulationBundle), LogLevel.Debug); //LoggerInitialization.SetThreshold(typeof(Scheduler), LogLevel.Debug); //LoggerInitialization.SetThreshold(typeof(Trajectory), LogLevel.Debug); int dim = 0; string [] names = new string [0]; double [] mins = new double [0]; double [] maxs = new double [0]; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); IBlauPoint mean = new BlauPoint(s); IBlauPoint std = new BlauPoint(s); IDistribution d = new Distribution_Gaussian(s, mean, std); IAgentFactory afact = new Agent0x0_Factory(d); int NUMAGENTS = 25; IPopulation pop = PopulationFactory.Instance().create(afact, NUMAGENTS); foreach (IAgent ag in pop) { SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "agent: " + ag); } string PATH = "" + ApplicationConfig.EXECDIR + "orderbooks/orderbook.csv"; AgentOrderbookLoader loader = MakeAgentOrderbookLoader(PATH); pop.addAgent(loader); IOrderbook_Observable ob = new Orderbook(); string PROPERTY = "NetWorth"; // 1 hours ISimulationBundle simb = new SimulationBundle(pop, ob, 0.0, 3600.0); IAgentEvaluationFactory metricEF = new NamedMetricAgentEvaluationFactory(PROPERTY); simb.add(metricEF); ITrajectoryFactory priceTF = new TrajectoryFactory_Price(10.0, 0.8); simb.add(priceTF); ITrajectoryFactory spreadTF = new TrajectoryFactory_Spread(10.0, 0.0); simb.add(spreadTF); int NUMTRIALS = 25; SingletonLogger.Instance().DebugLog(typeof(sim_tests), "Running Simulation"); ISimulationResultsBundle resb = simb.run(NUMTRIALS); SingletonLogger.Instance().DebugLog(typeof(sim_tests), "Stopping Simulation"); SingletonLogger.Instance().DebugLog(typeof(sim_tests), "resb: " + resb.ToString()); int STEPS = 1; int [] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); foreach (IAgentEvaluationBundle aeb in resb.getAgentEvaluationBundles()) { IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(bsl); IBlauSpaceEvaluation stdEval = aeb.StdEvaluation(bsl); SingletonLogger.Instance().DebugLog(typeof(sim_tests), "meanEval: " + meanEval.ToStringLong()); SingletonLogger.Instance().DebugLog(typeof(sim_tests), "stdEval: " + stdEval.ToStringLong()); } foreach (ITrajectoryBundle tb in resb.getTrajectoryBundles()) { SingletonLogger.Instance().DebugLog(typeof(sim_tests), "Computing meanTraj"); ITrajectory meanTraj = tb.MeanTrajectory; SingletonLogger.Instance().DebugLog(typeof(sim_tests), "Computing stdTraj"); ITrajectory stdTraj = tb.StdTrajectory; SingletonLogger.Instance().DebugLog(typeof(sim_tests), "meanTraj: " + meanTraj.ToStringLong()); SingletonLogger.Instance().DebugLog(typeof(sim_tests), "stdTraj: " + stdTraj.ToStringLong()); } Assert.AreEqual(resb.Valid, true); }
public void AgentEvaluationBundleCollapsingTest() { Console.WriteLine("AgentEvaluationBundleCollapsingTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 100.0, 100.0 }; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); int STEPS = 10; int [] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); IBlauPoint mean = new BlauPoint(s); mean.setCoordinate(0, 10.0); mean.setCoordinate(1, 20.0); mean.setCoordinate(2, 30.0); IBlauPoint std = new BlauPoint(s); std.setCoordinate(0, 2.0); std.setCoordinate(1, 4.0); std.setCoordinate(2, 6.0); IDistribution d = new Distribution_Gaussian(s, mean, std); IAgentFactory afact = new AgentDummy_Factory(d); int NUMAGENTS = 100; IAgent[] agents = new IAgent[NUMAGENTS]; for (int i = 0; i < NUMAGENTS; i++) { agents[i] = afact.create(); } string PROPERTY = "NetWorth"; IAgentEvaluationBundle aeb = new AgentEvaluationBundle(PROPERTY); int NUMTRIALS = 1000; double MEANVAL = 1.0; for (int trial = 0; trial < NUMTRIALS; trial++) { SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "*** Trial " + trial); IAgentEvaluation ae = new AgentEvaluation(PROPERTY, null); for (int i = 0; i < NUMAGENTS; i++) { ae.set(agents[i], SingletonRandomGenerator.Instance.NextGaussian(MEANVAL, 0.2)); } aeb.addAgentEvaluation(ae); } IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(bsl); IBlauSpaceEvaluation stdEval = aeb.StdEvaluation(bsl); foreach (IBlauPoint p in meanEval.AssignedLatticePoints) { double meanval = meanEval.eval(p); double stdval = stdEval.eval(p); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "Scores binned to Blaupoint: " + p + " ===> mean:" + meanval + ", std:" + stdval); Assert.Less(Math.Abs(meanval - MEANVAL), 0.1); Assert.Less(stdval, 0.1); } SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "aeb: " + aeb.ToString()); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "meanEval: " + meanEval.ToStringLong()); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "stdEval: " + stdEval.ToStringLong()); }
private void WriteTrajectories(int popi, ISimulationBundle simb, ISimulationResultsBundle resb) { string trajname = TRAJ_FILE_PREFIX + "." + popi + ".Validation"; string trajpath = Path.Combine(_trajdir, trajname); TextWriter trajWriter = File.CreateText(trajpath); foreach (IAgentEvaluationBundle aeb in resb.getAgentEvaluationBundles()) { trajWriter.WriteLine("# AgentEvaluation: " + aeb.Name); trajWriter.Write("# BlauPoint-Coordinates \t "); trajWriter.Write("mean \t std \t count"); trajWriter.WriteLine(""); IBlauSpaceLattice bsl = simb.getLattice(theActualDistribution, aeb); IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(bsl); IBlauSpaceEvaluation stdEval = aeb.StdEvaluation(bsl); IBlauSpaceEvaluation ctEval = aeb.AssignmentCounts(bsl); foreach (IBlauPoint bp in meanEval.AssignedLatticePoints) { for (int c = 0; c < bp.Space.Dimension; c++) { trajWriter.Write("" + bp.Space.getAxis(c).Name + "=" + bp.getCoordinate(c).ToString("#0.000") + "\t"); } trajWriter.Write("" + meanEval.eval(bp).ToString("#0.000") + "\t"); trajWriter.Write("" + stdEval.eval(bp).ToString("#0.000") + "\t"); trajWriter.Write("" + ctEval.eval(bp).ToString("#0.000") + "\t"); trajWriter.WriteLine(""); } } double NUMTICKS = 100.0; foreach (ITrajectoryBundle tb in resb.getTrajectoryBundles()) { trajWriter.WriteLine("# TrajectoryBundle: " + tb.Name); trajWriter.WriteLine("# time \t mean \t std \t center \t dev"); ITrajectory meanTraj = tb.MeanTrajectory; ITrajectory stdTraj = tb.StdTrajectory; ITrajectory centerTraj = tb.CentralTrajectory; ITrajectory devTraj = tb.CentralDevTrajectory; double mint = tb.MinimumTime; double maxt = tb.MaximumTime; double stept = (maxt - mint) / NUMTICKS; for (double t = mint; t < maxt; t += stept) { trajWriter.Write("" + t.ToString("#0.000") + "\t"); trajWriter.Write("" + meanTraj.eval(t).ToString("#0.000") + "\t"); trajWriter.Write("" + stdTraj.eval(t).ToString("#0.000") + "\t"); trajWriter.Write("" + centerTraj.eval(t).ToString("#0.000") + "\t"); trajWriter.Write("" + devTraj.eval(t).ToString("#0.000") + "\t"); trajWriter.WriteLine(""); } } trajWriter.Flush(); trajWriter.Close(); }
public void BlauSpaceMultiEvaluationTest() { Console.WriteLine("BlauSpaceMultiEvaluationTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 100.0, 100.0 }; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); int STEPS = 10; int [] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); IBlauSpaceMultiEvaluation mev = new BlauSpaceMultiEvaluation("net worth", bsl); IBlauPoint bp = new BlauPoint(s); bp.setCoordinate(0, 11.0); bp.setCoordinate(1, 22.0); bp.setCoordinate(2, 33.0); mev.set(bp, 10.0); Assert.AreEqual(mev.eval(bp).Count, 1); mev.set(bp, 20.0); Assert.AreEqual(mev.eval(bp).Count, 2); IBlauPoint bp2 = bp.clone(); mev.set(bp2, 30.0); Assert.AreEqual(mev.eval(bp).Count, 3); Assert.AreEqual(mev.eval(bp2).Count, 3); mev.set(bp2, 40.0); Assert.AreEqual(mev.eval(bp).Count, 4); Assert.AreEqual(mev.eval(bp2).Count, 4); Assert.AreEqual(mev.AssignedLatticePoints.Count, 1); IBlauPoint bp3 = new BlauPoint(s); bp3.setCoordinate(0, 12.0); bp3.setCoordinate(1, 23.0); bp3.setCoordinate(2, 34.0); mev.set(bp3, 50.0); Assert.AreEqual(mev.eval(bp).Count, 5); Assert.AreEqual(mev.eval(bp2).Count, 5); Assert.AreEqual(mev.eval(bp3).Count, 5); Assert.AreEqual(mev.AssignedLatticePoints.Count, 1); IBlauPoint bpX = new BlauPoint(s); bpX.setCoordinate(0, 22.0); bpX.setCoordinate(1, 33.0); bpX.setCoordinate(2, 44.0); mev.set(bpX, 100.0); Assert.AreEqual(mev.eval(bp).Count, 5); Assert.AreEqual(mev.eval(bp2).Count, 5); Assert.AreEqual(mev.eval(bp3).Count, 5); Assert.AreEqual(mev.eval(bpX).Count, 1); Assert.AreEqual(mev.AssignedLatticePoints.Count, 2); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "mev: " + mev.ToStringLong()); }
public void BlauSpaceEvaluationTest() { Console.WriteLine("BlauSpaceEvaluationTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 100.0, 100.0 }; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); int STEPS = 10; int [] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); IBlauSpaceMultiEvaluation mev = new BlauSpaceMultiEvaluation("net worth", bsl); IBlauPoint bp = new BlauPoint(s); bp.setCoordinate(0, 11.0); bp.setCoordinate(1, 22.0); bp.setCoordinate(2, 33.0); mev.set(bp, 10.0); mev.set(bp, 20.0); IBlauPoint bp2 = bp.clone(); mev.set(bp2, 30.0); mev.set(bp2, 40.0); IBlauPoint bp3 = new BlauPoint(s); bp3.setCoordinate(0, 12.0); bp3.setCoordinate(1, 23.0); bp3.setCoordinate(2, 34.0); mev.set(bp3, 50.0); IBlauPoint bpX = new BlauPoint(s); bpX.setCoordinate(0, 22.0); bpX.setCoordinate(1, 33.0); bpX.setCoordinate(2, 44.0); mev.set(bpX, 100.0); IBlauSpaceEvaluation bse = new BlauSpaceEvaluation("net worth", bsl); foreach (IBlauPoint p in mev.AssignedLatticePoints) { LinkedList <IScore> scores = mev.eval(p); double total = 0.0; double count = 0.0; foreach (IScore sc in scores) { total += sc.Value; count += 1.0; } if (p.CompareTo(bp) == 0) { Assert.AreEqual(total, 150.0); Assert.AreEqual(count, 5.0); } if (p.CompareTo(bpX) == 0) { Assert.AreEqual(total, 100.0); Assert.AreEqual(count, 1.0); } double ave = total / count; bse.set(p, ave); Assert.Throws <Exception>(delegate { bse.set(p, ave); }); Assert.Throws <Exception>(delegate { bse.set(p.clone(), ave); }); Assert.AreEqual(bse.eval(p), ave); Assert.AreEqual(bse.eval(p.clone()), ave); } SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "bse: " + bse.ToStringLong()); }
public BlauSpaceEvaluation(string name, IBlauSpaceLattice lattice) { _name = name; _lattice = lattice; _evaluationData = new SortedDictionary <IBlauPoint, double>(new BlauPointComparer()); }
public void NamedMetricAgentEvaluationFactoryTest() { Console.WriteLine("NamedMetricAgentEvaluationFactoryTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 100.0, 100.0 }; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); int STEPS = 10; int [] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); IBlauPoint mean = new BlauPoint(s); mean.setCoordinate(0, 10.0); mean.setCoordinate(1, 20.0); mean.setCoordinate(2, 30.0); IBlauPoint std = new BlauPoint(s); std.setCoordinate(0, 2.0); std.setCoordinate(1, 4.0); std.setCoordinate(2, 6.0); IDistribution d = new Distribution_Gaussian(s, mean, std); IAgentFactory afact = new AgentDummy_Factory(d); int NUMAGENTS = 100; IPopulation pop = PopulationFactory.Instance().create(afact, NUMAGENTS); IOrderbook_Observable ob = new Orderbook(); foreach (IAgent ag in pop) { SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "agent: " + ag); } string PROPERTY = "NetWorth"; IAgentEvaluationBundle aeb = new AgentEvaluationBundle(PROPERTY); int NUMTRIALS = 100; for (int trial = 0; trial < NUMTRIALS; trial++) { SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "*** Trial " + trial); ISimulation sim = new Simulation(pop.clone(), ob.clone(), 0.0, 100.0); NamedMetricAgentEvaluationFactory metricEF = new NamedMetricAgentEvaluationFactory(PROPERTY); sim.add(metricEF); sim.broadcast(new SimulationStart()); sim.broadcast(new SimulationEnd()); IAgentEvaluation ae = metricEF.create(); aeb.addAgentEvaluation(ae); } IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(bsl); IBlauSpaceEvaluation stdEval = aeb.StdEvaluation(bsl); foreach (IBlauPoint p in meanEval.AssignedLatticePoints) { double meanval = meanEval.eval(p); double stdval = stdEval.eval(p); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "Scores binned to Blaupoint: " + p + " ===> mean:" + meanval + ", std:" + stdval); Assert.Less(Math.Abs(meanval - AgentDummy.MEANWORTH), 0.1); Assert.Less(stdval, 0.1); } SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "aeb: " + aeb.ToString()); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "meanEval: " + meanEval.ToStringLong()); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "stdEval: " + stdEval.ToStringLong()); }
public BlauSpaceMultiEvaluation(string name, IBlauSpaceLattice lattice) { _name = name; _lattice = lattice; _evaluationData = new SortedDictionary <IBlauPoint, LinkedList <IScore> >(new BlauPointComparer()); }
public void BlauSpaceMultiEvaluationConstructionTest() { Console.WriteLine("BlauSpaceMultiEvaluationConstructionTest"); int dim = 3; string [] names = new string [3] { "x", "y", "z" }; double [] mins = new double [3] { 0.0, 0.0, 0.0 }; double [] maxs = new double [3] { 100.0, 100.0, 100.0 }; IBlauSpace s = BlauSpace.create(dim, names, mins, maxs); int STEPS = 10; int [] STEPSarray = new int[s.Dimension]; for (int j = 0; j < s.Dimension; j++) { STEPSarray[j] = STEPS; } IBlauSpaceLattice bsl = BlauSpaceLattice.create(s, STEPSarray); IBlauPoint mean = new BlauPoint(s); mean.setCoordinate(0, 10.0); mean.setCoordinate(1, 20.0); mean.setCoordinate(2, 30.0); IBlauPoint std = new BlauPoint(s); std.setCoordinate(0, 2.0); std.setCoordinate(1, 4.0); std.setCoordinate(2, 6.0); IDistribution d = new Distribution_Gaussian(s, mean, std); IAgentFactory afact = new AgentDummy_Factory(d); int NUMAGENTS = 100; IAgent[] agents = new IAgent[NUMAGENTS]; for (int i = 0; i < NUMAGENTS; i++) { agents[i] = afact.create(); } string PROPERTY = "NetWorth"; BlauSpaceMultiEvaluation mev = new BlauSpaceMultiEvaluation(PROPERTY, bsl); int NUMTRIALS = 10; for (int trial = 0; trial < NUMTRIALS; trial++) { SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "*** Trial " + trial); IAgentEvaluation ae = new AgentEvaluation(PROPERTY, null); for (int i = 0; i < NUMAGENTS; i++) { ae.set(agents[i], SingletonRandomGenerator.Instance.NextGaussian(1.0, 0.2)); } ae.AddToBlauSpaceMultiEvaluation(mev); int count = 0; foreach (IBlauPoint p in mev.AssignedLatticePoints) { LinkedList <IScore> scores = mev.eval(p); SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "" + scores.Count + " Readings binned to Blaupoint: " + p); count += scores.Count; } Assert.AreEqual(count, NUMAGENTS * (trial + 1)); } SingletonLogger.Instance().DebugLog(typeof(metrics_tests), "mev: " + mev.ToStringLong()); }