/// <summary>
/// Return an positive factor instance with given low and high bounds. Author: Henry Lin.
/// </summary>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Initial value</param>
/// <param name="doSearch">Whether search on this parameter or not</param>
/// <returns>An instance whose search is on the log space</returns>
static public OptimizationParameter GetPositiveFactorInstance(string name, double value, bool doSearch, double low, double high)
{
OptimizationParameter parameter = GetPositiveFactorInstance(name, value, doSearch);
parameter.Low = low; parameter.High = high;
return(parameter);
}
static public OptimizationParameter GetUntransformedInstance(string name, double value, bool doSearch, double low, double high)
{
OptimizationParameter parameter = new OptimizationParameter();
parameter.Name = name;
parameter.Value = value;
parameter.DoSearch = doSearch;
parameter.ConvertToUntransformedInstance(low, high);
return(parameter);
}
static public OptimizationParameter GetTanInstance(string name, double value, bool doSearch, double low, double high)
{
OptimizationParameter parameter = new OptimizationParameter();
parameter.Name = name;
parameter.Value = value;
parameter.DoSearch = doSearch;
//parameter.LowForSearch = parameter.TransformForSearch(parameter.Low);
//parameter.HighForSearch = parameter.TransformForSearch(parameter.High);
parameter.ConvertToTanInstance(low, high);
return(parameter);
}
public OptimizationParameter Clone()
{
OptimizationParameter parameter = new OptimizationParameter();
parameter.TransformForSearch = TransformForSearch;
parameter.TransformFromSearch = TransformFromSearch;
parameter.Name = Name;
parameter.Value = Value;
parameter.DoSearch = DoSearch;
parameter.Low = Low;
parameter.High = High;
return(parameter);
}
static public OptimizationParameter GetPositiveFactorInstance(string name, double value, bool doSearch)
{
OptimizationParameter parameter = new OptimizationParameter();
//parameter.TransformForSearch = delegate(double r) { return Math.Log(r); };
//parameter.TransformFromSearch = delegate(double r) { return Math.Exp(r); };
//parameter.Low = 1.0 / 1000.0;
//parameter.High = 1000;
//parameter.LowForSearch = parameter.TransformForSearch(parameter.Low);
//parameter.HighForSearch = parameter.TransformForSearch(parameter.High);
parameter.Name = name;
parameter.Value = value;
parameter.DoSearch = doSearch;
parameter.ConvertToPositiveFactorInstance();
return(parameter);
}
static public OptimizationParameter GetProbabilityInstance(string name, double value, bool doSearch)
{
OptimizationParameter parameter = new OptimizationParameter();
//parameter.TransformForSearch = SpecialFunctions.LogOdds;
//parameter.TransformFromSearch = SpecialFunctions.Probability;
//parameter.Low = .001;
//parameter.High = .999;
//parameter.LowForSearch = parameter.TransformForSearch(parameter.Low);
//parameter.HighForSearch = parameter.TransformForSearch(parameter.High);
parameter.Name = name;
parameter.Value = value;
parameter.DoSearch = doSearch;
parameter.ConvertToProbabilityInstance();
return(parameter);
}
override public double Run(Converter <OptimizationParameter, double> oneDRealFunction,
/*ref*/ OptimizationParameter param)
{
try
{
return(Brent.Run(oneDRealFunction, param));
//return Brent.Run(oneDRealFunction, param, gridLineCount, out bestInput);
}
catch (Exception exception)
{
Console.WriteLine("Error calling Brent");
Console.WriteLine(exception.Message);
if (exception.InnerException != null)
{
Console.WriteLine(exception.InnerException.Message);
}
}
return(Grid.Run(oneDRealFunction, param));
}
override public double Run(Converter <OptimizationParameter, double> oneDRealFunction,
OptimizationParameter param)
{
double low = param.LowForSearch;
double high = param.HighForSearch;
Converter <double, double> oneDRealFunctionInDoubleSpace = delegate(double d)
{
param.ValueForSearch = d;
return(oneDRealFunction(param));
};
double initParamValue = param.ValueForSearch;
BestSoFar <double, double> bestFound = OneDOptimizationX(oneDRealFunctionInDoubleSpace, low, high, GridLineCount, Tolerance);
bestFound.Compare(oneDRealFunctionInDoubleSpace(initParamValue), initParamValue); // make sure we didn't get any worse
//bestInput = bestFound.Champ;
param.ValueForSearch = bestFound.Champ;
return(bestFound.ChampsScore);
}
/// <summary> /// Runs maximization for f(x) and returns the best f(x). The corresponding argmax x is in the paramToOptimize. /// </summary> abstract public double Run(Converter <OptimizationParameter, double> oneDRealFunction, OptimizationParameter paramToOptimize);
/// <summary>
/// Runs brent's method as a MAXIMIZATION procedure (I think).
/// </summary>
/// <param name="oneDRealFunction"></param>
/// <param name="param"></param>
/// <param name="gridLineCount"></param>
/// <returns></returns>
override public double Run(Converter <OptimizationParameter, double> oneDRealFunction, /*ref*/ OptimizationParameter param)
{
++DebugCount;
double outputTol = .00000001;
Converter <double, double> oneDRealFunctionInDoubleSpace = delegate(double d)
{
Debug.Assert(!double.IsNaN(d));
param.ValueForSearch = d;
try
{
double odrf = oneDRealFunction(param);
if (double.IsNaN(odrf))
{
return(double.PositiveInfinity);
}
//Debug.Assert(!double.IsNegativeInfinity(odrf)); //!!!for debugging
return(-odrf);
}
catch (Exception exception)
{
Console.WriteLine("Exception turned to NaN in OneDOptimizationBrent");
Console.WriteLine(exception.Message);
if (exception.InnerException != null)
{
Console.WriteLine(exception.InnerException.Message);
}
return(double.NaN);
}
};
double a = param.LowForSearch;
double b = param.ValueForSearch;
Debug.WriteLine(Helper.CreateTabString(DebugCount, "Get a and b from param\n", "", "a", a, "\n", "", "b", b, "\n"));
double c;
// !! why would we not want to always base our starting off low and high, rather than arbitrarily basing high of starting and low??
// !! hm, note that changing it so this always goes in does some weird things to TreeBuilding regression tests. Maybe I'm missing something... JC
if (a > b || Math.Abs(a - b) < Tolerance || double.IsInfinity(b))
{
c = param.HighForSearch;
b = a + GoldenRatio * (c - a);
Debug.WriteLine(Helper.CreateTabString(DebugCount, "if (a > b || Math.Abs(a - b) < inputTol || double.IsInfinity(b)){c = param.HighForSearch;b = a + goldenRatio * (c - a);}\n", "", "a", a, "\n", "", "b", b, "\n", "", "c", c, "\n"));
}
else
{
Debug.Assert(a <b && Math.Abs(a - b)> Tolerance); // real assert
c = b + InvGold * (b - a);
Debug.WriteLine(Helper.CreateTabString(DebugCount, "NOT if (a > b || Math.Abs(a - b) < inputTol || double.IsInfinity(b)){c = b + invGold * (b - a);}", "a", a, "", "\n", "", "b", b, "", "\n", "", "c", c, "", "\n"));
}
double fOfA;
double fOfB;
double fOfC;
double bestInput;
if (FindBracketWithInfinities(ref a, ref b, ref c, oneDRealFunctionInDoubleSpace, Tolerance, outputTol, out bestInput, out fOfA, out fOfB, out fOfC, DebugCount))
{
param.ValueForSearch = bestInput;
return(-fOfB);
}
Debug.WriteLine(Helper.CreateTabString(DebugCount, "About to enter Brent\n", "", "a", a, fOfA, "\n", "", "b", b, fOfB, "\n", "", "c", c, fOfC, "\n"));
Helper.CheckCondition(fOfB < fOfA && fOfB < fOfC, string.Format("About to enter Brent, but prediction, f(b)<f(a) && f(b) < f(c), has failed"));
FuncMin.FuncMinBrent(a, ref b, c, fOfA, ref fOfB, fOfC, Tolerance, oneDRealFunctionInDoubleSpace);
Debug.WriteLine(Helper.CreateTabString(DebugCount, "After Brent\n", "", "a", a, fOfA, "\n", "", "b", b, fOfB, "\n", "", "c", c, fOfC, "\n"));
bestInput = b;
param.ValueForSearch = bestInput;
return(-fOfB);
}
/// <summary>
/// Checks equals based off having identical fields for Name, DoSearch, Value, High, Low and the corresponding values under transformation.
/// Name check is case sensitive.
/// </summary>
public bool Equals(OptimizationParameter param)
{
return(this.Name.Equals(param.Name) && this.Value == param.Value && this.High == param.High && this.Low == param.Low && this.DoSearch == param.DoSearch &&
this.HighForSearch == param.HighForSearch && this.LowForSearch == param.LowForSearch && this.ValueForSearch == param.ValueForSearch); // not guaranteed to check that transformation is the same, but awefully close.
}
