/// <summary> /// Attempts a calibration through <see cref="PelsserCappletOptimizationProblem"/> /// using caps matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">The controller which may be used to cancel the process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List <object> data, IEstimationSettings settings = null, IController controller = null, Dictionary <string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; MatrixMarketData normalVol = null; if (data.Count > 1) { normalVol = (MatrixMarketData)data[1]; } EstimationResult result; if ((dataset.ZRMarket == null) || (dataset.CapVolatility == null)) { result = new EstimationResult(); result.ErrorMessage = "Not enough data to calibrate.\n" + "The estimator needs a ZRMarket and a CapVolatility " + "defined inside InterestRateMarketData"; return(result); } // Backup the dates DateTime effectiveDate = DateTime.Now.Date; DateTime valuationDate = DateTime.Now.Date; if (Document.ActiveDocument != null) { effectiveDate = Document.ActiveDocument.ContractDate; valuationDate = Document.ActiveDocument.SimulationStartDate; } // Creates the Context. Document doc = new Document(); ProjectROV prj = new ProjectROV(doc); doc.Part.Add(prj); Function zr = new PFunction(null); zr.VarName = "zr"; // Load the zr. double[,] zrvalue = (double[, ])ArrayHelper.Concat(dataset.ZRMarketDates.ToArray(), dataset.ZRMarket.ToArray()); zr.Expr = zrvalue; prj.Symbols.Add(zr); var bm = BlackModelFactory(zr); if (bm is BachelierNormalModel) { (bm as BachelierNormalModel).Tenor = dataset.CapTenor; } double deltak = dataset.CapTenor; Matrix capVol = normalVol != null ? normalVol.Values:dataset.CapVolatility; Vector capMat = normalVol != null ? normalVol.RowValues: dataset.CapMaturity; Vector capK = normalVol != null ? normalVol.ColumnValues: dataset.CapRate; var preferences = settings as Fairmat.Calibration.CapVolatilityFiltering; // Matrix calculated with black. var blackCaps = new Matrix(capMat.Length, capK.Length); for (int m = 0; m < capMat.Length; m++) { for (int s = 0; s < capK.Length; s++) { bool skip = false; if (preferences != null) { if (capK[s] < preferences.MinCapRate || capK[s] > preferences.MaxCapRate || capMat[m] < preferences.MinCapMaturity || capMat[m] > preferences.MaxCapMaturity) { skip = true; } } if (capVol[m, s] == 0 || skip) { blackCaps[m, s] = 0; } else { blackCaps[m, s] = bm.Cap(capK[s], capVol[m, s], deltak, capMat[m]); } } } if (blackCaps.IsNaN()) { Console.WriteLine("Black caps matrix has non real values:"); Console.WriteLine(blackCaps); throw new Exception("Cannot calculate Black caps"); } // Maturity goes from 0 to the last item with step deltaK. Vector maturity = new Vector((int)(1.0 + capMat[capMat.Length - 1] / deltak)); for (int l = 0; l < maturity.Length; l++) { maturity[l] = deltak * l; } Vector fwd = new Vector(maturity.Length - 1); for (int i = 0; i < fwd.Length; i++) { fwd[i] = bm.Fk(maturity[i + 1], deltak); } // Creates a default Pelsser model. Pelsser.SquaredGaussianModel model = new Pelsser.SquaredGaussianModel(); model.a1 = (ModelParameter)0.014; model.sigma1 = (ModelParameter)0.001; model.zr = (ModelParameter)"@zr"; StochasticProcessExtendible iex = new StochasticProcessExtendible(prj, model); prj.Processes.AddProcess(iex); prj.Parse(); DateTime t0 = DateTime.Now; Caplet cp = new Caplet(); PelsserCappletOptimizationProblem problem = new PelsserCappletOptimizationProblem(prj, cp, maturity, fwd, capK, deltak, capMat, blackCaps); IOptimizationAlgorithm solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 35; o.TargetCost = 0.0025; o.MaxIter = 10; o.Verbosity = Math.Max(1, Engine.Verbose); o.controller = controller; // Parallel evaluation is not supported for this calibration. o.Parallel = false; o.Debug = true; SolutionInfo solution = null; Vector x0 = (Vector) new double[] { 0.1, 0.1 }; solution = solver.Minimize(problem, o, x0); if (solution.errors) { return(new EstimationResult(solution.message)); } o.epsilon = 10e-7; o.h = 10e-7; o.MaxIter = 1000; o.Debug = true; o.Verbosity = Math.Max(1, Engine.Verbose); if (solution != null) { solution = solver2.Minimize(problem, o, solution.x); } else { solution = solver2.Minimize(problem, o, x0); } if (solution.errors) { return(new EstimationResult(solution.message)); } Console.WriteLine(solution); string[] names = new string[] { "alpha1", "sigma1" }; result = new EstimationResult(names, solution.x); result.ZRX = (double[])dataset.ZRMarketDates.ToArray(); result.ZRY = (double[])dataset.ZRMarket.ToArray(); result.Objects = new object[1]; result.Objects[0] = solution.obj; //result.Fit = solution.obj;//Uncomment in 1.6 // Restore the dates if (Document.ActiveDocument != null) { Document.ActiveDocument.ContractDate = effectiveDate; Document.ActiveDocument.SimulationStartDate = valuationDate; } return(result); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SteepestDescent obj) { return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; }
static void Main(string[] args) { double oneOver2Pi = 1.0 / (1.0 * Math.Sqrt(2 * Math.PI)); Console.WriteLine(NormalCDFInverse(0.99)); Console.WriteLine(inv_cdf(0.99)); Console.WriteLine(InverseCDF.QNorm(0.99, 0, 1, true, false)); Console.WriteLine(NormalCDFInverse(0.5)); Console.WriteLine(inv_cdf(0.5)); Console.WriteLine(InverseCDF.QNorm(0.5, 0, 1, true, false)); Console.WriteLine(NormalCDFInverse(0.31)); Console.WriteLine(inv_cdf(0.31)); Console.WriteLine(InverseCDF.QNorm(0.31, 0, 1, true, false)); //x4−8x2 + 5 Func <double[], double> testFunc1 = (x) => { return(Math.Pow(x[0], 4) - 8 * Math.Pow(x[0], 2) + 5); }; Func <double[], double>[] dtestFunc1 = new Func <double[], double> [1]; dtestFunc1[0] = (x) => { return(4 * Math.Pow(x[0], 3) - 16 * x[0]); }; Func <double[], double> testConstr = (x) => { return(5 - Math.Exp(x[0]) + 2.0 * Math.Pow(x[0] - 1, 2)); }; Func <double[], double> testv = (x) => { double a = x[0]; return(0.0); }; //Func<Variables, double> testFunc = (x) => { // return Math.Pow(x.Vars[0], 4) - 3 * Math.Pow(x.Vars[0], 3) + 2; //}; //Func<Variables, double> dTestfunc = (x) => //{ // return 4 * Math.Pow(x.Vars[0], 3) - 9 * Math.Pow(x.Vars[0], 2); //}; //x4−3x3 + 2 //TestFunc(); Func <double[], double> bananaFunc = (x) => { return(Math.Pow(1 - x[0], 2) + 100 * Math.Pow(x[1] - x[0] * x[0], 2)); }; Func <double[], double> powell = (x) => { return(Math.Pow(x[0] + 10 * x[1], 2) + 5 * Math.Pow(x[2] - x[3], 2) + Math.Pow(x[1] + 2 * x[2], 4) + 10 * Math.Pow(x[0] - x[3], 4)); }; OptVector[] ttt = new OptVector[3]; ttt[0] = new OptVector(new double[3] { 1, 2, 3 }); ttt[1] = new OptVector(new double[3] { 4, 5, 6 }); ttt[2] = new OptVector(new double[3] { 7, 8, 9 }); var tr = OptVector.Transpose(ttt); //TestsSQP.Test0(); TestsSQP.Test1(); TestsSQP.Test2(); TestsSQP.Test3(); ////TestsSQP.Test4(); ////TestsSQP.Test5(); TestsSQP.Test6(); TestsSQP.Test7(); TestsSQP.Test8(); TestsSQP.Test9(); TestsSQP.Test10(); TestsSQP.Test11(); TestsSQP.Test12(); TestsSQP.Test13(); TestsSQP.Test14(); TestsSQP.Test15(); TestsSQP.Test16(); TestsSQP.Test17(); TestsSQP.Test18(); TestsSQP.Test19(); TestsSQP.Test20(); TestsSQP.Test21(); TestsSQP.Test22(); TestsSQP.Test23(); TestsSQP.Test24(); TestsSQP.Test25(); TestsSQP.Test26(); TestsSQP.Test27(); TestsSQP.Test28(); //TestCGMethod(); BFGS bfsg = new BFGS(); var result0 = bfsg.Solve(powell, new double[] { 3.0, -1.0, 0.0, 1.0 }, 10000); Console.WriteLine("Min " + powell(result0)); NLCG gradient = new NLCG(); var result = gradient.Solve(powell, new double[] { 3.0, -1.0, 0.0, 1.0 }, 4000); Console.WriteLine("Min " + powell(result)); SteepestDescent gradientSteep = new SteepestDescent(); var result1 = gradientSteep.Solve(powell, new double[] { 3.0, -1.0, 0.0, 1.0 }, 10000); Console.WriteLine("Min " + powell(result1)); //Variables result = SteepestDescent(testFunc, dTestFunc, 2, 20); for (int i = 0; i < result.Length; i++) { Console.WriteLine("result " + result[i]); } //Console.WriteLine("ver " + testFunc(result)); Console.ReadLine(); }
/// <summary> /// Attempts a calibration through <see cref="SwaptionHW1OptimizationProblem"/> /// using swaption matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">The controller which may be used to cancel the process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List <object> data, IEstimationSettings settings = null, IController controller = null, Dictionary <string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; MatrixMarketData normalVol = null; if (data.Count > 1) { normalVol = (MatrixMarketData)data[1]; } PFunction zr = new PFunction(null); // Loads the zero rate. double[,] zrvalue = (double[, ])ArrayHelper.Concat(dataset.ZRMarketDates.ToArray(), dataset.ZRMarket.ToArray()); zr.Expr = zrvalue; double deltak = dataset.SwaptionTenor; Console.WriteLine("Swaption Tenor\t" + dataset.SwaptionTenor); var swaptionsFiltering = settings as SwaptionsFiltering; if (swaptionsFiltering == null) { swaptionsFiltering = new SwaptionsFiltering();//creates a default } //F stands for Full matrix var optionMaturityF = normalVol != null ? normalVol.RowValues: dataset.OptionMaturity; var swapDurationF = normalVol != null ? normalVol.ColumnValues: dataset.SwapDuration; var swaptionsVolatilityF = normalVol != null ? normalVol.Values: dataset.SwaptionsVolatility; int maturitiesCount = optionMaturityF.Count(x => x >= swaptionsFiltering.MinSwaptionMaturity && x <= swaptionsFiltering.MaxSwaptionMaturity); int durationsCount = swapDurationF.Count(x => x >= swaptionsFiltering.MinSwapDuration && x <= swaptionsFiltering.MaxSwapDuration); Console.WriteLine(string.Format("Calibrating on {0} swaptions prices [#maturiries x #durations]=[{1} x {2}]", maturitiesCount * durationsCount, maturitiesCount, durationsCount)); if (maturitiesCount * durationsCount == 0) { return(new EstimationResult("No swaptions satisfying criteria found, please relax filters")); } //reduced version var swaptionsVolatility = new Matrix(maturitiesCount, durationsCount); // dataset.SwaptionsVolatility; var optionMaturity = new Vector(maturitiesCount); // dataset.OptionMaturity; var swapDuration = new Vector(durationsCount); // dataset.SwapDuration; //Build filtered matrix and vectors int fm = 0; for (int m = 0; m < optionMaturityF.Length; m++) { int fd = 0; if (optionMaturityF[m] >= swaptionsFiltering.MinSwaptionMaturity && optionMaturityF[m] <= swaptionsFiltering.MaxSwaptionMaturity) { for (int d = 0; d < swapDurationF.Length; d++) { if (swapDurationF[d] >= swaptionsFiltering.MinSwapDuration && swapDurationF[d] <= swaptionsFiltering.MaxSwapDuration) { swaptionsVolatility[fm, fd] = swaptionsVolatilityF[m, d]; swapDuration[fd] = swapDurationF[d]; fd++; } } optionMaturity[fm] = optionMaturityF[m]; fm++; } } var swbm = new SwaptionsBlackModel(zr, BlackModelFactory(zr)); Matrix fsr; var blackSwaptionPrice = 1000.0 * swbm.SwaptionsSurfBM(optionMaturity, swapDuration, swaptionsVolatility, deltak, out fsr); Console.WriteLine("Maturities\t" + optionMaturity); Console.WriteLine("swapDuration\t" + swapDuration); Console.WriteLine("SwaptionHWEstimator: Black model prices"); Console.WriteLine(blackSwaptionPrice); SwaptionHW1 swhw1 = new SwaptionHW1(zr); SwaptionHW1OptimizationProblem problem = new SwaptionHW1OptimizationProblem(swhw1, blackSwaptionPrice, optionMaturity, swapDuration, deltak); IOptimizationAlgorithm solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 20; o.MaxIter = 5; o.Verbosity = 1; o.controller = controller; SolutionInfo solution = null; Vector x0 = new Vector(new double[] { 0.1, 0.1 }); solution = solver.Minimize(problem, o, x0); if (solution.errors) { return(new EstimationResult(solution.message)); } o.epsilon = 10e-8; o.h = 10e-8; o.MaxIter = 1000; // We can permit this, given it is fast. o.accourate_numerical_derivatives = true; if (solution != null) { solution = solver2.Minimize(problem, o, solution.x); } else { solution = solver2.Minimize(problem, o, x0); } if (solution.errors) { return(new EstimationResult(solution.message)); } Console.WriteLine("Solution:"); Console.WriteLine(solution); string[] names = new string[] { "Alpha", "Sigma" }; Console.WriteLine("SwaptionHWEstimator: hw model prices and error"); problem.Obj(solution.x, true); EstimationResult result = new EstimationResult(names, solution.x); result.ZRX = (double[])dataset.ZRMarketDates.ToArray(); result.ZRY = (double[])dataset.ZRMarket.ToArray(); double obj = problem.Obj(solution.x); return(result); }
/// <summary> /// Attempts a calibration through <see cref="CapsHW1OptimizationProblem"/> /// using caps matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">The controller which may be used to cancel the process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List<object> data, IEstimationSettings settings = null, IController controller = null, Dictionary<string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; PFunction zr = new PFunction(null); zr.VarName = "zr"; var preferences = settings as Fairmat.Calibration.CapVolatilityFiltering; // Loads ZR double[,] zrvalue = (double[,])ArrayHelper.Concat(dataset.ZRMarketDates.ToArray(), dataset.ZRMarket.ToArray()); zr.Expr = zrvalue; BlackModel bm = new BlackModel(zr); double deltak = dataset.CapTenor; if (dataset.CapVolatility == null) return new EstimationResult("Cap not available at requested date"); Matrix capVolatility = dataset.CapVolatility; Vector capMaturity = dataset.CapMaturity; Vector capRate = dataset.CapRate; double a = 0.1; double sigma = 0.1; // Matrix calculated with Black. Matrix blackCaps = new Matrix(capMaturity.Length, capRate.Length); Matrix logic = new Matrix(capMaturity.Length, capRate.Length); for (int m = 0; m < capMaturity.Length; m++) { for (int s = 0; s < capRate.Length; s++) { blackCaps[m, s] = bm.Cap(capRate[s], capVolatility[m, s], deltak, capMaturity[m]); if (double.IsNaN(blackCaps[m, s])) { bm.Cap(capRate[s], capVolatility[m, s], deltak, capMaturity[m]); throw new Exception("Malformed black caps"); } if (blackCaps[m, s] == 0.0) { logic[m, s] = 0.0; } else { logic[m, s] = 1.0; } //filter if (preferences != null) { if (capRate[s] < preferences.MinCapRate || capRate[s] > preferences.MaxCapRate || capMaturity[m]<preferences.MinCapMaturity|| capMaturity[m]>preferences.MaxCapMaturity) {logic[m, s] = 0; blackCaps[m, s] = 0;} } } } DateTime t0 = DateTime.Now; CapHW1 hw1Caps = new CapHW1(zr); Matrix caps = hw1Caps.HWMatrixCaps(capMaturity, capRate, a, sigma, deltak); for (int m = 0; m < capMaturity.Length; m++) { for (int s = 0; s < capRate.Length; s++) { caps[m, s] = logic[m, s] * caps[m, s]; } } CapsHW1OptimizationProblem problem = new CapsHW1OptimizationProblem(hw1Caps, blackCaps, capMaturity, capRate, deltak); Vector provaparam = new Vector(2); var solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 20; o.MaxIter = 10; o.Verbosity = 1; o.Parallel = false; SolutionInfo solution = null; Vector x0 = new Vector(new double[] { 0.05, 0.01 }); o.controller = controller; solution = solver.Minimize(problem, o, x0); o.epsilon = 10e-8; o.h = 10e-8; o.MaxIter = 100; solution = solver2.Minimize(problem, o, solution.x); if (solution.errors) return new EstimationResult(solution.message); Console.WriteLine("Solution:"); Console.WriteLine(solution); string[] names = new string[] { "Alpha", "Sigma" }; //solution.x[0] *= 3; EstimationResult result = new EstimationResult(names, solution.x); result.ZRX = (double[])dataset.ZRMarketDates.ToArray(); result.ZRY = (double[])dataset.ZRMarket.ToArray(); return result; }
void Visualize() { idx = 0; vDataPoints = new List <GameObject>(); // vDataPoints is a list of GameOjbects (prefix 'v' is for visualized) // mapping each type to a material index assuming number of unique types is less than number of materials int materialIndex = 0; Dictionary <string, int> typeToColor = new Dictionary <string, int>(); foreach (DataPoint dataPoint in dataPoints) { if (!typeToColor.ContainsKey(dataPoint.type)) { typeToColor.Add(dataPoint.type, materialIndex); materialIndex++; } } /* * order is a list of datapoints in the order of removal by steepest descent * it's easier to imagine order as dataPoints but with a different ordering of elements * this order of elements matters because it's the order of the traversal of the visualization method. * * TODO change from list to array because size is known beforehand */ List <DataPoint> order = new List <DataPoint>(); while (dataPoints.Any()) // FIXME SteepestDescent returns NaN when there are no unique coordinates in dataPoints { if (dataPoints.Count == 1) { order.Add(dataPoints.Last()); break; } double init_x = dataPoints[0].x, init_y = dataPoints[0].y; // initial point is first point Vector2[] steps = SteepestDescent.Run(dataPoints, init_x, init_y, 0.03, 300); int nearest = GetNearest(dataPoints, steps.Last()); order.Add(dataPoints[nearest]); dataPoints.RemoveAt(nearest); // TODO optimize using dictionary or boolean visited array } // instantiate datapoints foreach (DataPoint dataPoint in order) { double y = SteepestDescent.CauchyTotalPotential(order, dataPoint.x, dataPoint.y); double x = dataPoint.x; double z = dataPoint.y; Vector3 position = new Vector3(XZ_Scale * (float)x, Y_Scale * (float)y, XZ_Scale * (float)z); GameObject vPoint = Instantiate(rockPrefab, position, Quaternion.identity); int colorIndex = typeToColor[dataPoint.type]; vPoint.GetComponent <MeshRenderer>().material = colors[colorIndex]; vDataPoints.Add(vPoint); } // instaniate trail trail = Instantiate(trailPrefab, Vector3.zero, Quaternion.identity); StartCoroutine(Animate()); }
/// <summary> /// Attempts a calibration through <see cref="CapsHW1OptimizationProblem"/> /// using caps matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">The controller which may be used to cancel the process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List <object> data, IEstimationSettings settings = null, IController controller = null, Dictionary <string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; PFunction zr = new PFunction(null); zr.VarName = "zr"; var preferences = settings as Fairmat.Calibration.CapVolatilityFiltering; // Loads ZR double[,] zrvalue = (double[, ])ArrayHelper.Concat(dataset.ZRMarketDates.ToArray(), dataset.ZRMarket.ToArray()); zr.Expr = zrvalue; BlackModel bm = new BlackModel(zr); double deltak = dataset.CapTenor; if (dataset.CapVolatility == null) { return(new EstimationResult("Cap not available at requested date")); } Matrix capVolatility = dataset.CapVolatility; Vector capMaturity = dataset.CapMaturity; Vector capRate = dataset.CapRate; double a = 0.1; double sigma = 0.1; // Matrix calculated with Black. Matrix blackCaps = new Matrix(capMaturity.Length, capRate.Length); Matrix logic = new Matrix(capMaturity.Length, capRate.Length); for (int m = 0; m < capMaturity.Length; m++) { for (int s = 0; s < capRate.Length; s++) { blackCaps[m, s] = bm.Cap(capRate[s], capVolatility[m, s], deltak, capMaturity[m]); if (double.IsNaN(blackCaps[m, s])) { bm.Cap(capRate[s], capVolatility[m, s], deltak, capMaturity[m]); throw new Exception("Malformed black caps"); } if (blackCaps[m, s] == 0.0) { logic[m, s] = 0.0; } else { logic[m, s] = 1.0; } //filter if (preferences != null) { if (capRate[s] < preferences.MinCapRate || capRate[s] > preferences.MaxCapRate || capMaturity[m] < preferences.MinCapMaturity || capMaturity[m] > preferences.MaxCapMaturity) { logic[m, s] = 0; blackCaps[m, s] = 0; } } } } DateTime t0 = DateTime.Now; CapHW1 hw1Caps = new CapHW1(zr); Matrix caps = hw1Caps.HWMatrixCaps(capMaturity, capRate, a, sigma, deltak); for (int m = 0; m < capMaturity.Length; m++) { for (int s = 0; s < capRate.Length; s++) { caps[m, s] = logic[m, s] * caps[m, s]; } } CapsHW1OptimizationProblem problem = new CapsHW1OptimizationProblem(hw1Caps, blackCaps, capMaturity, capRate, deltak); Vector provaparam = new Vector(2); var solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 20; o.MaxIter = 10; o.Verbosity = 1; o.Parallel = false; SolutionInfo solution = null; Vector x0 = new Vector(new double[] { 0.05, 0.01 }); o.controller = controller; solution = solver.Minimize(problem, o, x0); o.epsilon = 10e-8; o.h = 10e-8; o.MaxIter = 100; solution = solver2.Minimize(problem, o, solution.x); if (solution.errors) { return(new EstimationResult(solution.message)); } Console.WriteLine("Solution:"); Console.WriteLine(solution); string[] names = new string[] { "Alpha", "Sigma" }; //solution.x[0] *= 3; EstimationResult result = new EstimationResult(names, solution.x); result.ZRX = (double[])dataset.ZRMarketDates.ToArray(); result.ZRY = (double[])dataset.ZRMarket.ToArray(); return(result); }
/// <summary> /// Attempts to solve the Heston optimization problem using /// <see cref="Heston.HestonOptimizationProblem"/>. /// </summary> /// <param name="marketData">Data to be used in order to perform the optimization.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">IController.</param> /// <returns>The results of the optimization.</returns> public EstimationResult Estimate(List <object> marketData, IEstimationSettings settings = null, IController controller = null, Dictionary <string, object> properties = null) { DateTime t0 = DateTime.Now; var interestDataSet = (CurveMarketData)marketData[0]; CallPriceMarketData callDataSet = (CallPriceMarketData)marketData[1]; EquityCalibrationData equityCalData = new EquityCalibrationData(callDataSet, interestDataSet); var spotPrice = (DVPLI.MarketDataTypes.Scalar)marketData[2]; Setup(equityCalData, settings); var calSettings = settings as HestonCalibrationSettings; // Creates the context. Document doc = new Document(); ProjectROV prj = new ProjectROV(doc); doc.Part.Add(prj); // Optimization problem instance. Vector matBound = new Vector(2); Vector strikeBound = new Vector(2); if (calSettings != null) { matBound[0] = calSettings.MinMaturity; matBound[1] = calSettings.MaxMaturity; strikeBound[0] = calSettings.MinStrike; strikeBound[1] = calSettings.MaxStrike; } else { //use defaults matBound[0] = 1.0 / 12; // .25; matBound[1] = 6; // 10; //Up to 6Y maturities strikeBound[0] = 0.4; strikeBound[1] = 1.6; } Console.WriteLine(callDataSet); /* * //CBA TEST * matBound[0] = 1;// .25; * matBound[1] = 3.5;// 10; //Up to 6Y maturities * strikeBound[0] = 0.5;// 0.5; * strikeBound[1] = 2;//1.5; */ HestonCallOptimizationProblem problem = NewOptimizationProblem(equityCalData, matBound, strikeBound); int totalOpts = problem.numCall + problem.numPut; Console.WriteLine("Calibration based on " + totalOpts + " options. (" + problem.numCall + " call options and " + problem.numPut + " put options)."); IOptimizationAlgorithm solver = new QADE(); //IOptimizationAlgorithm solver = new MultiLevelSingleLinkage(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.controller = controller; // If true the optimization algorithm will operate in parallel. o.Parallel = Engine.MultiThread; o.h = 10e-8; o.epsilon = 10e-8; SolutionInfo solution = null; double minObj = double.MaxValue; Vector minX = null; int Z = 1; //if (problem.GetType() == typeof(Heston.HestonCallSimulationOptimizationProblem)) // Z = 2; for (int z = 0; z < Z; z++) { if (solver.GetType() == typeof(MultiLevelSingleLinkage)) { o.NP = 50; o.MaxIter = 25; o.MaxGamma = 6; } else { o.NP = 60; o.MaxIter = 35; } o.Verbosity = 1; Vector x0 = null;// new Vector(new double[] { 0.5, 0.5, 0.8, -0.5, 0.05 }); // GA solution = solver.Minimize(problem, o, x0); if (solution.errors) { return(null); } o.options = "qn"; o.MaxIter = 500;// 1000; if (solution != null) { solution = solver2.Minimize(problem, o, solution.x); } else { solution = solver2.Minimize(problem, o, x0); } if (solution.errors) { return(null); } if (solution.obj < minObj) { minObj = solution.obj; minX = solution.x.Clone(); } } solution.obj = minObj; solution.x = minX; //Displays pricing error structure HestonCallOptimizationProblem.displayObjInfo = true; problem.Obj(solution.x); HestonCallOptimizationProblem.displayObjInfo = false; Console.WriteLine("Calibration Time (s)\t" + (DateTime.Now - t0).TotalSeconds); return(BuildEstimate(spotPrice, interestDataSet, callDataSet, equityCalData, solution)); }
/// <summary> /// Attempts a calibration through <see cref="SwaptionHW1OptimizationProblem"/> /// using swaption matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">The controller which may be used to cancel the process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List<object> data, IEstimationSettings settings = null, IController controller = null, Dictionary<string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; PFunction zr = new PFunction(null); // Loads the zero rate. double[,] zrvalue = (double[,])ArrayHelper.Concat(dataset.ZRMarketDates.ToArray(), dataset.ZRMarket.ToArray()); zr.Expr = zrvalue; double deltak = dataset.SwaptionTenor; var swaptionsFiltering = settings as SwaptionsFiltering; if (swaptionsFiltering == null) swaptionsFiltering = new SwaptionsFiltering();//creates a default int maturitiesCount = dataset.OptionMaturity.Count(x => x >= swaptionsFiltering.MinSwaptionMaturity && x <= swaptionsFiltering.MaxSwaptionMaturity); int durationsCount = dataset.SwapDuration.Count(x => x >= swaptionsFiltering.MinSwapDuration && x <= swaptionsFiltering.MaxSwapDuration); Console.WriteLine(string.Format("Calibrating on {0} swaptions prices [#maturiries x #durations]=[{1} x {2}]", maturitiesCount * durationsCount, maturitiesCount,durationsCount)); if (maturitiesCount * durationsCount == 0) return new EstimationResult("No swaptions satisfying criteria found, please relax filters"); Matrix swaptionsVolatility = new Matrix(maturitiesCount, durationsCount);// dataset.SwaptionsVolatility; Vector optionMaturity = new Vector(maturitiesCount);// dataset.OptionMaturity; Vector swapDuration = new Vector(durationsCount);// dataset.SwapDuration; //Build filtered matrix and vectors int fm=0; for (int m = 0; m < dataset.OptionMaturity.Length; m++) { int fd=0; if (dataset.OptionMaturity[m] >= swaptionsFiltering.MinSwaptionMaturity && dataset.OptionMaturity[m] <= swaptionsFiltering.MaxSwaptionMaturity) { for (int d = 0; d < dataset.SwapDuration.Length; d++) { if (dataset.SwapDuration[d] >= swaptionsFiltering.MinSwapDuration && dataset.SwapDuration[d] <= swaptionsFiltering.MaxSwapDuration) { swaptionsVolatility[fm, fd] = dataset.SwaptionsVolatility[m, d]; swapDuration[fd] = dataset.SwapDuration[d]; fd++; } } optionMaturity[fm] = dataset.OptionMaturity[m]; fm++; } } SwaptionsBlackModel swbm = new SwaptionsBlackModel(zr); Matrix fsr; var blackSwaptionPrice = 1000.0 * swbm.SwaptionsSurfBM(optionMaturity, swapDuration, swaptionsVolatility, deltak, out fsr); Console.WriteLine("SwaptionHWEstimator: Black model prices"); Console.WriteLine(blackSwaptionPrice); SwaptionHW1 swhw1 = new SwaptionHW1(zr); SwaptionHW1OptimizationProblem problem = new SwaptionHW1OptimizationProblem(swhw1, blackSwaptionPrice, optionMaturity, swapDuration, deltak); IOptimizationAlgorithm solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 20; o.MaxIter = 5; o.Verbosity = 1; o.controller = controller; SolutionInfo solution = null; Vector x0 = new Vector(new double[] { 0.1, 0.1 }); solution = solver.Minimize(problem, o, x0); if (solution.errors) return new EstimationResult(solution.message); o.epsilon = 10e-8; o.h = 10e-8; o.MaxIter = 1000; // We can permit this, given it is fast. o.accourate_numerical_derivatives = true; if (solution != null) solution = solver2.Minimize(problem, o, solution.x); else solution = solver2.Minimize(problem, o, x0); if (solution.errors) return new EstimationResult(solution.message); Console.WriteLine("Solution:"); Console.WriteLine(solution); string[] names = new string[] { "Alpha", "Sigma" }; EstimationResult result = new EstimationResult(names, solution.x); result.ZRX = (double[])dataset.ZRMarketDates.ToArray(); result.ZRY = (double[])dataset.ZRMarket.ToArray(); double obj = problem.Obj(solution.x); return result; }
/// <summary> /// Attempts to solve the Heston optimization problem using /// <see cref="Heston.HestonOptimizationProblem"/>. /// </summary> /// <param name="marketData">Data to be used in order to perform the optimization.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">IController.</param> /// <returns>The results of the optimization.</returns> public EstimationResult Estimate(List<object> marketData, IEstimationSettings settings = null, IController controller = null, Dictionary<string, object> properties = null) { DateTime t0 = DateTime.Now; var interestDataSet = (CurveMarketData)marketData[0]; CallPriceMarketData callDataSet = (CallPriceMarketData)marketData[1]; EquityCalibrationData equityCalData = new EquityCalibrationData(callDataSet, interestDataSet); var spotPrice = (DVPLI.MarketDataTypes.Scalar)marketData[2]; Setup(equityCalData, settings); var calSettings = settings as HestonCalibrationSettings; // Creates the context. Document doc = new Document(); ProjectROV prj = new ProjectROV(doc); doc.Part.Add(prj); // Optimization problem instance. Vector matBound = new Vector(2); Vector strikeBound = new Vector(2); if (calSettings != null) { matBound[0] = calSettings.MinMaturity; matBound[1] = calSettings.MaxMaturity; strikeBound[0] = calSettings.MinStrike; strikeBound[1] = calSettings.MaxStrike; } else { //use defaults matBound[0] = 1.0 / 12;// .25; matBound[1] = 6;// 10; //Up to 6Y maturities strikeBound[0] = 0.4; strikeBound[1] = 1.6; } Console.WriteLine(callDataSet); /* //CBA TEST matBound[0] = 1;// .25; matBound[1] = 3.5;// 10; //Up to 6Y maturities strikeBound[0] = 0.5;// 0.5; strikeBound[1] = 2;//1.5; */ HestonCallOptimizationProblem problem = NewOptimizationProblem(equityCalData, matBound, strikeBound); int totalOpts = problem.numCall + problem.numPut; Console.WriteLine("Calibration based on "+totalOpts+ " options. (" + problem.numCall + " call options and "+problem.numPut+" put options)."); IOptimizationAlgorithm solver = new QADE(); //IOptimizationAlgorithm solver = new MultiLevelSingleLinkage(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.controller = controller; // If true the optimization algorithm will operate in parallel. o.Parallel = Engine.MultiThread; o.h = 10e-8; o.epsilon = 10e-8; SolutionInfo solution = null; double minObj=double.MaxValue; Vector minX= null; int Z = 1; //if (problem.GetType() == typeof(Heston.HestonCallSimulationOptimizationProblem)) // Z = 2; for(int z=0;z<Z;z++) { if (solver.GetType() == typeof(MultiLevelSingleLinkage)) { o.NP = 50; o.MaxIter = 25; o.MaxGamma = 6; } else { o.NP = 60; o.MaxIter = 35; } o.Verbosity = 1; Vector x0 = null;// new Vector(new double[] { 0.5, 0.5, 0.8, -0.5, 0.05 }); // GA solution = solver.Minimize(problem, o, x0); if (solution.errors) return null; o.options = "qn"; o.MaxIter = 500;// 1000; if (solution != null) solution = solver2.Minimize(problem, o, solution.x); else { solution = solver2.Minimize(problem, o, x0); } if (solution.errors) return null; if (solution.obj < minObj) { minObj = solution.obj; minX = solution.x.Clone(); } } solution.obj = minObj; solution.x = minX; //Displays pricing error structure HestonCallOptimizationProblem.displayObjInfo = true; problem.Obj(solution.x); HestonCallOptimizationProblem.displayObjInfo = false; Console.WriteLine("Calibration Time (s)\t" + (DateTime.Now - t0).TotalSeconds); return BuildEstimate(spotPrice,interestDataSet, callDataSet, equityCalData, solution); }
/// <summary> /// Attempts a calibration through <see cref="PelsserCappletOptimizationProblem"/> /// using caps matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">The controller which may be used to cancel the process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List<object> data, IEstimationSettings settings = null, IController controller = null, Dictionary<string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; EstimationResult result; if ((dataset.ZRMarket == null) || (dataset.CapVolatility == null)) { result = new EstimationResult(); result.ErrorMessage = "Not enough data to calibrate.\n" + "The estimator needs a ZRMarket and a CapVolatility " + "defined inside InterestRateMarketData"; return result; } // Backup the dates DateTime effectiveDate = DateTime.Now.Date; DateTime valuationDate = DateTime.Now.Date; if (Document.ActiveDocument != null) { effectiveDate = Document.ActiveDocument.ContractDate; valuationDate = Document.ActiveDocument.SimulationStartDate; } // Creates the Context. Document doc = new Document(); ProjectROV prj = new ProjectROV(doc); doc.Part.Add(prj); Function zr = new PFunction(null); zr.VarName = "zr"; // Load the zr. double[,] zrvalue = (double[,])ArrayHelper.Concat(dataset.ZRMarketDates.ToArray(), dataset.ZRMarket.ToArray()); zr.Expr = zrvalue; prj.Symbols.Add(zr); BlackModel bm = new BlackModel(zr); double deltak = dataset.CapTenor; Matrix capVol = dataset.CapVolatility; Vector capMat = dataset.CapMaturity; Vector capK = dataset.CapRate; var preferences = settings as Fairmat.Calibration.CapVolatilityFiltering; // Matrix calculated with black. Matrix blackCaps = new Matrix(capMat.Length, capK.Length); for (int m = 0; m < capMat.Length; m++) { for (int s = 0; s < capK.Length; s++) { bool skip = false; if (preferences != null) { if (capK[s] < preferences.MinCapRate || capK[s] > preferences.MaxCapRate || capMat[m] < preferences.MinCapMaturity || capMat[m] > preferences.MaxCapMaturity) {skip = true; } } if (capVol[m, s] == 0 || skip) blackCaps[m, s] = 0; else blackCaps[m, s] = bm.Cap(capK[s], capVol[m, s], deltak, capMat[m]); } } if (blackCaps.IsNAN()) { Console.WriteLine("Black caps matrix has non real values:"); Console.WriteLine(blackCaps); throw new Exception("Cannot calculate Black caps"); } // Maturity goes from 0 to the last item with step deltaK. Vector maturity = new Vector((int)(1.0 + capMat[capMat.Length - 1] / deltak)); for (int l = 0; l < maturity.Length; l++) maturity[l] = deltak * l; Vector fwd = new Vector(maturity.Length - 1); for (int i = 0; i < fwd.Length; i++) { fwd[i] = bm.Fk(maturity[i + 1], deltak); } // Creates a default Pelsser model. Pelsser.SquaredGaussianModel model = new Pelsser.SquaredGaussianModel(); model.a1 = (ModelParameter)0.014; model.sigma1 = (ModelParameter)0.001; model.zr = (ModelParameter)"@zr"; StochasticProcessExtendible iex = new StochasticProcessExtendible(prj, model); prj.Processes.AddProcess(iex); prj.Parse(); DateTime t0 = DateTime.Now; Caplet cp = new Caplet(); PelsserCappletOptimizationProblem problem = new PelsserCappletOptimizationProblem(prj, cp, maturity, fwd, capK, deltak, capMat, blackCaps); IOptimizationAlgorithm solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 35; o.TargetCost = 0.0025; o.MaxIter = 10; o.Verbosity = Math.Max(1, Engine.Verbose); o.controller = controller; // Parallel evaluation is not supported for this calibration. o.Parallel = false; o.Debug = true; SolutionInfo solution = null; Vector x0 = (Vector)new double[] { 0.1, 0.1 }; solution = solver.Minimize(problem, o, x0); if (solution.errors) return new EstimationResult(solution.message); o.epsilon = 10e-7; o.h = 10e-7; o.MaxIter = 1000; o.Debug = true; o.Verbosity = Math.Max(1, Engine.Verbose); if (solution != null) solution = solver2.Minimize(problem, o, solution.x); else solution = solver2.Minimize(problem, o, x0); if (solution.errors) return new EstimationResult(solution.message); Console.WriteLine(solution); string[] names = new string[] { "alpha1", "sigma1" }; result = new EstimationResult(names, solution.x); result.ZRX = (double[])dataset.ZRMarketDates.ToArray(); result.ZRY = (double[])dataset.ZRMarket.ToArray(); result.Objects = new object[1]; result.Objects[0] = solution.obj; //result.Fit = solution.obj;//Uncomment in 1.6 // Restore the dates if (Document.ActiveDocument != null) { Document.ActiveDocument.ContractDate = effectiveDate; Document.ActiveDocument.SimulationStartDate = valuationDate; } return result; }
/// <summary> /// Attempts a calibration through <see cref="CapsCIROptimizationProblem"/> /// using caps matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">A controller used for the optimization process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List<object> data, IEstimationSettings settings = null, IController controller = null, Dictionary<string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; // Creates the context. Document doc = new Document(); ProjectROV prj = new ProjectROV(doc); doc.Part.Add(prj); CapCIROptimizationProblem problem = new CapCIROptimizationProblem(dataset); IOptimizationAlgorithm solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 50; o.MaxIter = 50; o.Verbosity = 1; o.Parallel = false; o.controller = controller; SolutionInfo solution = null; Vector x0 = new Vector(new double[] { 1, 0.01, 0.05 }); solution = solver.Minimize(problem, o, x0); if (solution.errors) return new EstimationResult(solution.message); o.epsilon = 10e-10; o.h = 10e-10; o.MaxIter = 1000; if (solution != null) solution = solver2.Minimize(problem, o, solution.x); else solution = solver2.Minimize(problem, o, x0); if (solution.errors) return new EstimationResult(solution.message); Console.WriteLine("Solution:"); Console.WriteLine(solution); string[] names = CIR.parameterNames; Vector values = new Vector(4); values[Range.New(0, 2)] = solution.x; values[3] = problem.r0; EstimationResult result = new EstimationResult(names, values); return result; }
/// <summary> /// Attempts a calibration through <see cref="CapsCIROptimizationProblem"/> /// using caps matrices. /// </summary> /// <param name="data">The data to be used in order to perform the calibration.</param> /// <param name="settings">The parameter is not used.</param> /// <param name="controller">A controller used for the optimization process.</param> /// <returns>The results of the calibration.</returns> public EstimationResult Estimate(List <object> data, IEstimationSettings settings = null, IController controller = null, Dictionary <string, object> properties = null) { InterestRateMarketData dataset = data[0] as InterestRateMarketData; // Creates the context. Document doc = new Document(); ProjectROV prj = new ProjectROV(doc); doc.Part.Add(prj); CapCIROptimizationProblem problem = new CapCIROptimizationProblem(dataset); IOptimizationAlgorithm solver = new QADE(); IOptimizationAlgorithm solver2 = new SteepestDescent(); DESettings o = new DESettings(); o.NP = 50; o.MaxIter = 50; o.Verbosity = 1; o.Parallel = false; o.controller = controller; SolutionInfo solution = null; Vector x0 = new Vector(new double[] { 1, 0.01, 0.05 }); solution = solver.Minimize(problem, o, x0); if (solution.errors) { return(new EstimationResult(solution.message)); } o.epsilon = 10e-10; o.h = 10e-10; o.MaxIter = 1000; if (solution != null) { solution = solver2.Minimize(problem, o, solution.x); } else { solution = solver2.Minimize(problem, o, x0); } if (solution.errors) { return(new EstimationResult(solution.message)); } Console.WriteLine("Solution:"); Console.WriteLine(solution); string[] names = CIR.parameterNames; Vector values = new Vector(4); values[Range.New(0, 2)] = solution.x; values[3] = problem.r0; EstimationResult result = new EstimationResult(names, values); return(result); }
private static void Main() { Parameters.Verbosity = VerbosityLevels.AboveNormal; // this next line is to set the Debug statements from OOOT to the Console. Debug.Listeners.Add(new TextWriterTraceListener(Console.Out)); /* In this example, we first present how the details of an optimzation * problem can be saved to an XML-file so that it can be read in * and solved as opposed to defining all the details in an imperative * (code line by code line) way. In the first function, the xml file * name "test1.xml" is created. */ makeAndSaveProblemDefinition(); /* now we create a series of different optimization methods and test * them on the problem. The problem is now opened from the file and * the details are stored in an object of class "Problem Definition".*/ var stream = new FileStream(filename, FileMode.Open); ProblemDefinition probTest1 = ProblemDefinition.OpenprobFromXml(stream); abstractOptMethod opty; /***********Gradient Based Optimization with Steepest Descent****************/ SearchIO.output("***********Gradient Based Optimization with Steepest Descent****************"); opty = new GradientBasedOptimization(); opty.Add(probTest1); abstractSearchDirection searchDirMethod = new SteepestDescent(); opty.Add(searchDirMethod); //abstractLineSearch lineSearchMethod = new ArithmeticMean(0.0001, 1, 100); //abstractLineSearch lineSearchMethod = new DSCPowell(0.0001, 1, 100); abstractLineSearch lineSearchMethod = new GoldenSection(0.0001, 1); opty.Add(lineSearchMethod); opty.Add(new squaredExteriorPenalty(opty, 10)); /* since this is not a population-based optimization method, we need to remove the MaxSpan criteria. */ opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence); double[] xStar; var timer = Stopwatch.StartNew(); var fStar = opty.Run(out xStar); printResults(opty, xStar, fStar, timer); /***********Gradient Based Optimization with Fletcher-Reeves****************/ SearchIO.output("***********Gradient Based Optimization with Fletcher-Reeves****************"); /* we don't need to reset (invoke the constructor) for GradientBasedOptimization since we are only * change the seaach direction method. */ searchDirMethod = new FletcherReevesDirection(); /* you could also try the remaining 3 search direction methods. */ //searchDirMethod = new CyclicCoordinates(); //searchDirMethod = new BFGSDirection(); //searchDirMethod = new PowellMethod(0.001, 6); opty.Add(searchDirMethod); timer = Stopwatch.StartNew(); opty.ResetFunctionEvaluationDatabase(); fStar = opty.Run(out xStar); printResults(opty, xStar, fStar, timer); /******************Generalized Reduced Gradient***********************/ SearchIO.output("******************Generalized Reduced Gradient***********************"); opty = new GeneralizedReducedGradientActiveSet(); opty.Add(probTest1); opty.Add(new squaredExteriorPenalty(opty, 10)); opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence); timer = Stopwatch.StartNew(); fStar = opty.Run(out xStar); printResults(opty, xStar, fStar, timer); /* GRG is the ONLY one here that handles constraints explicity. It find the * optimal very quickly and accurately. However, many of the other show a * better value of f*, this is because they are using an imperfect penalty * function (new squaredExteriorPenalty(opty, 10)). While it seems that GRG * includes it as well, it is only used in the the line search method. */ /******************Random Hill Climbing ***********************/ SearchIO.output("******************Random Hill Climbing ***********************"); opty = new HillClimbing(); opty.Add(probTest1); opty.Add(new squaredExteriorPenalty(opty, 8)); opty.Add(new RandomNeighborGenerator(probTest1.SpaceDescriptor)); opty.Add(new KeepSingleBest(optimize.minimize)); opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence); /* the deltaX convergence needs to be removed as well, since RHC will end many iterations * at the same point it started. */ opty.ConvergenceMethods.RemoveAll(a => a is DeltaXConvergence); timer = Stopwatch.StartNew(); fStar = opty.Run(out xStar); printResults(opty, xStar, fStar, timer); /******************Exhaustive Hill Climbing ***********************/ SearchIO.output("******************Exhaustive Hill Climbing ***********************"); /* Everything else about the Random Hill Climbing stays the same. */ opty.Add(new ExhaustiveNeighborGenerator(probTest1.SpaceDescriptor)); timer = Stopwatch.StartNew(); fStar = opty.Run(out xStar); printResults(opty, xStar, fStar, timer); /******************Simulated Annealing***********************/ SearchIO.output("******************Simulated Annealing***********************"); opty = new SimulatedAnnealing(optimize.minimize); opty.Add(probTest1); opty.Add(new squaredExteriorPenalty(opty, 10)); opty.Add(new RandomNeighborGenerator(probTest1.SpaceDescriptor, 100)); opty.Add(new SACoolingSangiovanniVincentelli(100)); opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence); /* the deltaX convergence needs to be removed as well, since RHC will end many iterations * at the same point it started. */ opty.ConvergenceMethods.RemoveAll(a => a is DeltaXConvergence); timer = Stopwatch.StartNew(); fStar = opty.Run(out xStar); printResults(opty, xStar, fStar, timer); /******************Exhaustive Search ***********************/ // SearchIO.output("******************Exhaustive Search ***********************"); //opty = new ExhaustiveSearch(probTest1.SpaceDescriptor, optimize.minimize); //opty.Add(probTest1); /* No convergence criteria is needed as the process concludes when all * states have been visited but for this problem that is 4 trillion states.*/ //opty.ConvergenceMethods.Clear(); /* if you DID KNOW the best, you can include a criteria like...*/ //opty.ConvergenceMethods.Add(new ToKnownBestXConvergence(new[] { 3.0, 3.0 }, 0.0000001)); //timer = Stopwatch.StartNew(); //fStar = opty.Run(out xStar); /* you probably will never see this process complete. Even with the added * convergence criteria (which is not factored into the estimated time of * completion), you are probably looking at 1 to 2 years. */ //printResults(opty, xStar, fStar, timer); }