/// <summary>
/// Converts optimization execution status to SolidColorBrush for indication of status
/// </summary>
/// <param name="value">StrategyStatus</param>
/// <param name="targetType">not used</param>
/// <param name="parameter">not used</param>
/// <param name="culture">not used</param>
/// <returns>System.Windows.Media.SolidColorBrush</returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value != null && value != DependencyProperty.UnsetValue)
{
OptimizationStatus status = (OptimizationStatus)value;
// Return certain brush depending on StrategyStatus
if (status.Equals(OptimizationStatus.Working))
{
return(Application.Current.Resources["GreenBrush"]);
}
else if (status.Equals(OptimizationStatus.Completed))
{
return(Application.Current.Resources["BlueBrush"]);
}
else if (status.Equals(OptimizationStatus.Stopped))
{
return(Application.Current.Resources["RedBrush"]);
}
else if (status.Equals(OptimizationStatus.None))
{
return(Application.Current.Resources["GrayBrush"]);
}
}
// Initial state is None, so the color is Gray
return(Application.Current.Resources["GrayBrush"]);
}
/// <summary>
/// Initializes an instance of the optimization summary.
/// </summary>
/// <param name="status">Status of the completed optimization.</param>
/// <param name="nf">Number of function evaluations.</param>
/// <param name="x">Optimized variable array.</param>
/// <param name="f">Optimal value of the objective function.</param>
/// <param name="g">If defined, values of constraint functions at optimum.</param>
internal OptimizationSummary(OptimizationStatus status, int nf, double[] x, double f, double[] g = null)
{
Status = status;
Evals = nf;
X = x;
F = f;
G = g;
}
public void FindMinimum_BobyqaTestCase_ReturnStatusNormal(int m, int npt)
{
// Test problem for BOBYQA, the objective function being the sum of
// the reciprocals of all pairwise distances between the points P_I,
// I=1,2,...,M in two dimensions, where M=N/2 and where the components
// of P_I are X(2*I-1) and X(2*I). Thus each vector X of N variables
// defines the M points P_I. The initial X gives equally spaced points
// on a circle. Four different choices of the pairs (N,NPT) are tried,
// namely (10,16), (10,21), (20,26) and (20,41). Convergence to a local
// minimum that is not global occurs in both the N=10 cases. The details
// of the results are highly sensitive to computer rounding errors. The
// choice IPRINT=2 provides the current X and optimal F so far whenever
// RHO is reduced. The bound constraints of the problem require every
// component of X to be in the interval [-1,1].
var n = 2 * m;
var x0 = new double[n];
var xl = new double[n];
var xu = new double[n];
const double bdl = -1.0;
const double bdu = 1.0;
for (var i = 0; i < n; ++i)
{
xl[i] = bdl;
xu[i] = bdu;
}
Console.WriteLine("{0}2D output with M ={1,4}, N ={2,4} and NPT ={3,4}", Environment.NewLine, m, n, npt);
for (var j = 1; j <= m; ++j)
{
var temp = 2.0 * Math.PI * j / m;
x0[2 * j - 2] = Math.Cos(temp);
x0[2 * j - 1] = Math.Sin(temp);
}
const int iprint = 2;
const int maxfun = 500000;
const double rhobeg = 1.0E-1;
const double rhoend = 1.0E-6;
var optimizer = new Bobyqa(n, this.BobyqaTestCalfun, xl, xu)
{
InterpolationConditions = npt,
TrustRegionRadiusStart = rhobeg,
TrustRegionRadiusEnd = rhoend,
PrintLevel = iprint,
MaximumFunctionCalls = maxfun
};
const OptimizationStatus expected = OptimizationStatus.Normal;
var actual = optimizer.FindMinimum(x0).Status;
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Sets the current optimization status
/// </summary>
/// <param name="optimizationStatus">The new optimization status</param>
protected virtual void SetOptimizationStatus(OptimizationStatus optimizationStatus)
{
lock (_statusLock)
{
// we never come back from an aborted/ended status
if (Status != OptimizationStatus.Aborted && Status != OptimizationStatus.Completed)
{
Status = optimizationStatus;
}
}
}
public virtual MazeCycleOutcome Travel(int?timerTimeout = null, CancellationToken?token = null)
{
const int START_RANDOM = 30;
const int END_RANDOM = 5;
OptimizationStatus?.Invoke("Initializing...");
int sessions = simSettings.SimType == SimulationType.Sessions ? simSettings.Sessions.Value : 100;
DateTime startedOn = simSettings.StartedOn = DateTime.Now;
if (simSettings.SimType == SimulationType.Time)
{
simSettings.EndsOn = startedOn.AddHours(simSettings.Hours.Value);
}
CreateOrLoadNetwork(simSettings.DBIdentifier, sessions, START_RANDOM, END_RANDOM);
OptimizationStatus?.Invoke("Training...");
MazeCycleOutcome outcome = null;
bool stopTraining = false;
do
{
for (int i = 0; i < sessions; i++)
{
outcome = Travel(true, token: token, perMoveDisplay: simSettings.EnableSimDisplay);
if ((simSettings.SimType == SimulationType.Score && outcome.FinalScore >= simSettings.Score.Value) ||
(simSettings.SimType == SimulationType.Time && simSettings.EndsOn < DateTime.Now) ||
(token.HasValue && token.Value.IsCancellationRequested))
{
stopTraining = true;
break;
}
}
if (simSettings.SimType == SimulationType.Sessions)
{
stopTraining = true;
}
ResetRLM();
} while (!stopTraining);
if (!token.HasValue || (token.HasValue && !token.Value.IsCancellationRequested))
{
if (simSettings.SimType == SimulationType.Score)
{
for (int i = 0; i < SimulationSettings.NUM_SCORE_HITS - 1; i++)
{
Travel(false, token: token, perMoveDisplay: simSettings.EnableSimDisplay);
}
}
Travel(false, timerTimeout, token, true);
TrainingDone();
OptimizationStatus?.Invoke("Done");
}
return(outcome);
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="strategyType">Strategy Type containing TradeHubStrategy</param>
public BruteForceParameters(Type strategyType)
{
_status = OptimizationStatus.None;
_strategyType = strategyType;
_parameterDetails = new ObservableCollection <BruteForceParameterDetail>();
}
