public async Task Classify()
{
var problemFactory = new ProblemFactory(threeClassDataset);
SvmTraining training = new SvmTraining(problemFactory, threeClassDataset);
var parameters = training.SelectParameters(TrainingHeader.CreateDefault(), CancellationToken.None);
var results = await training.Train(parameters).ConfigureAwait(false);
results.Model.Write(Path.Combine(TestContext.CurrentContext.TestDirectory, "classify.dat"));
var testSet = ArffDataSet.Create <PositivityType>("Test");
testSet.UseTotal = true;
var positive = testSet.AddDocument();
positive.AddRecord("Good");
var negative = testSet.AddDocument();
negative.AddRecord("Bad");
SvmTesting testing = new SvmTesting(results.Model, problemFactory);
testing.Classify(testSet);
Assert.AreEqual(PositivityType.Positive, positive.Class.Value);
Assert.AreEqual(PositivityType.Negative, negative.Class.Value);
}
/// <summary>
/// This is the main program.
/// </summary>
///
static void Main()
{
int problemNumber;
// ProblemFactory problemFactory = new ProblemFactory();
totalTime = new Stopwatch();
problemNumber = GetUserInput();
while (problemNumber > 0)
{
totalTime.Reset();
totalTime.Start();
string result = ProblemFactory.GetSolution(problemNumber).Compute();
totalTime.Stop();
Console.WriteLine("\n-----------------------------------------------------------------------");
Console.WriteLine("Solution to problem " + problemNumber + " = " + result);
Console.WriteLine("Execution time was " + Utilities.FormatMilliseconds(totalTime.ElapsedMilliseconds));
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine();
problemNumber = GetUserInput();
}
Console.WriteLine("Goodbye. Press any key to continue");
Console.ReadKey();
}
public async Task <ActionResult> Query([FromQuery] BlueprintQueryParameters queryParameters)
{
if (queryParameters == null)
{
return(this.Problem(ProblemFactory.BadParameters()));
}
var blueprintQuery = new BlueprintsQuery
{
MaxProductionEfford = queryParameters.MaxProductionEfford,
NameContains = queryParameters.ModelName
};
var result = await CommandHandler.Query(blueprintQuery);
return(result.Match(
success =>
{
var resultHto = Ok(new BlueprintQueryResultHto(success.Result, queryParameters));
return resultHto;
},
notReachable => this.Problem(ProblemFactory.ServiceUnavailable()),
invalidQuery => this.Problem(ProblemFactory.BadParameters()),
error => this.Problem(ProblemFactory.Exception(error.Exception))
));
}
public GUI(SortAlgorithm s)
{
theProblem = ProblemFactory.createActualProblem();
theAlgorithm = s;
InitializeComponent();
initializeGUI();
}
public void Setup()
{
dataSet = ArffDataSet.CreateSimple("Test");
dataSet.Header.RegisterNominalClass("One");
var problemFactory = new ProblemFactory(dataSet);
factory = new ParametersSelectionFactory(Task.Factory, problemFactory);
}
public async Task <ActionResult> GetProductionLines()
{
var getAllResult = await CommandHandler.GetAllProductionLines();
return(getAllResult.Match(
success => Ok(new ProductionHto(success.Result)),
notReachable => this.Problem(ProblemFactory.ServiceUnavailable()),
error => this.Problem(ProblemFactory.Exception(error.Exception))));
}
public void LessThan6NumbersThrowsError()
{
var p = new ConstantNumberProvider();
var factory = new ProblemFactory(p);
Assert.Throws <ArgumentException>(() =>
{
var problem = factory.Create();
});
}
private void toolStripMenuItem7_Click(object sender, EventArgs e)
{
clearOldStuff();
theProblem = ProblemFactory.createTestProblem();
if (problemChangedListener != null)
{
problemChangedListener.onProblemChanged(theProblem.getDataForAlgorithm());
}
initializeGUI();
}
private void gradingProblemMenuClicked(object sender, EventArgs e)
{
clearOldStuff();
theProblem = ProblemFactory.createGradingProblem();
if (problemChangedListener != null)
{
problemChangedListener.onProblemChanged(theProblem.getDataForAlgorithm());
}
initializeGUI();
}
static void Main(string[] args)
{
Console.WriteLine(
ProblemFactory.Create(ProblemId.Day25A)
.SendToClipboard()
.AppendTime()
.Solve());
Console.ReadKey();
}
static void Main(string[] args)
{
ProblemFactory problemFactory = new ProblemFactory();
BinaryLevelConfiguration binaryLevelConfig = new BinaryLevelConfiguration();
// register your factory functions
problemFactory.RegisterProblem <BinaryProblem>((level) => new BinaryProblem(binaryLevelConfig.GetProblemConfiguration(level)));
// consume them
IProblem problem1 = problemFactory.GenerateProblem <BinaryProblem>(Level.Easy);
IProblem problem2 = problemFactory.GenerateProblem <BinaryProblem>(Level.Hard);
}
private Problem LoadData(bool withScaling = false)
{
var file = Path.Combine(TestContext.CurrentContext.TestDirectory, @".\Data\data.arff");
var arff = ArffDataSet.Load <PositivityType>(file);
IProblemFactory factory = new ProblemFactory(arff);
if (withScaling)
{
factory = factory.WithRangeScaling();
}
return(factory.Construct(arff).GetProblem());
}
public void Execute()
{
ProblemFactory.Execute <Day01A>();
ProblemFactory.Execute <Day01B>();
ProblemFactory.Execute <Day02A>();
ProblemFactory.Execute <Day02B>();
ProblemFactory.Execute <Day03A>();
ProblemFactory.Execute <Day03B>();
ProblemFactory.Execute <Day04A>();
ProblemFactory.Execute <Day04B>();
}
private void displayNextProblem()
{
//get the next problem
_CurrentProblem = ProblemFactory.GetArithmeticProblem <int>(getNextOperation(), 2, 20, false);
string[] lines = _CurrentProblem.Display().ToArray();
if (lines.Length > 0)
{
lines[0] = lines.First().Remove(0, 1); //remove the first symbol
}
ProblemBox.Lines = lines;
AnswerBox.Text = string.Empty;
AnswerBox.Focus();
_Timer.Restart();
}
public async Task TestTwoClass()
{
var problemFactory = new ProblemFactory(twoClassDataset);
SvmTraining training = new SvmTraining(problemFactory, twoClassDataset);
var parameters = training.SelectParameters(TrainingHeader.CreateDefault(), CancellationToken.None);
var results = await training.Train(parameters).ConfigureAwait(false);
var file = Path.Combine(TestContext.CurrentContext.TestDirectory, "data.arff");
threeClassDataset.Save(file);
var testFile = ArffDataSet.LoadSimple(file);
SvmTesting testing = new SvmTesting(results.Model, problemFactory);
var result = testing.Test(testFile, Path.Combine(TestContext.CurrentContext.TestDirectory, "."));
Assert.AreEqual(1, result);
}
public ActionResult NewQuery(BlueprintQueryParameters queryParameters)
{
if (queryParameters == null)
{
return(this.Problem(ProblemFactory.BadParameters()));
}
var canQueryResult = CommandHandler.CanQueryBlueprints();
return(canQueryResult.Match(
// Will create a Location header with a URI to the result.
available => this.CreatedQuery(typeof(BlueprintQueryResultHto), queryParameters),
notAvailable => this.Problem(ProblemFactory.OperationNotAvailable()),
notReachable => this.Problem(ProblemFactory.ServiceUnavailable()),
error => this.Problem(ProblemFactory.Exception(error.Exception))
));
}
public void Classify(string arff, string modelName, object result)
{
var file = Path.Combine(TestContext.CurrentContext.TestDirectory, "data", arff);
var dataSet = result.GetType() == typeof(PositivityType)
? ArffDataSet.Load <PositivityType>(file)
: ArffDataSet.LoadSimple(file);
file = Path.Combine(TestContext.CurrentContext.TestDirectory, "data", modelName);
var model = Model.Read(file);
IProblemFactory factory = new ProblemFactory(dataSet);
var client = new SvmTesting(model, factory);
var dataHolder = dataSet.CreateDataSet("Test");
var review = dataHolder.AddDocument();
review.AddRecord("Good").Value = 2;
review.AddRecord("Bad").Value = 1;
client.Classify(dataHolder);
Assert.AreEqual(result, review.Class.Value);
}
public void Setup()
{
training = new Mock <ITrainingModel>();
var scheduler = new ConcurrentExclusiveSchedulerPair(TaskScheduler.Default, 2)
.ConcurrentScheduler;
taskFactory = new TaskFactory(scheduler);
parameters = new GridSearchParameters(5, new double[] { 1, 2, 3, 4 }, new double[] { 1, 2, 3, 4 }, new Parameter());
instance = new GridParameterSelection(taskFactory, training.Object, parameters);
var dataSet = ArffDataSet.CreateSimple("Test");
dataSet.Header.RegisterNominalClass("One", "Two", "Three");
dataSet.UseTotal = true;
var one = dataSet.AddDocument();
one.Class.Value = "One";
one.AddRecord("Good");
IProblemFactory factory = new ProblemFactory(dataSet);
problem = factory.Construct(dataSet).GetProblem();
resetEvent = new ManualResetEvent(false);
}
static void Main(string[] args)
{
var aProblem = ProblemFactory.Get(ProblemEnmu.Rotate, SizeEnum.Small);
var fileManger = new FileManager(aProblem.FileName);
var input = fileManger.ReadFile();
var initializer = new ObjectInitializer(aProblem);
dynamic inputProblems = typeof(ObjectInitializer)
.GetMethod("InitializeObject")
.MakeGenericMethod(aProblem.GetType())
.Invoke(initializer, new object[] { aProblem, input });
var printSolutions = new List <string>();
for (var index = 0; index < inputProblems.Cases; index++)
{
printSolutions.Add(string.Format("Case #{0}: {1}", (index + 1).ToString(), inputProblems.Problems[index].PrintSolution()));
}
fileManger.WriteFile(printSolutions);
}
static IEnumerable <Route> ServeRequest(Request request)
{
if (!CheckRequest(request))
{
return(null);
}
(IGraphDatabase cars, IGraphDatabase trains) = MockData.InitDatabases();
List <IGraphDatabase> databases = new List <IGraphDatabase>();
databases.Add(cars);
databases.Add(trains);
IGraphDatabase database = new VehicleDatabase(databases, request.Filter.AllowedVehicles);
database = new PopulationDatabase(database, request.Filter.MinPopulation);
database = new HasRestaurantDatabase(database, request.Filter.RestaurantRequired);
List <ISolver> solvers = new List <ISolver>();
solvers.Add(new BFS());
solvers.Add(new DFS());
solvers.Add(new DijkstraCost());
solvers.Add(new DijkstraTime());
IRouteProblem problem = ProblemFactory.MakeProblem(request.Problem, request.From, request.To);
problem.Graph = database;
foreach (ISolver solver in solvers)
{
if (solver.Name == request.Solver && problem.TrySolveBySolver(solver, out IEnumerable <Route> routes))
{
return(routes);
}
}
Console.WriteLine("Cannot find algorithm to solve this problem");
return(null);
}
public async Task TestMultiClass()
{
var dataSet = ArffDataSet.CreateSimple("Test");
dataSet.Header.RegisterNominalClass("One", "Two", "Three");
dataSet.UseTotal = true;
for (int i = 0; i < 20; i++)
{
var one = dataSet.AddDocument();
one.Class.Value = "One";
one.AddRecord("Good");
var two = dataSet.AddDocument();
two.Class.Value = "Two";
two.AddRecord("Bad");
var three = dataSet.AddDocument();
three.Class.Value = "Three";
three.AddRecord("Some");
}
var problemFactory = new ProblemFactory(dataSet);
SvmTraining training = new SvmTraining(problemFactory, dataSet);
var parameters = training.SelectParameters(TrainingHeader.CreateDefault(), CancellationToken.None);
var results = await training.Train(parameters).ConfigureAwait(false);
var file = Path.Combine(TestContext.CurrentContext.TestDirectory, "data.arff");
dataSet.Save(file);
results.Model.Write(Path.Combine(TestContext.CurrentContext.TestDirectory, "label.dat"));
var testFile = ArffDataSet.LoadSimple(file);
SvmTesting testing = new SvmTesting(results.Model, problemFactory);
var result = testing.Test(testFile, Path.Combine(TestContext.CurrentContext.TestDirectory, "."));
Assert.AreEqual(1, result);
}
/// <summary>
///Usage: three choices
/// - AbYSS
/// - AbYSS problemName
/// - AbYSS problemName paretoFrontFile
/// </summary>
/// <param name="args">Command line arguments.</param>
public static void Main(string[] args)
{
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator crossover; // Crossover operator
Operator mutation; // Mutation operator
Operator improvement; // Operator for improvement
Dictionary <string, object> parameters; // Operator parameters
QualityIndicator indicators; // Object to get quality indicators
// Logger object and file to store log messages
var logger = Logger.Log;
var appenders = logger.Logger.Repository.GetAppenders();
var fileAppender = appenders[0] as log4net.Appender.FileAppender;
fileAppender.File = "AbYSS.log";
fileAppender.ActivateOptions();
indicators = null;
if (args.Length == 1)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
}
else if (args.Length == 2)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
indicators = new QualityIndicator(problem, args[1]);
}
else
{ // Default problem
problem = new Kursawe("Real", 3);
//problem = new Kursawe("BinaryReal", 3);
//problem = new Water("Real");
//problem = new ZDT4("ArrayReal", 10);
//problem = new ConstrEx("Real");
//problem = new DTLZ1("Real");
//problem = new OKA2("Real") ;
}
// STEP 2. Select the algorithm (AbYSS)
algorithm = new JMetalCSharp.Metaheuristics.AbYSS.AbYSS(problem);
// STEP 3. Set the input parameters required by the metaheuristic
algorithm.SetInputParameter("populationSize", 20);
algorithm.SetInputParameter("refSet1Size", 10);
algorithm.SetInputParameter("refSet2Size", 10);
algorithm.SetInputParameter("archiveSize", 100);
algorithm.SetInputParameter("maxEvaluations", 25000);
// STEP 4. Specify and configure the crossover operator, used in the
// solution combination method of the scatter search
parameters = new Dictionary <string, object>();
parameters.Add("probability", 0.9);
parameters.Add("distributionIndex", 20.0);
crossover = CrossoverFactory.GetCrossoverOperator("SBXCrossover", parameters);
// STEP 5. Specify and configure the improvement method. We use by default
// a polynomial mutation in this method.
parameters = new Dictionary <string, object>();
parameters.Add("probability", 1.0 / problem.NumberOfVariables);
parameters.Add("distributionIndex", 20.0);
mutation = MutationFactory.GetMutationOperator("PolynomialMutation", parameters);
parameters = new Dictionary <string, object>();
parameters.Add("improvementRounds", 1);
parameters.Add("problem", problem);
parameters.Add("mutation", mutation);
improvement = new MutationLocalSearch(parameters);
// STEP 6. Add the operators to the algorithm
algorithm.AddOperator("crossover", crossover);
algorithm.AddOperator("improvement", improvement);
long initTime = Environment.TickCount;
// STEP 7. Run the algorithm
SolutionSet population = algorithm.Execute();
long estimatedTime = Environment.TickCount - initTime;
// STEP 8. Print the results
logger.Info("Total execution time: " + estimatedTime + "ms");
logger.Info("Variables values have been writen to file VAR");
population.PrintVariablesToFile("VAR");
logger.Info("Objectives values have been writen to file FUN");
population.PrintObjectivesToFile("FUN");
Console.WriteLine("Total execution time: " + estimatedTime + "ms");
Console.ReadLine();
if (indicators != null)
{
logger.Info("Quality indicators");
logger.Info("Hypervolume: " + indicators.GetHypervolume(population));
logger.Info("GD : " + indicators.GetGD(population));
logger.Info("IGD : " + indicators.GetIGD(population));
logger.Info("Spread : " + indicators.GetSpread(population));
logger.Info("Epsilon : " + indicators.GetEpsilon(population));
}
}
/// <summary>
/// Usage: three options
/// - SPEA2
/// - SPEA2 problemName
/// - SPEA2 problemName ParetoFrontFile
/// </summary>
/// <param name="args">Command line arguments. The first (optional) argument specifies the problem to solve.</param>
public static void Main(string[] args)
{
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator crossover; // Crossover operator
Operator mutation; // Mutation operator
Operator selection; // Selection operator
QualityIndicator indicators; // Object to get quality indicators
Dictionary <string, object> parameters; // Operator parameters
// Logger object and file to store log messages
var logger = Logger.Log;
var appenders = logger.Logger.Repository.GetAppenders();
var fileAppender = appenders[0] as log4net.Appender.FileAppender;
fileAppender.File = "SPEA2.log";
fileAppender.ActivateOptions();
indicators = null;
if (args.Length == 1)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
}
else if (args.Length == 2)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
indicators = new QualityIndicator(problem, args[1]);
}
else
{ // Default problem
problem = new Kursawe("Real", 3);
//problem = new Water("Real");
//problem = new ZDT1("ArrayReal", 1000);
//problem = new ZDT4("BinaryReal");
//problem = new WFG1("Real");
//problem = new DTLZ1("Real");
//problem = new OKA2("Real") ;
}
algorithm = new JMetalCSharp.Metaheuristics.SPEA2.SPEA2(problem);
// Algorithm parameters
algorithm.SetInputParameter("populationSize", 100);
algorithm.SetInputParameter("archiveSize", 100);
algorithm.SetInputParameter("maxEvaluations", 25000);
// Mutation and Crossover for Real codification
parameters = new Dictionary <string, object>();
parameters.Add("probability", 0.9);
parameters.Add("distributionIndex", 20.0);
crossover = CrossoverFactory.GetCrossoverOperator("SBXCrossover", parameters);
parameters = new Dictionary <string, object>();
parameters.Add("probability", 1.0 / problem.NumberOfVariables);
parameters.Add("distributionIndex", 20.0);
mutation = MutationFactory.GetMutationOperator("PolynomialMutation", parameters);
// Selection operator
parameters = null;
selection = SelectionFactory.GetSelectionOperator("BinaryTournament", parameters);
// Add the operators to the algorithm
algorithm.AddOperator("crossover", crossover);
algorithm.AddOperator("mutation", mutation);
algorithm.AddOperator("selection", selection);
// Execute the algorithm
long initTime = Environment.TickCount;
SolutionSet population = algorithm.Execute();
long estimatedTime = Environment.TickCount - initTime;
// Result messages
logger.Info("Total execution time: " + estimatedTime + "ms");
logger.Info("Objectives values have been writen to file FUN");
population.PrintObjectivesToFile("FUN");
logger.Info("Variables values have been writen to file VAR");
population.PrintVariablesToFile("VAR");
if (indicators != null)
{
logger.Info("Quality indicators");
logger.Info("Hypervolume: " + indicators.GetHypervolume(population));
logger.Info("GD : " + indicators.GetGD(population));
logger.Info("IGD : " + indicators.GetIGD(population));
logger.Info("Spread : " + indicators.GetSpread(population));
logger.Info("Epsilon : " + indicators.GetEpsilon(population));
}
Console.WriteLine("Total execution time: " + estimatedTime + "ms");
Console.ReadLine();
}
public void Execute()
{
ProblemFactory.Execute <Day01A>();
ProblemFactory.Execute <Day01B>();
ProblemFactory.Execute <Day02A>();
ProblemFactory.Execute <Day02B>();
ProblemFactory.Execute <Day03A>();
ProblemFactory.Execute <Day03B>();
ProblemFactory.Execute <Day04A>();
ProblemFactory.Execute <Day04B>();
ProblemFactory.Execute <Day05A>();
ProblemFactory.Execute <Day05B>();
ProblemFactory.Execute <Day06A>();
ProblemFactory.Execute <Day06B>();
ProblemFactory.Execute <Day07A>();
ProblemFactory.Execute <Day07B>();
ProblemFactory.Execute <Day08A>();
ProblemFactory.Execute <Day08B>();
ProblemFactory.Execute <Day09A>();
ProblemFactory.Execute <Day09B>();
//
// ProblemFactory.Execute<Day10A>();
// ProblemFactory.Execute<Day10B>();
//
// ProblemFactory.Execute<Day11A>();
// ProblemFactory.Execute<Day11B>();
//
// ProblemFactory.Execute<Day12A>();
// ProblemFactory.Execute<Day12B>();
//
// ProblemFactory.Execute<Day13A>();
// ProblemFactory.Execute<Day13B>();
//
// ProblemFactory.Execute<Day14A>();
// ProblemFactory.Execute<Day14B>();
//
// ProblemFactory.Execute<Day15A>();
// ProblemFactory.Execute<Day15B>();
//
// ProblemFactory.Execute<Day16A>();
// ProblemFactory.Execute<Day16B>();
//
// ProblemFactory.Execute<Day17A>();
// ProblemFactory.Execute<Day17B>();
//
// ProblemFactory.Execute<Day18A>();
// ProblemFactory.Execute<Day18B>();
//
// ProblemFactory.Execute<Day19A>();
// ProblemFactory.Execute<Day19B>();
//
// ProblemFactory.Execute<Day20A>();
// ProblemFactory.Execute<Day20B>();
//
// ProblemFactory.Execute<Day21A>();
// ProblemFactory.Execute<Day21B>();
//
// ProblemFactory.Execute<Day22A>();
// ProblemFactory.Execute<Day22B>();
//
// ProblemFactory.Execute<Day23A>();
// ProblemFactory.Execute<Day23B>();
//
// ProblemFactory.Execute<Day24A>();
// ProblemFactory.Execute<Day24B>();
//
// ProblemFactory.Execute<Day25A>();
}
/// <summary>
///Usage: three choices
/// - GDE3
/// - GDE3 problemName
/// - GDE3 problemName paretoFrontFile
/// </summary>
/// <param name="args">Command line arguments.</param>
public static void Main(string[] args)
{
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator selection;
Operator crossover;
Dictionary <string, object> parameters; // Operator parameters
QualityIndicator indicators; // Object to get quality indicators
// Logger object and file to store log messages
var logger = Logger.Log;
var appenders = logger.Logger.Repository.GetAppenders();
var fileAppender = appenders[0] as log4net.Appender.FileAppender;
fileAppender.File = "GDE3.log";
fileAppender.ActivateOptions();
indicators = null;
if (args.Length == 1)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
}
else if (args.Length == 2)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
indicators = new QualityIndicator(problem, args[1]);
}
else
{ // Default problem
problem = new Kursawe("Real", 3);
//problem = new Water("Real");
//problem = new ZDT1("ArrayReal", 100);
//problem = new ConstrEx("Real");
//problem = new DTLZ1("Real");
//problem = new OKA2("Real") ;
}
algorithm = new JMetalCSharp.Metaheuristics.GDE3.GDE3(problem);
// Algorithm parameters
algorithm.SetInputParameter("populationSize", 100);
algorithm.SetInputParameter("maxIterations", 250);
// Crossover operator
parameters = new Dictionary <string, object>();
parameters.Add("CR", 0.5);
parameters.Add("F", 0.5);
crossover = CrossoverFactory.GetCrossoverOperator("DifferentialEvolutionCrossover", parameters);
// Add the operators to the algorithm
parameters = null;
selection = SelectionFactory.GetSelectionOperator("DifferentialEvolutionSelection", parameters);
algorithm.AddOperator("crossover", crossover);
algorithm.AddOperator("selection", selection);
// Execute the Algorithm
long initTime = Environment.TickCount;
SolutionSet population = algorithm.Execute();
long estimatedTime = Environment.TickCount - initTime;
// Result messages
logger.Info("Total execution time: " + estimatedTime + "ms");
logger.Info("Objectives values have been writen to file FUN");
population.PrintObjectivesToFile("FUN");
logger.Info("Variables values have been writen to file VAR");
population.PrintVariablesToFile("VAR");
if (indicators != null)
{
logger.Info("Quality indicators");
logger.Info("Hypervolume: " + indicators.GetHypervolume(population));
logger.Info("GD : " + indicators.GetGD(population));
logger.Info("IGD : " + indicators.GetIGD(population));
logger.Info("Spread : " + indicators.GetSpread(population));
logger.Info("Epsilon : " + indicators.GetEpsilon(population));
}
Console.WriteLine("Total execution time gde: moead" + estimatedTime + "ms");
Console.ReadLine();
}
/// <summary>
/// Usage: three options
/// - NSGAIIAdaptive
/// - NSGAIIAdaptive problemName
/// - NSGAIIAdaptive problemName paretoFrontFile
/// </summary>
/// <param name="args">Command line arguments.</param>
public static void Main(string[] args)
{
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator selection; // Selection operator
Dictionary <string, object> parameters; // Operator parameters
QualityIndicator indicators; // Object to get quality indicators
// Logger object and file to store log messages
var logger = Logger.Log;
var appenders = logger.Logger.Repository.GetAppenders();
var fileAppender = appenders[0] as log4net.Appender.FileAppender;
fileAppender.File = "NSGAIIAdaptive.log";
fileAppender.ActivateOptions();
indicators = null;
if (args.Length == 1)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
}
else if (args.Length == 2)
{
object[] param = { "Real" };
problem = ProblemFactory.GetProblem(args[0], param);
indicators = new QualityIndicator(problem, args[1]);
}
else
{ // Default problem
problem = new Kursawe("Real", 3);
//problem = new Kursawe("BinaryReal", 3);
//problem = new Water("Real");
//problem = new ZDT1("ArrayReal", 100);
//problem = new ConstrEx("Real");
//problem = new DTLZ1("Real");
//problem = new OKA2("Real") ;
}
problem = new LZ09_F3("Real");
algorithm = new JMetalCSharp.Metaheuristics.NSGAII.NSGAIIAdaptive(problem);
//algorithm = new ssNSGAIIAdaptive(problem);
// Algorithm parameters
algorithm.SetInputParameter("populationSize", 100);
algorithm.SetInputParameter("maxEvaluations", 150000);
// Selection Operator
parameters = null;
selection = SelectionFactory.GetSelectionOperator("BinaryTournament2", parameters);
// Add the operators to the algorithm
algorithm.AddOperator("selection", selection);
// Add the indicator object to the algorithm
algorithm.SetInputParameter("indicators", indicators);
Offspring[] getOffspring = new Offspring[3];
double CR, F;
CR = 1.0;
F = 0.5;
getOffspring[0] = new DifferentialEvolutionOffspring(CR, F);
getOffspring[1] = new SBXCrossoverOffspring(1.0, 20);
//getOffspring[1] = new BLXAlphaCrossoverOffspring(1.0, 0.5);
getOffspring[2] = new PolynomialMutationOffspring(1.0 / problem.NumberOfVariables, 20);
//getOffspring[2] = new NonUniformMutationOffspring(1.0/problem.getNumberOfVariables(), 0.5, 150000);
algorithm.SetInputParameter("offspringsCreators", getOffspring);
// Execute the Algorithm
long initTime = Environment.TickCount;
SolutionSet population = algorithm.Execute();
long estimatedTime = Environment.TickCount - initTime;
// Result messages
logger.Info("Total execution time: " + estimatedTime + "ms");
logger.Info("Variables values have been writen to file VAR");
population.PrintVariablesToFile("VAR");
logger.Info("Objectives values have been writen to file FUN");
population.PrintObjectivesToFile("FUN");
Console.WriteLine("Time: " + estimatedTime);
Console.ReadLine();
if (indicators != null)
{
logger.Info("Quality indicators");
logger.Info("Hypervolume: " + indicators.GetHypervolume(population));
logger.Info("GD : " + indicators.GetGD(population));
logger.Info("IGD : " + indicators.GetIGD(population));
logger.Info("Spread : " + indicators.GetSpread(population));
logger.Info("Epsilon : " + indicators.GetEpsilon(population));
}
}
static void Main()
{
/** /
* ProblemFactory.Create<Day1A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 1A");
*
* ProblemFactory.Create<Day1B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 1B");
*
* ProblemFactory.Create<Day2A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 2A");
*
* ProblemFactory.Create<Day2B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 2B");
*
* ProblemFactory.Create<Day3A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 3A");
*
* ProblemFactory.Create<Day3B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 3B");
*
* ProblemFactory.Create<Day4A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 4A");
*
* ProblemFactory.Create<Day4B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 4B");
*
* ProblemFactory.Create<Day5A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 5A");
*
* ProblemFactory.Create<Day5B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 5B");
*
* ProblemFactory.Create<Day6A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 6A");
*
* ProblemFactory.Create<Day6B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 6B");
*
*
* ProblemFactory.Create<Day7A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 7A");
*
* ProblemFactory.Create<Day7B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 7B");
*
* ProblemFactory.Create<Day8A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 8A");
*
* ProblemFactory.Create<Day8B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 8B");
*
*
* ProblemFactory.Create<Day9A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 9A");
*
* ProblemFactory.Create<Day9B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 9B");
*
* ProblemFactory.Create<Day10A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 10A");
*
* ProblemFactory.Create<Day10B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 10B");
*
* ProblemFactory.Create<Day11A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 11A");
*
* ProblemFactory.Create<Day11B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 11B");
* // */
//ProblemFactory.Create<Day12A>()
// .SendToClipboard()
// .AppendTime()
// .Solve()
// .ToConsole("Day 12A");
//ProblemFactory.Create<Day12B>()
// .SendToClipboard()
// .AppendTime()
// .Solve()
// .ToConsole("Day 12B");
ProblemFactory.Create <Day13A>()
.SendToClipboard()
.AppendTime()
.Solve()
.ToConsole("Day 13A");
ProblemFactory.Create <Day13B>()
.SendToClipboard()
.AppendTime()
.Solve()
.ToConsole("Day 13B");
/** /
*
*
*
* ProblemFactory.Create<Day14A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 14A");
*
* ProblemFactory.Create<Day14B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 14B");
*
* ProblemFactory.Create<Day16A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 16A");
*
* ProblemFactory.Create<Day16B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 16B");
*
* ProblemFactory.Create<Day17A>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 17A");
*
* ProblemFactory.Create<Day17B>()
* .SendToClipboard()
* .AppendTime()
* .Solve()
* .ToConsole("Day 17B");
* // */
Console.ReadKey();
}
/// <summary>
/// Usage: three options
/// - PMOEAD
/// - PMOEAD problemName
/// - PMOEAD problemName ParetoFrontFile
/// - PMOEAD problemName numberOfThreads dataDirectory
/// </summary>
/// <param name="args">Command line arguments. The first (optional) argument specifies the problem to solve.</param>
public static void Main(string[] args)
{
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator crossover; // Crossover operator
Operator mutation; // Mutation operator
QualityIndicator indicators; // Object to get quality indicators
Dictionary <string, object> parameters; // Operator parameters
int numberOfThreads = 4;
string dataDirectory = "";
// Logger object and file to store log messages
var logger = Logger.Log;
var appenders = logger.Logger.Repository.GetAppenders();
var fileAppender = appenders[0] as log4net.Appender.FileAppender;
fileAppender.File = "PMOEAD.log";
fileAppender.ActivateOptions();
indicators = null;
if (args.Length == 1)
{ // args[0] = problem name
object[] paramsList = { "Real" };
problem = ProblemFactory.GetProblem(args[0], paramsList);
}
else if (args.Length == 2)
{ // args[0] = problem name, [1] = pareto front file
object[] paramsList = { "Real" };
problem = ProblemFactory.GetProblem(args[0], paramsList);
indicators = new QualityIndicator(problem, args[1]);
}
else if (args.Length == 3)
{ // args[0] = problem name, [1] = threads, [2] = data directory
object[] paramsList = { "Real" };
problem = ProblemFactory.GetProblem(args[0], paramsList);
numberOfThreads = int.Parse(args[1]);
dataDirectory = args[2];
}
else
{ // Problem + number of threads + data directory
problem = new Kursawe("Real", 3);
//problem = new Kursawe("BinaryReal", 3);
//problem = new Water("Real");
//problem = new ZDT1("ArrayReal", 100);
//problem = new ConstrEx("Real");
//problem = new DTLZ1("Real");
//problem = new OKA2("Real") ;
}
algorithm = new JMetalCSharp.Metaheuristics.MOEAD.PMOEAD(problem);
// Algorithm parameters
algorithm.SetInputParameter("populationSize", 300);
algorithm.SetInputParameter("maxEvaluations", 150000);
algorithm.SetInputParameter("numberOfThreads", numberOfThreads);
// Directory with the files containing the weight vectors used in
// Q. Zhang, W. Liu, and H Li, The Performance of a New Version of MOEA/D
// on CEC09 Unconstrained MOP Test Instances Working Report CES-491, School
// of CS & EE, University of Essex, 02/2009.
// http://dces.essex.ac.uk/staff/qzhang/MOEAcompetition/CEC09final/code/ZhangMOEADcode/moead0305.rar
algorithm.SetInputParameter("dataDirectory", "Data/Parameters/Weight");
algorithm.SetInputParameter("T", 20);
algorithm.SetInputParameter("delta", 0.9);
algorithm.SetInputParameter("nr", 2);
// Crossover operator
parameters = new Dictionary <string, object>();
parameters.Add("CR", 1.0);
parameters.Add("F", 0.5);
crossover = CrossoverFactory.GetCrossoverOperator("DifferentialEvolutionCrossover", parameters);
// Mutation operator
parameters = new Dictionary <string, object>();
parameters.Add("probability", 1.0 / problem.NumberOfVariables);
parameters.Add("distributionIndex", 20.0);
mutation = MutationFactory.GetMutationOperator("PolynomialMutation", parameters);
algorithm.AddOperator("crossover", crossover);
algorithm.AddOperator("mutation", mutation);
// Execute the Algorithm
long initTime = Environment.TickCount;
SolutionSet population = algorithm.Execute();
long estimatedTime = Environment.TickCount - initTime;
// Result messages
logger.Info("Total execution time: " + estimatedTime + " ms");
logger.Info("Objectives values have been writen to file FUN");
population.PrintObjectivesToFile("FUN");
logger.Info("Variables values have been writen to file VAR");
population.PrintVariablesToFile("VAR");
Console.ReadLine();
if (indicators != null)
{
logger.Info("Quality indicators");
logger.Info("Hypervolume: " + indicators.GetHypervolume(population));
logger.Info("GD : " + indicators.GetGD(population));
logger.Info("IGD : " + indicators.GetIGD(population));
logger.Info("Spread : " + indicators.GetSpread(population));
}
}
