public void RunTest()
{
// Valid input - Minimization
{
var optimizer = new SystemPerformanceOptimizer();
// Create the context.
var testableContext =
TestableContinuousOptimizationContext00.Get();
var context = testableContext.Context;
// Set optimization parameters.
int sampleSize = 100;
double rarity = 0.09;
// Solve the problem.
var results = optimizer.Optimize(
context,
rarity,
sampleSize);
Assert.AreEqual(
expected: true,
actual: results.HasConverged);
DoubleMatrixAssert.AreEqual(
expected: testableContext.OptimalState,
actual: results.OptimalState,
delta: .03);
Assert.AreEqual(
expected: testableContext.OptimalPerformance,
actual: results.OptimalPerformance,
DoubleMatrixTest.Accuracy);
}
// Valid input - Maximization
{
var optimizer = new SystemPerformanceOptimizer();
// Create the context.
var testableContext =
TestableContinuousOptimizationContext01.Get();
var context = testableContext.Context;
// Set optimization parameters.
int sampleSize = 100;
double rarity = 0.1;
// Solve the problem.
var results = optimizer.Optimize(
context,
rarity,
sampleSize);
Assert.AreEqual(
expected: true,
actual: results.HasConverged);
DoubleMatrixAssert.AreEqual(
expected: testableContext.OptimalState,
actual: results.OptimalState,
DoubleMatrixTest.Accuracy);
Assert.AreEqual(
expected: testableContext.OptimalPerformance,
actual: results.OptimalPerformance,
DoubleMatrixTest.Accuracy);
}
// Valid input - Maximization - not converging
{
var optimizer = new SystemPerformanceOptimizer();
// Create the context.
var testableContext =
TestableContinuousOptimizationContext01.Get();
var context = new ContinuousOptimizationContext(
objectiveFunction: testableContext.ObjectiveFunction,
initialArgument: testableContext.InitialArgument,
meanSmoothingCoefficient: testableContext.MeanSmoothingCoefficient,
standardDeviationSmoothingCoefficient: testableContext.StandardDeviationSmoothingCoefficient,
standardDeviationSmoothingExponent: testableContext.StandardDeviationSmoothingExponent,
initialStandardDeviation: testableContext.InitialStandardDeviation,
terminationTolerance: testableContext.TerminationTolerance,
optimizationGoal: testableContext.OptimizationGoal,
minimumNumberOfIterations: testableContext.MinimumNumberOfIterations,
maximumNumberOfIterations: testableContext.MinimumNumberOfIterations + 1);
// Set optimization parameters.
int sampleSize = 100;
double rarity = 0.1;
// Solve the problem.
var results = optimizer.Optimize(
context,
rarity,
sampleSize);
Assert.AreEqual(
expected: false,
actual: results.HasConverged);
}
}
/// <summary>
/// Finds the maximum of the specified
/// parametric objective function.
/// </summary>
/// <param name="objectiveFunction">
/// The objective function to be maximized.
/// </param>
/// <param name="initialArgument">
/// The argument at which the method starts the search
/// for optimality.
/// </param>
/// <param name="functionParameter">
/// The function parameter.
/// </param>
/// <typeparam name="TFunctionParameter">
/// The type of the function parameter.
/// </typeparam>
/// <returns>
/// The argument at which the function is maximized.
/// </returns>
/// <remarks>
/// <para>
/// It is assumed that the <paramref name="objectiveFunction"/>
/// will accept row
/// vectors as valid representations of an argument.
/// As a consequence, <paramref name="initialArgument"/> is
/// expected to be a row vector.
/// </para>
/// </remarks>
/// <example>
/// <para>
/// In the following example, function
/// <latex mode='display'>
/// f\round{x,\alpha}=\exp\round{-\round{x-2}^2}
/// + \round{\alpha} \exp\round{-\round{x+2}^2}
/// </latex>
/// is maximized.
/// </para>
/// <para>
/// The search for the maximizer starts from
/// the initial argument <latex>-6</latex>.
/// </para>
/// <para>
/// <code title="Maximizing a parametric function."
/// source="..\Novacta.Analytics.CodeExamples\ContinuousOptimizationExample1.cs.txt"
/// language="cs" />
/// </para>
/// </example>
/// <exception cref="ArgumentNullException">
/// <paramref name="objectiveFunction"/> is
/// <b>null</b>.<br/>
/// -or-<br/>
/// <paramref name="initialArgument"/> is <b>null</b>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="initialArgument"/> is not a row
/// vector.
/// </exception>
public static DoubleMatrix Maximize <TFunctionParameter>(
Func <DoubleMatrix, TFunctionParameter, double> objectiveFunction,
DoubleMatrix initialArgument,
TFunctionParameter functionParameter)
{
#region Input validation
if (objectiveFunction is null)
{
throw new ArgumentNullException(nameof(objectiveFunction));
}
if (initialArgument is null)
{
throw new ArgumentNullException(nameof(initialArgument));
}
if (!initialArgument.IsRowVector)
{
throw new ArgumentException(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR"),
nameof(initialArgument));
}
#endregion
double func(DoubleMatrix x) => objectiveFunction(x, functionParameter);
int numberOfArguments = initialArgument.Count;
var initialParameter = DoubleMatrix.Dense(
2,
numberOfArguments);
initialParameter[0, ":"] = initialArgument;
initialParameter[1, ":"] += 1.0e2;
var optimizer =
new SystemPerformanceOptimizer();
var context = new ContinuousOptimizationContext(
objectiveFunction: func,
initialArgument: initialArgument,
meanSmoothingCoefficient: .8,
standardDeviationSmoothingCoefficient: .7,
standardDeviationSmoothingExponent: 6,
initialStandardDeviation: 100.0,
optimizationGoal: OptimizationGoal.Maximization,
terminationTolerance: 1.0e-3,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
int sampleSize = 100 * numberOfArguments;
double rarity = .01;
var results = optimizer.Optimize(
context,
rarity,
sampleSize);
return(results.OptimalState);
}
