Ejemplo n.º 1
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");
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 5
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");
        }
Ejemplo n.º 6
0
        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);
        }
Ejemplo n.º 7
0
        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());
        }
Ejemplo n.º 8
0
        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());
        }
Ejemplo n.º 9
0
        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());
        }
Ejemplo n.º 10
0
        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());
        }
Ejemplo n.º 11
0
        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());
        }