public MissionTimer(StartCriteria startCriteria, EndCriteria endCriteria, string startParameter, string endParameter, string title) : base(title) { this.startCriteria = startCriteria; this.endCriteria = endCriteria; this.startParameter = startParameter; this.endParameter = endParameter; disableOnStateChange = false; checker = new ContractChecker(this); }
public virtual void calibrate(CalibrationHelperVector arg0, OptimizationMethod arg1, EndCriteria arg2) { NQuantLibcPINVOKE.CalibratedModel_calibrate__SWIG_3(swigCPtr, CalibrationHelperVector.getCPtr(arg0), OptimizationMethod.getCPtr(arg1), EndCriteria.getCPtr(arg2)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public virtual void calibrate(CalibrationHelperVector arg0, OptimizationMethod arg1, EndCriteria arg2, Constraint constraint, DoubleVector weights) { NQuantLibcPINVOKE.CalibratedModel_calibrate__SWIG_1(swigCPtr, CalibrationHelperVector.getCPtr(arg0), OptimizationMethod.getCPtr(arg1), EndCriteria.getCPtr(arg2), Constraint.getCPtr(constraint), DoubleVector.getCPtr(weights)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public void testCachedHullWhite() { //("Testing Hull-White calibration against cached values..."); Date today = new Date(15, Month.February, 2002); Date settlement = new Date(19, Month.February, 2002); Settings.setEvaluationDate(today); Handle <YieldTermStructure> termStructure = new Handle <YieldTermStructure>(Utilities.flatRate(settlement, 0.04875825, new Actual365Fixed())); //termStructure.link HullWhite model = new HullWhite(termStructure); CalibrationData[] data = { new CalibrationData(1, 5, 0.1148), new CalibrationData(2, 4, 0.1108), new CalibrationData(3, 3, 0.1070), new CalibrationData(4, 2, 0.1021), new CalibrationData(5, 1, 0.1000) }; IborIndex index = new Euribor6M(termStructure); IPricingEngine engine = new JamshidianSwaptionEngine(model); List <CalibrationHelper> swaptions = new List <CalibrationHelper>(); for (int i = 0; i < data.Length; i++) { Quote vol = new SimpleQuote(data[i].volatility); CalibrationHelper helper = new SwaptionHelper(new Period(data[i].start, TimeUnit.Years), new Period(data[i].length, TimeUnit.Years), new Handle <Quote>(vol), index, new Period(1, TimeUnit.Years), new Thirty360(), new Actual360(), termStructure); helper.setPricingEngine(engine); swaptions.Add(helper); } // Set up the optimization problem // Real simplexLambda = 0.1; // Simplex optimizationMethod(simplexLambda); LevenbergMarquardt optimizationMethod = new LevenbergMarquardt(1.0e-8, 1.0e-8, 1.0e-8); EndCriteria endCriteria = new EndCriteria(10000, 100, 1e-6, 1e-8, 1e-8); //Optimize model.calibrate(swaptions, optimizationMethod, endCriteria, new Constraint(), new List <double>()); EndCriteria.Type ecType = model.endCriteria(); // Check and print out results #if QL_USE_INDEXED_COUPON double cachedA = 0.0488199, cachedSigma = 0.00593579; #else double cachedA = 0.0488565, cachedSigma = 0.00593662; #endif double tolerance = 1.120e-5; //double tolerance = 1.0e-6; Vector xMinCalculated = model.parameters(); double yMinCalculated = model.value(xMinCalculated, swaptions); Vector xMinExpected = new Vector(2); xMinExpected[0] = cachedA; xMinExpected[1] = cachedSigma; double yMinExpected = model.value(xMinExpected, swaptions); if (Math.Abs(xMinCalculated[0] - cachedA) > tolerance || Math.Abs(xMinCalculated[1] - cachedSigma) > tolerance) { QAssert.Fail("Failed to reproduce cached calibration results:\n" + "calculated: a = " + xMinCalculated[0] + ", " + "sigma = " + xMinCalculated[1] + ", " + "f(a) = " + yMinCalculated + ",\n" + "expected: a = " + xMinExpected[0] + ", " + "sigma = " + xMinExpected[1] + ", " + "f(a) = " + yMinExpected + ",\n" + "difference: a = " + (xMinCalculated[0] - xMinExpected[0]) + ", " + "sigma = " + (xMinCalculated[1] - xMinExpected[1]) + ", " + "f(a) = " + (yMinCalculated - yMinExpected) + ",\n" + "end criteria = " + ecType); } }
public void calibrate(CalibrationHelperVector helper, OptimizationMethod method, EndCriteria endCriteria) { NQuantLibcPINVOKE.MarkovFunctional_calibrate__SWIG_3(swigCPtr, CalibrationHelperVector.getCPtr(helper), OptimizationMethod.getCPtr(method), EndCriteria.getCPtr(endCriteria)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public void calibrate(CalibrationHelperVector instruments, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint, DoubleVector weights, BoolVector fixParameters) { NQuantLibcPINVOKE.Gsr_calibrate__SWIG_0(swigCPtr, CalibrationHelperVector.getCPtr(instruments), OptimizationMethod.getCPtr(method), EndCriteria.getCPtr(endCriteria), Constraint.getCPtr(constraint), DoubleVector.getCPtr(weights), BoolVector.getCPtr(fixParameters)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public void calibrate(CalibrationHelperVector arg0, OptimizationMethod arg1, EndCriteria arg2) { NQuantLibcPINVOKE.ShortRateModelHandle_calibrate__SWIG_2(swigCPtr, CalibrationHelperVector.getCPtr(arg0), OptimizationMethod.getCPtr(arg1), EndCriteria.getCPtr(arg2)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); }
public SVIInterpolation(QlArray x, QlArray y, double expiry, double forward, double a, double b, double rho, double m, double sigma, EndCriteria endCriteria, OptimizationMethod optimizationMethod) : this(NQuantLibcPINVOKE.new_SVIInterpolation__SWIG_1(QlArray.getCPtr(x), QlArray.getCPtr(y), expiry, forward, a, b, rho, m, sigma, EndCriteria.getCPtr(endCriteria), OptimizationMethod.getCPtr(optimizationMethod)), true) { if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public void calibrate(CalibrationHelperVector arg0, OptimizationMethod arg1, EndCriteria arg2, Constraint constraint) { NQuantLibcPINVOKE.ShortRateModelHandle_calibrate__SWIG_2(swigCPtr, CalibrationHelperVector.getCPtr(arg0), OptimizationMethod.getCPtr(arg1), EndCriteria.getCPtr(arg2), Constraint.getCPtr(constraint)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public void calibrateVolatilitiesIterative(CalibrationHelperVector helpers, OptimizationMethod method, EndCriteria endCriteria) { NQuantLibcPINVOKE.Gsr_calibrateVolatilitiesIterative__SWIG_2(swigCPtr, CalibrationHelperVector.getCPtr(helpers), OptimizationMethod.getCPtr(method), EndCriteria.getCPtr(endCriteria)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public void calibrateVolatilitiesIterative(CalibrationHelperVector helpers, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint, DoubleVector weights) { NQuantLibcPINVOKE.Gsr_calibrateVolatilitiesIterative__SWIG_0(swigCPtr, CalibrationHelperVector.getCPtr(helpers), OptimizationMethod.getCPtr(method), EndCriteria.getCPtr(endCriteria), Constraint.getCPtr(constraint), DoubleVector.getCPtr(weights)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public QlArray solve(CostFunctionDelegate function, Constraint c, OptimizationMethod m, EndCriteria e, QlArray iv) { QlArray ret = new QlArray(NQuantLibcPINVOKE.Optimizer_solve(swigCPtr, CostFunctionDelegate.getCPtr(function), Constraint.getCPtr(c), OptimizationMethod.getCPtr(m), EndCriteria.getCPtr(e), QlArray.getCPtr(iv)), true); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public SABRInterpolation(QlArray x, QlArray y, double expiry, double forward, double alpha, double beta, double volvol, double rho, EndCriteria endCriteria, OptimizationMethod optimizationMethod) : this(NQuantLibcPINVOKE.new_SABRInterpolation__SWIG_5(QlArray.getCPtr(x), QlArray.getCPtr(y), expiry, forward, alpha, beta, volvol, rho, EndCriteria.getCPtr(endCriteria), OptimizationMethod.getCPtr(optimizationMethod)), true) { if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EndCriteria obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public void calibrate(CalibrationHelperVector instruments, OptimizationMethod method, EndCriteria endCriteria) { NQuantLibcPINVOKE.Gsr_calibrate__SWIG_3(swigCPtr, CalibrationHelperVector.getCPtr(instruments), OptimizationMethod.getCPtr(method), EndCriteria.getCPtr(endCriteria)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
public void calibrate(CalibrationHelperVector arg0, OptimizationMethod arg1, EndCriteria arg2, Constraint constraint) { NQuantLibcPINVOKE.CalibratedModel_calibrate__SWIG_1(swigCPtr, CalibrationHelperVector.getCPtr(arg0), OptimizationMethod.getCPtr(arg1), EndCriteria.getCPtr(arg2), Constraint.getCPtr(constraint)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); }
public static string eqModelSVI( [ExcelArgument(Description = "id of option to be constructed ")] string ObjectId, [ExcelArgument(Description = "ATM forward ")] double forward, [ExcelArgument(Description = "expiry (years of fraction ")] double tenor, [ExcelArgument(Description = "Strikes ")] double[] strikes, [ExcelArgument(Description = "implied vols ")] double[] volatilities, [ExcelArgument(Description = "initial parameters ")] double[] initials, [ExcelArgument(Description = "trigger ")] object trigger) { if (ExcelUtil.CallFromWizard()) { return(""); } string callerAddress = ""; callerAddress = ExcelUtil.getActiveCellAddress(); try { if (strikes.Length != volatilities.Length) { throw new Exception("SABR input lengths don't match."); } if (initials.Length != 5) { throw new Exception("SVI has five parameters."); } int[] idx = volatilities.Select((v, Index) => new { V = v, idx = Index }) .Where(x => x.V == 0) .Select(x => x.idx) .ToArray(); QlArray xx = new QlArray((uint)strikes.Length - (uint)idx.Length); QlArray yy = new QlArray((uint)volatilities.Length - (uint)idx.Length); for (uint i = 0, j = 0; i < strikes.Length; i++) { if (volatilities[i] == 0) // empty { continue; } xx.set(j, strikes[i]); yy.set(j, volatilities[i]); j++; } EndCriteria endcriteria = new EndCriteria(100000, 100, 1e-8, 1e-8, 1e-8); OptimizationMethod opmodel = new Simplex(0.01); // alpha: ATM Vol, beta: CEV param, rho: underlying/vol correlation, nu: vol of vol SVIInterpolation svi = new SVIInterpolation(xx, yy, tenor, forward, initials[0], initials[1], initials[2], initials[3], initials[4], endcriteria, opmodel, true); double err = 0; err = svi.update(); // Store the option and return its id string id = "MODEL@" + ObjectId; OHRepository.Instance.storeObject(id, svi, callerAddress); id += "#" + (String)DateTime.Now.ToString(@"HH:mm:ss"); return(id); } catch (Exception e) { ExcelUtil.logError(callerAddress, System.Reflection.MethodInfo.GetCurrentMethod().Name.ToString(), e.Message); return(e.Message); } }
protected override void OnParameterLoad(ConfigNode node) { startCriteria = ConfigNodeUtil.ParseValue<StartCriteria>(node, "startCriteria"); endCriteria = ConfigNodeUtil.ParseValue<EndCriteria>(node, "endCriteria"); startParameter = ConfigNodeUtil.ParseValue<string>(node, "startParameter", ""); endParameter = ConfigNodeUtil.ParseValue<string>(node, "endParameter", ""); startTime = Convert.ToDouble(node.GetValue("startTime")); endTime = Convert.ToDouble(node.GetValue("endTime")); if (Root.ContractState == Contract.State.Active || Root.ContractState == Contract.State.Offered) { checker = new ContractChecker(this); } }
public void calibrate(CalibrationHelperVector arg0, OptimizationMethod arg1, EndCriteria arg2, Constraint constraint, DoubleVector weights) { NQuantLibcPINVOKE.ShortRateModelHandle_calibrate__SWIG_0(swigCPtr, CalibrationHelperVector.getCPtr(arg0), OptimizationMethod.getCPtr(arg1), EndCriteria.getCPtr(arg2), Constraint.getCPtr(constraint), DoubleVector.getCPtr(weights)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); }
public void calibrate(CalibrationHelperVector helper, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint, DoubleVector weights) { NQuantLibcPINVOKE.MarkovFunctional_calibrate__SWIG_1(swigCPtr, CalibrationHelperVector.getCPtr(helper), OptimizationMethod.getCPtr(method), EndCriteria.getCPtr(endCriteria), Constraint.getCPtr(constraint), DoubleVector.getCPtr(weights)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EndCriteria obj) { return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; }
//! Perform line search public override double value(Problem P, // Optimization problem ref EndCriteria.Type ecType, EndCriteria endCriteria, double t_ini) // initial value of line-search step { Constraint constraint = P.constraint(); succeed_ = true; bool maxIter = false; double t = t_ini; int loopNumber = 0; double q0 = P.functionValue(); double qp0 = P.gradientNormValue(); double tl = 0.0; double tr = 0.0; qt_ = q0; qpt_ = (gradient_.empty()) ? qp0 : -Vector.DotProduct(gradient_, searchDirection_); // Initialize gradient gradient_ = new Vector(P.currentValue().size()); // Compute new point xtd_ = P.currentValue(); t = update(ref xtd_, searchDirection_, t, constraint); // Compute function value at the new point qt_ = P.value(xtd_); while ((qt_ - q0) < -beta_ * t * qpt_ || (qt_ - q0) > -alpha_ * t * qpt_) { if ((qt_ - q0) > -alpha_ * t * qpt_) { tr = t; } else { tl = t; } ++loopNumber; // calculate the new step if (Utils.close_enough(tr, 0.0)) { t *= extrapolation_; } else { t = (tl + tr) / 2.0; } // New point value xtd_ = P.currentValue(); t = update(ref xtd_, searchDirection_, t, constraint); // Compute function value at the new point qt_ = P.value(xtd_); P.gradient(ref gradient_, xtd_); // and it squared norm maxIter = endCriteria.checkMaxIterations(loopNumber, ref ecType); if (maxIter) { break; } } if (maxIter) { succeed_ = false; } // Compute new gradient P.gradient(ref gradient_, xtd_); // and it squared norm qpt_ = Vector.DotProduct(gradient_, gradient_); // Return new step value return(t); }