public void DistributionSpaceIterator_GaussianMixtureTest()
{
Console.WriteLine("DistributionSpaceIterator_GaussianMixtureTest");
double mean = 70.0;
double std = 1.0;
IDistribution d1 = create1DGaussian(mean, std);
double mean2 = 20.0;
double std2 = 1.0;
IDistribution d2 = create1DGaussian(mean2, std2);
int dim = 1;
string [] names = new string [1] {
"x"
};
double [] mins = new double [1] {
0.00
};
double [] maxs = new double [1] {
100.0
};
IBlauSpace s = BlauSpace.create(dim, names, mins, maxs);
Mixture d = new Mixture(s);
d.Add(d1, 0.75);
d.Add(d2, 0.25);
d.DistributionComplete();
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "original distribution: " + d);
DistributionSpace ds = new DistributionSpace(d);
int [] steps = new int[ds.ParamSpace.Dimension];
for (int N = 3; N <= 5; N++)
{
for (int i = 0; i < ds.ParamSpace.Dimension; i++)
{
steps[i] = N;
}
IDistributionSpaceIterator it = ds.iterator(steps);
int count = 0;
int validCt = 0;
foreach (IDistribution diter in it)
{
if (diter.IsValid())
{
validCt++;
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "iterator distribution: " + diter);
}
count++;
}
Assert.AreEqual((N + 1) * (N + 1) * (N + 1) * (N + 1) * (N + 1) * (N + 1), count);
SingletonLogger.Instance().InfoLog(typeof(dist_tests), "N=" + N + " valid distributions: " + validCt + " / total: " + count);
}
}
public void DistributionSpaceIterator_SingleIntervalTest()
{
Console.WriteLine("DistributionSpaceIterator_SingleIntervalTest");
int dim = 1;
string [] names = new string [1] {
"x"
};
double [] mins = new double [1] {
0.00
};
double [] maxs = new double [1] {
100.0
};
IBlauSpace s = BlauSpace.create(dim, names, mins, maxs);
double min = 20.0;
double max = 80.0;
IDistribution d = new Distribution_Interval(s, min, max);
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "original distribution: " + d);
DistributionSpace ds = new DistributionSpace(d);
int [] steps = new int[ds.ParamSpace.Dimension];
for (int N = 3; N <= 5; N++)
{
for (int i = 0; i < ds.ParamSpace.Dimension; i++)
{
steps[i] = N;
}
IDistributionSpaceIterator it = ds.iterator(steps);
int count = 0;
int validCt = 0;
foreach (IDistribution d2 in it)
{
if (d2.IsValid())
{
validCt++;
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "iterator distribution: " + d2);
}
count++;
}
Assert.AreEqual((N + 1) * (N + 1), count);
SingletonLogger.Instance().InfoLog(typeof(dist_tests), "N=" + N + " valid distributions: " + validCt + " / total: " + count);
}
}
public void DistributionSpaceIterator_Pointed2D()
{
Console.WriteLine("DistributionSpaceIterator_Pointed2D");
double [] p1 = new double [] { 70.0, 20.0, 4.1 };
IDistribution d = createPointed(p1);
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "DistributionSpaceIterator_Pointed2D distribution: " + d);
DistributionSpace ds = new DistributionSpace(d);
int [] steps = new int[ds.ParamSpace.Dimension];
for (int N = 3; N <= 5; N++)
{
for (int i = 0; i < ds.ParamSpace.Dimension; i++)
{
steps[i] = N;
}
IDistributionSpaceIterator it = ds.iterator(steps);
int count = 0;
int validCt = 0;
foreach (IDistribution d2 in it)
{
if (d2.IsValid())
{
validCt++;
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "iterator distribution: " + d2);
}
count++;
}
SingletonLogger.Instance().InfoLog(typeof(dist_tests), "N=" + N + " distributions: " + count);
Assert.AreEqual(Math.Pow((double)(N + 1), (double)(ds.ParamSpace.Dimension)), count);
SingletonLogger.Instance().InfoLog(typeof(dist_tests), "N=" + N + " valid distributions: " + validCt);
Assert.AreEqual(Math.Pow((double)(N + 1), (double)(ds.ParamSpace.Dimension)), validCt);
}
}
public void DistributionSpaceIterator_Gaussian2D()
{
Console.WriteLine("DistributionSpaceIterator_Gaussian2D");
double mean = 70.0;
double std = 1.0;
double mean2 = 20.0;
double std2 = 1.0;
IDistribution d = create2DGaussian(mean, std, mean2, std2);
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "original distribution: " + d);
DistributionSpace ds = new DistributionSpace(d);
int [] steps = new int[ds.ParamSpace.Dimension];
for (int N = 3; N <= 5; N++)
{
for (int i = 0; i < ds.ParamSpace.Dimension; i++)
{
steps[i] = N;
}
IDistributionSpaceIterator it = ds.iterator(steps);
int count = 0;
int validCt = 0;
foreach (IDistribution d2 in it)
{
if (d2.IsValid())
{
validCt++;
SingletonLogger.Instance().DebugLog(typeof(dist_tests), "iterator distribution: " + d2);
}
count++;
}
Assert.AreEqual((N + 1) * (N + 1) * (N + 1) * (N + 1), count);
SingletonLogger.Instance().InfoLog(typeof(dist_tests), "N=" + N + " valid distributions: " + validCt);
}
}
public static void Main1DMixture(string[] args)
{
Console.WriteLine("console_tests");
LoggerInitialization.SetThreshold(typeof(console_tests.MainClass), LogLevel.Debug);
double mean = 70.0;
double std = 1.0;
IDistribution d1 = create1DGaussian(mean, std);
double mean2 = 20.0;
double std2 = 1.0;
IDistribution d2 = create1DGaussian(mean2, std2);
int dim = 1;
string [] names = new string [1] {
"x"
};
double [] mins = new double [1] {
0.00
};
double [] maxs = new double [1] {
100.0
};
IBlauSpace s = BlauSpace.create(dim, names, mins, maxs);
Mixture d = new Mixture(s);
d.Add(d1, 0.75);
d.Add(d2, 0.25);
d.DistributionComplete();
SingletonLogger.Instance().DebugLog(typeof(console_tests.MainClass), "original distribution: " + d);
Console.WriteLine("original distribution: " + d);
DistributionSpace ds = new DistributionSpace(d);
int [] steps = new int[ds.ParamSpace.Dimension];
// N = subdivisions of each of the parameter values
for (int N = 3; N <= 6; N++)
{
for (int i = 0; i < ds.ParamSpace.Dimension; i++)
{
steps[i] = N;
}
IDistributionSpaceIterator it = ds.iterator(steps);
int count = 0;
int validCt = 0;
foreach (IDistribution diter in it)
{
if (diter.IsValid())
{
validCt++;
SingletonLogger.Instance().DebugLog(typeof(console_tests.MainClass), "iterator distribution: " + diter);
Console.WriteLine("valid distribution: " + diter);
}
else
{
Console.WriteLine("invalid distribution: " + diter);
}
count++;
}
Console.WriteLine("# of valid distributions: " + validCt);
Console.WriteLine("# of total distributions: " + count);
Assert.AreEqual((N + 1) * (N + 1) * (N + 1) * (N + 1) * (N + 1) * (N + 1), count);
SingletonLogger.Instance().InfoLog(typeof(console_tests.MainClass), "N=" + N + " valid distributions: " + validCt + " / total: " + count);
}
}
public override void run()
{
SingletonLogger.Instance().DebugLog(typeof(AllDistributionsMetaExperiment), "AllDistributionsMetaExperiment.run()");
int [] steps = theDistributionSpaceIteratorSpecification.ApplyToDistribution(this.theTemplateDistribution);
DistributionSpace ds = new DistributionSpace(this.theTemplateDistribution);
IDistributionSpaceIterator it = ds.iterator(steps);
using (TextWriter writer = File.CreateText(Path.Combine(_distdir, "STATUS")))
{
writer.WriteLine("Running");
}
TextWriter indexWriter = File.CreateText(Path.Combine(_distdir, "INDEX"));
SoapFormatter formatter = new SoapFormatter();
Console.WriteLine("Generating distributions...");
int count = 0;
int validCt = 0;
foreach (IDistribution d2 in it)
{
bool valid = d2.IsValid();
if (valid)
{
// SingletonLogger.Instance().DebugLog(typeof(Main_DistributionEnumerator), "iterator distribution: "+d2);
string distfilename = "" + DIST_FILE_PREFIX + "." + validCt.ToString("D6");
string distfilepath = Path.Combine(_distdir, distfilename);
FileStream fs2 = new FileStream(distfilepath, FileMode.Create);
formatter.Serialize(fs2, d2);
fs2.Close();
if (validCt == 0)
{
indexWriter.Write("XXXXXX #\tfile\t");
for (int j = 0; j < d2.SampleSpace.Dimension; j++)
{
indexWriter.Write(d2.SampleSpace.getAxis(j).Name + "\t");
}
indexWriter.WriteLine();
}
//indexWriter.WriteLine(""+validCt+"\t"+distfilename+"\t"+d2.ToString());
string distAsString = "";
for (int i = 0; i < d2.Params; i++)
{
string paramAsString = d2.getParamName(i) + "=" + d2.getParam(i);
distAsString += paramAsString + "\t";
}
indexWriter.WriteLine("XXXXXX " + validCt + "\t" + distfilename + "\t" + distAsString);
// Console.WriteLine("Generated distribution: "+d2);
validCt++;
}
else
{
// Console.WriteLine("Invalid distribution: "+d2);
}
count++;
}
indexWriter.Flush();
indexWriter.Close();
using (TextWriter writer = File.CreateText(Path.Combine(_distdir, "STATUS")))
{
writer.WriteLine("Finished");
}
Console.WriteLine("Done! valid distributions: " + validCt + " / total: " + count);
ApplicationConfig.Initialize(_outdir);
// reset
ds = new DistributionSpace(this.theTemplateDistribution);
it = ds.iterator(steps);
int count2 = 0;
int validCt2 = 0;
foreach (IDistribution d2 in it)
{
if (d2.IsValid())
{
string distnum = "" + validCt2.ToString("D6");
string exedir = SingleDistributionExperiment.MakeName(_outdir, distnum, false);
string distfilename = "" + DIST_FILE_PREFIX + "." + validCt2.ToString("D6");
string distfilepath = Path.Combine(_distdir, distfilename);
File.Copy(distfilepath, Path.Combine(_outdir, AbstractExperiment.ACTUAL_DIST_FILE), true);
Console.WriteLine("Preparing simulation: " + validCt2 + " / total: " + validCt);
IExperiment exp;
if (!Directory.Exists(exedir))
{
exp = SingleDistributionExperiment.Create(_outdir, distnum, false);
}
else
{
exp = SingleDistributionExperiment.Load(_outdir, distnum);
}
/*
* Console.WriteLine("exedir: "+exedir);
* Console.WriteLine("root: "+_outdir);
*
* try {
* Main_SingleDistributionExperiment.RunExperiment(exp);
* Console.WriteLine("...OK");
* }
* catch (Exception ex) {
* Console.WriteLine("...ERROR");
* throw ex;
* }
*/
validCt2++;
}
count2++;
}
/*
* string [] fileEntries = Directory.GetFiles(_distdir);
*
* foreach(string filepath in fileEntries)
* {
* string fileName = Path.GetFileName(filepath);
* // SingletonLogger.Instance().InfoLog(typeof(Main_table), "fileName: "+fileName);
* if ( ! fileName.StartsWith (DIST_FILE_PREFIX)) continue;
*
* Console.WriteLine(" ");
* Console.WriteLine("****************************************************");
* Console.WriteLine("Reading distribution: "+filepath);
* Console.WriteLine(" ");
*
* FileStream fs = new FileStream(filepath, FileMode.Open);
* IDistribution d2 = (IDistribution)formatter.Deserialize(fs);
* fs.Close();
*
* theActualDistribution = d2;
*
* Console.WriteLine("Distribution => "+d2);
*
* IAgentFactory af = CreateAgentFactory(d2, theTableConfig.AgentFactoryClassName);
*
* af.Initialize (theTableConfig);
*
* IOrderbook_Observable ob = new Orderbook();
*
* ISimulationBundle accumulated_simb = null;
* ISimulationResultsBundle accumulated_resb = null;
*
* for (int popi=0; popi<theTableConfig.Populations; popi++) {
* IPopulation pop = CreatePopulation(af, theTableConfig.NumAgents, theTableConfig.InitialOrderbook);
*
* string popname = POP_FILE_PREFIX+fileName.Substring(DIST_FILE_PREFIX.Length)+"."+popi;
* string poppath = Path.Combine(_popdir, popname);
*
* SingletonLogger.Instance().InfoLog(typeof(TableGenerationExperiment), "Population: "+popi);
*
* TextWriter popWriter = File.CreateText(poppath);
* foreach (IAgent ag in pop) {
* popWriter.Write(""+ag.ID+"\t");
* for (int c=0;c<ag.Coordinates.Space.Dimension;c++) {
* popWriter.Write(""+ag.Coordinates.getCoordinate(c)+"\t");
* }
* popWriter.WriteLine("");
* }
* popWriter.Flush ();
* popWriter.Close ();
*
*
* for (int triali=0; triali<theTableConfig.Trials; triali++) {
*
* Console.WriteLine("Population: "+popi+", Running Trial "+triali);
*
* SimulationBundle simb = new SimulationBundle(pop, ob, 0.0, theTableConfig.DurationHours*3600.0);
*
* if (accumulated_simb == null) {
* accumulated_simb = simb;
* }
*
* foreach (TrajectoryFactoryConfig tfc in theTrajConfig.getTrajectories()) {
* IPassiveTrajectoryFactory tf = CreatePassiveTrajectoryFactory(tfc);
* tf.Initialize(theTableConfig);
* simb.add(tf);
* }
*
* double MAX_ALPHA = 0.25;
* for (double alpha = 0.0; alpha <= MAX_ALPHA; alpha += MAX_ALPHA/(double)theTableConfig.NumCombs) {
* TrajectoryFactory_AlphaSlice tf = new TrajectoryFactory_AlphaSlice(0.0, 0.0, alpha, true);
* tf.Initialize(theTableConfig);
* simb.add(tf);
* TrajectoryFactory_AlphaSlice tf2 = new TrajectoryFactory_AlphaSlice(0.0, 0.0, alpha, false);
* tf2.Initialize(theTableConfig);
* simb.add(tf2);
* }
*
* foreach (AgentEvaluationConfig aefc in theAgentEvaluationFactorySetConfig.getAgentEvaluations()) {
* IAgentEvaluationFactory aef = CreateAgentEvaluationFactory(aefc);
* simb.add(aef, aefc);
* }
*
* // run ONE trial
* ISimulationResultsBundle resb = simb.run(1);
*
* if (accumulated_resb == null) {
* accumulated_resb = resb;
* }
* else {
* accumulated_resb.add (resb);
* }
*
* foreach (IAgentEvaluationBundle aeb in resb.getAgentEvaluationBundles()) {
*
* string trajname = TRAJ_FILE_PREFIX+fileName.Substring(DIST_FILE_PREFIX.Length)+"."+popi+"."+triali+".evaluation."+aeb.Name;
* string trajpath = Path.Combine(_trajdir, trajname);
* TextWriter trajWriter = File.CreateText(trajpath);
*
* trajWriter.WriteLine("# AgentEvaluation: "+aeb.Name);
* trajWriter.WriteLine("# blaupoint mean std count");
* IAgentEvaluationFactory aef = null;;
* foreach (IAgentEvaluation iae in aeb.Evaluations) {
* aef = iae.Creator;
* break;
* }
*
* steps = new int[theTemplateDistribution.SampleSpace.Dimension];
* for (int j=0;j<theTemplateDistribution.SampleSpace.Dimension;j++) steps[j]=simb.getAgentEvaluationConfig(aef).BlauSpaceGridding;
*
* IBlauSpaceLattice bsl = BlauSpaceLattice.create(theTemplateDistribution.SampleSpace, steps);
* 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.getCoordinate(c)+"\t");
* }
* trajWriter.Write(""+meanEval.eval (bp)+"\t");
* trajWriter.Write(""+stdEval.eval (bp)+"\t");
* trajWriter.Write(""+ctEval.eval (bp)+"\t");
* trajWriter.WriteLine("");
* }
*
* trajWriter.Flush ();
* trajWriter.Close ();
* }
*
* foreach (ITrajectoryBundle tb in resb.getTrajectoryBundles()) {
* string trajname = TRAJ_FILE_PREFIX+fileName.Substring(DIST_FILE_PREFIX.Length)+"."+popi+"."+triali+".trajectory."+tb.Name;
* string trajpath = Path.Combine(_trajdir, trajname);
* TextWriter trajWriter = File.CreateText(trajpath);
*
* trajWriter.WriteLine("# TrajectoryBundle: "+tb.Name);
* trajWriter.WriteLine("# time mean std center dev");
* ITrajectory meanTraj = tb.MeanTrajectory;
* ITrajectory stdTraj = tb.StdTrajectory;
* ITrajectory centerTraj = tb.CentralTrajectory;
* ITrajectory devTraj = tb.CentralDevTrajectory;
*
* foreach (double t in meanTraj.Times) {
* trajWriter.Write(""+meanTraj.eval (t)+"\t");
* trajWriter.Write(""+stdTraj.eval (t)+"\t");
* trajWriter.Write(""+centerTraj.eval (t)+"\t");
* trajWriter.Write(""+devTraj.eval (t)+"\t");
* trajWriter.WriteLine("");
* }
*
* trajWriter.Flush ();
* trajWriter.Close ();
* }
*
* }// trials
* }// populations
*
*
* string resultsname = RESULTS_DIR_PREFIX+fileName.Substring(DIST_FILE_PREFIX.Length);
* PresentationConfig.Directory = Path.Combine(this.OutputDirectory,resultsname);
* if ( ! Directory.Exists(PresentationConfig.Directory)) {
* Directory.CreateDirectory(PresentationConfig.Directory);
* }
*
* Latex.ClearImages();
*
* foreach (IAgentEvaluationBundle aeb in accumulated_resb.getAgentEvaluationBundles()) {
*
* string trajname = TRAJ_FILE_PREFIX+fileName.Substring(DIST_FILE_PREFIX.Length)+".ALL.evaluation."+aeb.Name;
* string trajpath = Path.Combine(_trajdir, trajname);
* TextWriter trajWriter = File.CreateText(trajpath);
*
* Console.WriteLine("Writing AgentEvaluation: "+aeb.Name);
*
* trajWriter.WriteLine("# AgentEvaluation: "+aeb.Name);
* trajWriter.WriteLine("# blaupoint mean std count");
* IAgentEvaluationFactory aef = null;;
* foreach (IAgentEvaluation iae in aeb.Evaluations) {
* aef = iae.Creator;
* break;
* }
*
* steps = new int[theTemplateDistribution.SampleSpace.Dimension];
* for (int j=0;j<theTemplateDistribution.SampleSpace.Dimension;j++) steps[j]=accumulated_simb.getAgentEvaluationConfig(aef).BlauSpaceGridding;
*
* IBlauSpaceLattice bsl = BlauSpaceLattice.create(theTemplateDistribution.SampleSpace, steps);
* IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(bsl);
* IBlauSpaceEvaluation stdEval = aeb.StdEvaluation(bsl);
* IBlauSpaceEvaluation ctEval = aeb.AssignmentCounts(bsl);
*
* BlauSpaceEvaluationGnuplotPresenter pres = BlauSpaceEvaluationGnuplotPresenter.Instance();
* pres.Present(this, meanEval, stdEval);
*
* foreach (IBlauPoint bp in meanEval.AssignedLatticePoints) {
* for (int c=0;c<bp.Space.Dimension;c++) {
* trajWriter.Write(""+bp.getCoordinate(c)+"\t");
* }
* trajWriter.Write(""+meanEval.eval (bp)+"\t");
* trajWriter.Write(""+stdEval.eval (bp)+"\t");
* trajWriter.Write(""+ctEval.eval (bp)+"\t");
* trajWriter.WriteLine("");
* }
*
* trajWriter.Flush ();
* trajWriter.Close ();
* }
*
* foreach (ITrajectoryBundle tb in accumulated_resb.getTrajectoryBundles()) {
* string trajname = TRAJ_FILE_PREFIX+fileName.Substring(DIST_FILE_PREFIX.Length)+".ALL.trajectory."+tb.Name;
* string trajpath = Path.Combine(_trajdir, trajname);
* TextWriter trajWriter = File.CreateText(trajpath);
*
* TrajectoryBundleGnuplotPresenter.Instance().Present(this, tb);
*
* Console.WriteLine("Writing TrajectoryBundle: "+tb.Name);
*
* trajWriter.WriteLine("# TrajectoryBundle: "+tb.Name);
* trajWriter.WriteLine("# time mean std center dev");
* ITrajectory meanTraj = tb.MeanTrajectory;
* ITrajectory stdTraj = tb.StdTrajectory;
* ITrajectory centerTraj = tb.CentralTrajectory;
* ITrajectory devTraj = tb.CentralDevTrajectory;
*
* foreach (double t in meanTraj.Times) {
* trajWriter.Write(""+meanTraj.eval (t)+"\t");
* trajWriter.Write(""+stdTraj.eval (t)+"\t");
* trajWriter.Write(""+centerTraj.eval (t)+"\t");
* trajWriter.Write(""+devTraj.eval (t)+"\t");
* trajWriter.WriteLine("");
* }
*
* trajWriter.Flush ();
* trajWriter.Close ();
* }
*
* Console.WriteLine("Writing Latex.");
* Latex.Instance().Present(this);
* CreateReport(this, resultsname);
*
* }// distributions
*/
} // run
