/// <summary>
/// <see cref="IOOOptimizer{T}.Minimize(T, OOOptimizationProblem, CancellationToken)"/>
/// </summary>
/// <param name="Parameters"> Parameters for method. </param>
/// <param name="Problem"> An optimization problem. </param>
/// <param name="Reporter">
/// Object which implement interface <see cref="IProgress{T}"/>, where T is
/// <see cref="Progress"/>. <seealso cref="IOOOptimizer{T}.Minimize(T, OOOptimizationProblem, IProgress{Progress})"/>
/// </param>
/// <param name="CancelToken"> <see cref="CancellationToken"/> </param>
/// <exception cref="InvalidOperationException"> If parameters do not set. </exception>
/// <exception cref="ArgumentNullException">
/// If <paramref name="Problem"/> or <paramref name="Reporter"/> is null.
/// </exception>
/// <exception cref="ArithmeticException">
/// If the function has value is NaN, PositiveInfinity or NegativeInfinity.
/// </exception>
/// <exception cref="OperationCanceledException"></exception>
public override void Minimize(FWParams Parameters, IOOOptProblem Problem, IProgress <Progress> Reporter, CancellationToken CancelToken)
{
if (Reporter == null)
{
throw new ArgumentNullException(nameof(Reporter));
}
Init(Parameters, Problem.LowerBounds.Count, 1);
FirstStep(Problem);
Progress progress = new Progress(this, 0, _parameters.Imax - 1, 0);
Reporter.Report(progress);
for (int i = 1; i < _parameters.Imax; i++)
{
CancelToken.ThrowIfCancellationRequested();
NextStep(Problem);
progress.Current = i;
Reporter.Report(progress);
}
Clear();
}
/// <summary>
/// <see cref="IBaseOptimizer{TParams, TProblem}.Minimize(TParams, TProblem, IProgress{Progress}, CancellationToken)"/>
/// </summary>
/// <param name="Parameters"> General parameters.</param>
/// <param name="Problem">Multiobjective problem</param>
/// <param name="Reporter">
/// Object which implement interface <see cref="IProgress{T}"/>, where T is
/// <see cref="Progress"/>./>
/// </param>
/// <exception cref="InvalidOperationException"> If parameters do not set. </exception>
/// <exception cref="ArgumentNullException">
/// If <paramref name="GenParams"/> or <paramref name="Reporter"/> is null.
/// </exception>
/// <exception cref="ArithmeticException">
/// If the function has value is NaN, PositiveInfinity or NegativeInfinity.
/// </exception>
public override void Minimize(FWParams Parameters, IMOOptProblem Problem, IProgress <Progress> Reporter)
{
if (Reporter == null)
{
throw new ArgumentNullException(nameof(Reporter));
}
if (Problem == null)
{
throw new ArgumentNullException(nameof(Problem));
}
Init(Parameters, Problem.LowerBounds.Count, Problem.CountObjs);
FirstStep(Problem);
Progress progress = new Progress(this, 0, this._parameters.Imax - 1, 0);
Reporter.Report(progress);
for (int i = 1; i < this._parameters.Imax; i++)
{
NextStep(Problem);
progress.Current = i;
Reporter.Report(progress);
}
Clear();
}
protected override void Init(FWParams Parameters, int Dim, int DimObjs)
{
base.Init(Parameters, Dim, DimObjs);
if (_chargesCopy == null)
{
_chargesCopy = new List <Agent>(Parameters.NP);
for (int i = 0; i < Parameters.NP; i++)
{
_chargesCopy.Add(_pool.GetAgent());
}
}
else if (_chargesCopy.Count != Parameters.NP)
{
_chargesCopy.Clear();
_chargesCopy.Capacity = Parameters.NP;
for (int i = 0; i < Parameters.NP; i++)
{
_chargesCopy.Add(_pool.GetAgent());
}
}
_currentFronts = new int[Parameters.NP];
}
public void FWOptimizerTestArithmeticException(InvalidFunc TypeFunc)
{
FWOptimizer fw = new FWOptimizer();
FWParams param = new FWParams(10, 1000 * 1000, 3, 5, 10, 40);
Assert.Throws <InvalidValueFunctionException>(() => GeneralOptimizerTests.TestInavlidFunction(fw, param, TypeFunc));
}
public void FWOptimizerTestOptimization()
{
FWOptimizer fw = new FWOptimizer();
FWParams param = new FWParams(10, GeneralOptimizerTests.ITER_MAX, 3, 1, 2, 4);
bool error = GeneralOptimizerTests.TestOptimizer(fw, param);
Assert.False(error);
}
public void FWOptimizerTestCancel()
{
FWOptimizer fw = new FWOptimizer();
// Distance is Manhattan distance.
FWParams param = new FWParams(10, 1000 * 1000, 3, 5, 10, 40);
bool error = GeneralOptimizerTests.TestCancel(fw, param);
Assert.False(error);
}
/// <summary>
/// <see cref="IOOOptimizer{T}.Minimize(T, OOOptimizationProblem)"/>
/// </summary>
/// <param name="Parameters"> Parameters for method. </param>
/// <param name="Problem"> An optimization problem. </param>
/// <exception cref="InvalidOperationException"> If parameters do not set. </exception>
/// <exception cref="ArgumentNullException"> If <paramref name="Problem"/> is null. </exception>
/// <exception cref="ArithmeticException">
/// If the function has value is NaN, PositiveInfinity or NegativeInfinity.
/// </exception>
public override void Minimize(FWParams Parameters, IOOOptProblem Problem)
{
Init(Parameters, Problem.LowerBounds.Count, 1);
FirstStep(Problem);
for (int i = 1; i < _parameters.Imax; i++)
{
NextStep(Problem);
}
Clear();
}
protected override void Init(FWParams Parameters, int Dimension, int DimObjs)
{
base.Init(Parameters, Dimension, DimObjs);
if (_solution == null)
{
_solution = new Agent(Dimension, DimObjs);
}
else if (_solution.Point.Count != Dimension)
{
_solution = new Agent(Dimension, DimObjs);
}
}
public void FWOptimizerTestReporter()
{
FWOptimizer fw = new FWOptimizer();
FWParams param = new FWParams(10, GeneralOptimizerTests.ITER_MAX, 3, 1, 4, 5);
var reporter = new TestReporter(typeof(FWOptimizer), 0, GeneralOptimizerTests.ITER_MAX - 1);
// Optimization f(x,y)=x^2 + y^2 on [-10;10]x[-10;10].
fw.Minimize(param, new OOOptimizationProblem(GeneralOptimizerTests.TargetFunction, GeneralOptimizerTests.LowerBounds, GeneralOptimizerTests.UpperBounds), reporter);
Assert.False(reporter.Error);
}
/// <summary>
/// <see cref="IOOOptimizer{T}.Minimize(T, OOOptimizationProblem, CancellationToken)"/>
/// </summary>
/// <param name="Parameters"> Parameters for method. </param>
/// <param name="Problem"> An optimization problem. </param>
/// <param name="CancelToken"> <see cref="CancellationToken"/> </param>
/// <exception cref="InvalidOperationException"> If parameters do not set. </exception>
/// <exception cref="ArgumentNullException"> If <paramref name="Problem"/> is null. </exception>
/// <exception cref="ArithmeticException">
/// If the function has value is NaN, PositiveInfinity or NegativeInfinity.
/// </exception>
/// <exception cref="OperationCanceledException"></exception>
public override void Minimize(FWParams Parameters, IOOOptProblem Problem, CancellationToken CancelToken)
{
Init(Parameters, Problem.LowerBounds.Count, 1);
FirstStep(Problem);
for (int i = 1; i < _parameters.Imax; i++)
{
CancelToken.ThrowIfCancellationRequested();
NextStep(Problem);
}
Clear();
}
public void MOFWOptimizerTest2()
{
MOFWOptimizer optimizer = new MOFWOptimizer();
FWParams param = new FWParams(20, 5, 0.1, 2, 5, 0.2);
MOOptimizationProblem problem = new MOOptimizationProblem(
new List <Func <IReadOnlyList <double>, double> >()
{
Obj1,
Obj2
},
Enumerable.Repeat(0.0, 5).ToArray(),
Enumerable.Repeat(1.0, 5).ToArray()
);
optimizer.Minimize(param, problem);
Assert.True(optimizer.ParetoFront.Count() == param.NP);
}
/// <summary>
/// <see cref="IBaseOptimizer{TParams, TProblem}.Minimize(TParams, TProblem, IProgress{Progress}, CancellationToken)"/>
/// </summary>
/// <param name="Parameters"> General parameters.</param>
/// <param name="Problem">Multiobjective problem</param>
/// <param name="CancelToken"> <see cref="CancellationToken"/> </param>
/// <exception cref="InvalidOperationException"> If parameters do not set. </exception>
/// <exception cref="ArgumentNullException"> If <paramref name="Problem"/> is null. </exception>
/// <exception cref="ArithmeticException">
/// If the function has value is NaN, PositiveInfinity or NegativeInfinity.
/// </exception>
/// <exception cref="OperationCanceledException"></exception>
public override void Minimize(FWParams Parameters, IMOOptProblem Problem, CancellationToken CancelToken)
{
if (Problem == null)
{
throw new ArgumentNullException(nameof(Problem));
}
Init(Parameters, Problem.LowerBounds.Count, Problem.CountObjs);
FirstStep(Problem);
for (int i = 1; i < this._parameters.Imax; i++)
{
CancelToken.ThrowIfCancellationRequested();
NextStep(Problem);
}
Clear();
}
/// <summary>
/// <see cref="IBaseOptimizer{TParams, TProblem}.Minimize(TParams, TProblem)"/>
/// </summary>
/// <param name="Parameters"> General parameters. <see cref="FWParams"/>. </param>
/// <param name="Problem">Multiobjective problem</param>
/// <exception cref="InvalidOperationException"> If parameters do not set. </exception>
/// <exception cref="ArgumentNullException"> If <paramref name="Problem"/> is null. </exception>
/// <exception cref="ArithmeticException">
/// If the function has value is NaN, PositiveInfinity or NegativeInfinity.
/// </exception>
public override void Minimize(FWParams Parameters, IMOOptProblem Problem)
{
if (Problem == null)
{
throw new ArgumentNullException(nameof(Problem));
}
Init(Parameters, Problem.LowerBounds.Count, Problem.CountObjs);
FirstStep(Problem);
for (int i = 1; i < _parameters.Imax; i++)
{
_iter = i;
NextStep(Problem);
}
Clear();
}
private static void Main(string[] args)
{
IMOOptProblem problem = new ZDT1(Enumerable.Repeat(0.0, 10).ToArray(), Enumerable.Repeat(1.0, 10).ToArray());
MOFWOptimizer optimizer = new MOFWOptimizer();
FWParams parameters = new FWParams(50, 200, 20, 10, 30, 2);
ProgressReporter reporter = new ProgressReporter();
optimizer.Minimize(parameters, problem, reporter);
foreach (Agent agent in optimizer.ParetoFront)
{
Console.WriteLine($"F1 = {agent.Objs[0]} F2 = {agent.Objs[1]}");
}
Console.ReadKey();
}
private static void Main(string[] args)
{
IOOOptimizer <BBBCParams> bbbc = new BBBCOptimizer();
IOOOptimizer <FWParams> fw = new FWOptimizer();
IOOOptimizer <GEMParams> gem = new GEMOptimizer();
BBBCParams param1 = new BBBCParams(20, 200, 0.4, 0.5);
FWParams param2 = new FWParams(20, 100, 20, 10, 20, 40);
GEMParams param3 = new GEMParams(1, 100, 50, 2 * Math.Sqrt(2), 100);
IOOOptProblem param = new RastriginProblem();
Console.WriteLine("Exact solution: f(x) = 0, x = (0, 0).");
Console.WriteLine();
Test(bbbc, param1, param, "BBBC");
Test(fw, param2, param, "Fireworks");
Test(gem, param3, param, "GEM");
Console.WriteLine("Complete");
Console.ReadKey();
}
private static void SolveFW(INamedMOProblem Problem, string PathToOutDir, int MaxRun)
{
MappedDiagnosticsContext.Set("thread_id", $"_{Thread.CurrentThread.ManagedThreadId}_");
Logger logger = LogManager.GetLogger("Main");
const int numParams = 6;
object[][] parameters =
{
//new object[numParams] {250, 600, 10, 20, 30, 1.1},
new object[numParams] {
300, 700, 20, 8, 15, 0.025
},
new object[numParams] {
300, 1000, 25, 8, 17, 0.05
},
new object[numParams] {
400, 900, 15, 8, 12, 0.1
},
new object[numParams] {
350, 750, 20, 10, 19, 0.15
}
};
string pathToXml = Path.Combine(PathToOutDir, $"{Problem.Name}_res.xml");
logger.Info($"Open a xml file. '{pathToXml}'");
var normalGen = new NormalGen();
var contGen = new ContGen();
MOFWOptimizer opt = new MOFWOptimizer(contGen, normalGen);
using (XmlWriter writer = XmlWriter.Create(pathToXml))
{
writer.WriteStartDocument();
writer.WriteStartElement("Problem");
Dictionary <string, string> problemDesc = new Dictionary <string, string>
{
["Name"] = Problem.Name,
["DimDec"] = Problem.LowerBounds.Count.ToString(),
["DimObj"] = Problem.CountObjs.ToString(),
};
foreach (var name in problemDesc)
{
writer.WriteAttributeString(name.Key, name.Value);
}
writer.WriteStartElement("Bounds");
foreach (var bound in Problem.LowerBounds.Zip(Problem.UpperBounds, (low, upp) => (Lower: low, Upper: upp)))
{
writer.WriteStartElement("Bound");
writer.WriteAttributeString("LowerB", bound.Lower.ToString());
writer.WriteAttributeString("UpperB", bound.Upper.ToString());
writer.WriteEndElement();
}
writer.WriteEndElement();
logger.Info("Start solving with MOFW.");
foreach (var par in Enumerable.Range(0, parameters.Length).Zip(parameters, (num, par) => (Num: num, Parameters: par)))
{
logger.Info($"Try to find solution with {par.Num}th configuration of {parameters.Length}");
writer.WriteStartElement("Experiment");
writer.WriteStartElement("OptParams");
FWParams pars = CreateParams <FWParams>(par.Parameters);
var paramsType = pars.GetType();
foreach (var prop in paramsType.GetProperties())
{
if (prop.PropertyType == typeof(bool))
{
continue;
}
writer.WriteStartElement("Param");
writer.WriteAttributeString(prop.Name, prop.GetValue(pars).ToString());
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("Runs");
for (int i = 0; i < MaxRun; i++)
{
logger.Info($"Run {i} of {MaxRun}");
writer.WriteStartElement("Run");
try
{
opt.Minimize(pars, Problem);
writer.WriteStartElement("Decisions");
foreach (var agent in opt.ParetoFront)
{
writer.WriteStartElement("Point");
for (int coordIndex = 0; coordIndex < agent.Point.Count; coordIndex++)
{
writer.WriteAttributeString($"x{coordIndex + 1}", agent.Point[coordIndex].ToString());
}
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("Targets");
foreach (var agent in opt.ParetoFront)
{
writer.WriteStartElement("Target");
for (int coordIndex = 0; coordIndex < agent.Objs.Count; coordIndex++)
{
writer.WriteAttributeString($"F{coordIndex + 1}", agent.Objs[coordIndex].ToString());
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
catch (Exception exc)
{
logger.Error(exc, "Error was in optimization process.");
logger.Info("Recreate optimization method.");
opt = new MOFWOptimizer();
logger.Info($"Skip run {i}.");
}
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
}
}
logger.Info("Close a xml file.");
MappedDiagnosticsContext.Remove("thread_id");
}
