static void Main(string[] args)
{
options.Parse(args);
//check that the file exists before attempting to parse
if (!Directory.Exists(directory))
{
Console.WriteLine($"Directory \"{directory}\" does not exist");
return;
}
CIlibParser parser;
if (iteration < 0) //parse only final output
{
parser = new FinalOutputParser();
}
else //parse entire file
{
parser = new SingleIterationParser(iteration);
}
List <Algorithm> algorithms = parser.ParseDirectory(directory);
string outputPath = Path.Combine(directory, "summaries");
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
foreach (string measure in algorithms[0].Measurements.Select(x => x.Name))
{
string fileName = Path.Combine(outputPath, $"{measure}.csv");
using (TextWriter writer = new StreamWriter(fileName))
{
//writer.WriteLine("Algorithm,Mean,Stdandard Deviation,Min,Max");
if (verbose)
{
Console.WriteLine(measure);
Console.WriteLine(" Alg | Min | Median | Mean | Std.Dev | Max");
}
foreach (Algorithm alg in algorithms)
{
IterationStats stats = alg.Measurements.Find(m => m.Name == measure).FinalIteration; //get the stats for the associated measure //writer.WriteLine("{0},{1},{2},{3},{4}", alg.Name, stats.Average, stats.StandardDeviation, stats.Min, stats.Max);
writer.WriteLine("{0} & {1:e2} & {2:e2} & {3:e2} & {4:e2} & {5:e2} \\\\ \\hline", alg.Name, checkMin(stats.Min), checkMin(stats.Median), checkMin(stats.Average), checkMin(stats.StandardDeviation), checkMin(stats.Max));
if (verbose)
{
Console.WriteLine("{0,10} | {1:0.000} | {2:0.000} | {3:0.000} | {4:0.000} | {5:0.000}", alg.Name, checkMin(stats.Min), checkMin(stats.Median), checkMin(stats.Average), checkMin(stats.StandardDeviation), checkMin(stats.Max));
}
}
if (verbose)
{
Console.WriteLine();
}
}
}
}
/// <summary>
/// This method is called by MapperOptimalEfficiency_AdditionalStats for each iteration
/// </summary>
/// <param name="images"></param>
/// <param name="maxWidth"></param>
/// <param name="maxHeight"></param>
/// <returns></returns>
protected override S MappingRestrictedBox(
IOrderedEnumerable <IImageInfo> images, int maxWidth, int maxHeight, ICanvasStats canvasStats,
out int lowestFreeHeightDeficitTallestRightFlushedImage)
{
S intermediateSpriteInfo =
base.MappingRestrictedBox(images, maxWidth, maxHeight, canvasStats, out lowestFreeHeightDeficitTallestRightFlushedImage);
IterationStats stats = null;
CanvasWritingStepImages canvasBLFStats = _canvas as CanvasWritingStepImages;
List <ImagePlacementDetails> imageDetails = null;
if (canvasBLFStats != null)
{
imageDetails = new List <ImagePlacementDetails>(canvasBLFStats.ImageDetails);
}
if (intermediateSpriteInfo != null)
{
stats =
new IterationStats
{
Result = IterationResult.Success,
MaxCanvasWidth = maxWidth,
MaxCanvasHeight = maxHeight,
IntermediateSpriteWidth = intermediateSpriteInfo.Width,
IntermediateSpriteHeight = intermediateSpriteInfo.Height,
ImageDetails = imageDetails
};
}
else
{
stats =
new IterationStats
{
Result = IterationResult.Failure,
MaxCanvasWidth = maxWidth,
MaxCanvasHeight = maxHeight,
ImageDetails = imageDetails
};
}
_currentMappingIterationStats.Add(stats);
// Clear out the current image details as kept by the canvas, otherwise we get the same details again next time.
if (canvasBLFStats != null)
{
canvasBLFStats.ImageDetails.Clear();
}
return(intermediateSpriteInfo);
}
/// <summary>
/// Read an individual line from a CIlib output file
/// </summary>
/// <param name="line">The line to be read.</param>
protected virtual void ReadLine(string line)
{
string[] tokens = line.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries);
if (!int.TryParse(tokens[0], out var iter))
{
Console.WriteLine("Iteration is not the first column.");
}
string columnName;
int index = 0; //the index of the column being parsed
//loop through each column
while (index < ColumnArray.Length)
{
columnName = ColumnArray[index];
List <double> values = new List <double>();
//loop through the various columns (i.e., runs) for this measure
while (index < ColumnArray.Length && ColumnArray[index] == columnName)
{
values.Add(double.Parse(tokens[index + 1])); //add 1 to offset iteration as first column
index++;
}
IterationStats stats = new IterationStats(iter, values);
Measurements.AddOrUpdate(columnName,
x => //add function
{
Measurement meas = new Measurement(columnName);
meas.AddIterationStatistics(iter, stats);
return(meas);
},
(name, meas) => //update function
{
meas.AddIterationStatistics(iter, stats);
return(meas);
}
);
}
}
/// <summary>
/// </summary>
/// <param name="images"></param>
/// <param name="maxWidth"></param>
/// <param name="maxHeight"></param>
/// <returns></returns>
protected override bool CandidateCanvasFeasable(
int canvasMaxWidth, int canvasMaxHeight, int bestSpriteArea, int totalAreaAllImages,
out bool candidateBiggerThanBestSprite, out bool candidateSmallerThanCombinedImages)
{
bool isFeasable =
base.CandidateCanvasFeasable(
canvasMaxWidth, canvasMaxHeight, bestSpriteArea, totalAreaAllImages,
out candidateBiggerThanBestSprite, out candidateSmallerThanCombinedImages);
IterationStats stats = null;
if (candidateBiggerThanBestSprite)
{
stats = new IterationStats
{
Result = IterationResult.BiggerThanBestSprite,
MaxCanvasWidth = canvasMaxWidth,
MaxCanvasHeight = canvasMaxHeight
};
}
else if (candidateSmallerThanCombinedImages)
{
stats = new IterationStats
{
Result = IterationResult.SmallerThanCombinedImages,
MaxCanvasWidth = canvasMaxWidth,
MaxCanvasHeight = canvasMaxHeight
};
}
if (stats != null)
{
_currentMappingIterationStats.Add(stats);
}
return(isFeasable);
}
public void Calculate(List <Algorithm> algorithms)
{
char[] nameSplit = { '_' };
using (TextWriter writer = new StreamWriter("test.csv"))
{
foreach (var algorithm in algorithms)
{
var nameTokens = algorithm.Name.Split(nameSplit, StringSplitOptions.RemoveEmptyEntries);
if (!double.TryParse(nameTokens[1], out var inertia))
{
Console.WriteLine("Error parsing inertia from: {0}", nameTokens[1]);
}
if (!double.TryParse(nameTokens[2], out var cognitive))
{
Console.WriteLine("Error parsing cognitive from: {0}", nameTokens[2]);
}
if (!double.TryParse(nameTokens[3], out var social))
{
Console.WriteLine("Error parsing social from: {0}", nameTokens[3]);
}
IterationStats stats = algorithm.Measurements.Find(x => x.Name == "Fitness").FinalIteration;
int count = stats.Values.Count(x => x < accuracy);
double successRate = (double)count / stats.Values.Count;
string successString = "";
if (successRate < double.Epsilon) //s = 0.0
{
successString = "F";
}
else if (successRate < 0.2) //0 < s < 0.2
{
successString = "VP";
}
else if (successRate < 0.4) //0.2 < s < 0.4
{
successString = "P";
}
else if (successRate < 0.6) //0.4 < s < 0.6
{
successString = "A";
}
else if (successRate < 0.8) //0.6 < s < 0.8
{
successString = "G";
}
else if (successRate < 1.0) //s = 1.0
{
successString = "VG";
}
else
{
successString = "S";
}
writer.WriteLine($"{inertia},{cognitive},{social},{successRate},{successString}");
}
}
}
private static void ProcessMovement()
{
if (!Directory.Exists(_directory))
{
Console.WriteLine("Invalid directory, exiting.");
Environment.Exit(1);
}
if (_value < 0)
{
Console.WriteLine("Value must be positive, exiting.");
Environment.Exit(1);
}
string outputDir = Path.Combine(_directory, OutputDirName);
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
string output = Path.Combine(outputDir, _value + ".csv");
char[] nameSplit = { '_' };
using (TextWriter writer = new StreamWriter(output))
{
foreach (string movementfile in Directory.EnumerateFiles(_directory, "*.txt"))
{
//Algorithm alg = CIlibParserOld.Parse(movementfile);
CIlibParser parser = new FullParser();
Algorithm alg = parser.Parse(movementfile);
Measurement measure = alg.Measurements.Find(x => x.Name == MeasureName);
int iterations;
if (_divergence)
{
if (measure.FinalIteration.Average < _value)
{
iterations = measure.MaximumIterations;
}
else
{
IterationStats stats = measure.Stats.Skip(1).First(x => x.Average >= _value);
iterations = stats.Iteration;
}
}
else
{ //check if the final value is less than the threshold, if not set it to max iters immediately
if (measure.FinalIteration.Average > _value)
{
iterations = measure.MaximumIterations;
}
else
{
IterationStats stats = measure.Stats.Skip(1).First(x => x.Average <= _value);
iterations = stats.Iteration;
}
}
var nameTokens = alg.Name.Split(nameSplit, StringSplitOptions.RemoveEmptyEntries);
if (!double.TryParse(nameTokens[1], out var inertia))
{
Console.WriteLine("Error parsing inertia from: {0}", nameTokens[1]);
}
if (!double.TryParse(nameTokens[2], out var cognitive))
{
Console.WriteLine("Error parsing cognitive from: {0}", nameTokens[2]);
}
if (!double.TryParse(nameTokens[3], out var social))
{
Console.WriteLine("Error parsing social from: {0}", nameTokens[3]);
}
writer.WriteLine("{0},{1},{2}", cognitive + social, inertia, iterations);
}
writer.Close();
}
}
