static void CalibrateModel(ShortRateModel model,
List <CalibrationHelper> helpers)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var om = new LevenbergMarquardt();
model.calibrate(helpers, om,
new EndCriteria(400, 100, 1.0e-8, 1.0e-8, 1.0e-8), new Constraint(),
new List <double>());
// Output the implied Black volatilities
for (int i = 0; i < NumRows; i++)
{
int j = NumCols - i - 1; // 1x5, 2x4, 3x3, 4x2, 5x1
int k = i * NumCols + j;
double npv = helpers[i].modelValue();
double implied = helpers[i].impliedVolatility(npv, 1e-4,
1000, 0.05, 0.50);
double diff = implied - SwaptionVols[k];
Console.WriteLine("{0}x{1}: model {2:0.00000 %}, market {3:0.00000 %}, diff {4:0.00000 %} ",
i + 1, SwapLenghts[j], implied, SwaptionVols[k], diff);
}
}
public DVPLI.EstimationResult Estimate(List <object> data, DVPLI.IEstimationSettings settings = null, DVPLI.IController controller = null, Dictionary <string, object> properties = null)
{
DVPLI.InterestRateMarketData irmd = data[0] as DVPLI.InterestRateMarketData;
//Date today = new Date(15, Month.February, 2002);
//Date settlement = new Date(19, Month.February, 2002);
Settings.setEvaluationDate(irmd.Date);
Handle <YieldTermStructure> termStructure = new Handle <YieldTermStructure>(new Utilities.ZeroRateFunction(irmd.Date, irmd.ZRMarketDates, irmd.ZRMarket));
//termStructure.link
HullWhite model = new HullWhite(termStructure);
IborIndex index = new Euribor6M(termStructure);
IPricingEngine engine = new JamshidianSwaptionEngine(model);
List <CalibrationHelper> swaptions = new List <CalibrationHelper>();
for (int i = 0; i < irmd.SwapDates.Length; i++)
{
for (int j = 0; j < irmd.SwapDuration.Length; j++)
{
Quote vol = new SimpleQuote(irmd.SwaptionsVolatility[j, i]);
CalibrationHelper helper =
new SwaptionHelper(new Period((int)irmd.SwapDates[i], TimeUnit.Years),
new Period((int)irmd.SwapDuration[j], TimeUnit.Years),
new Handle <Quote>(vol),
index,
new Period(1, TimeUnit.Years),
new Thirty360(),
new Actual360(),
termStructure,
false);
helper.setPricingEngine(engine);
swaptions.Add(helper);
}
}
// Set up the optimization problem
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();
Vector xMinCalculated = model.parameters();
double yMinCalculated = model.value(xMinCalculated, swaptions);
Vector xMinExpected = new Vector(2);
double yMinExpected = model.value(xMinExpected, swaptions);
DVPLI.EstimationResult r = new DVPLI.EstimationResult(new string[] { "Alpha", "Sigma" }, new double[] { xMinCalculated[0], xMinCalculated[1] });
return(r);
}
public void minimize_test()
{
#region doc_minimize
// Example from https://en.wikipedia.org/wiki/Gauss%E2%80%93Newton_algorithm
// In this example, the Gauss–Newton algorithm will be used to fit a model to
// some data by minimizing the sum of squares of errors between the data and
// model's predictions.
// In a biology experiment studying the relation between substrate concentration [S]
// and reaction rate in an enzyme-mediated reaction, the data in the following table
// were obtained:
double[][] inputs = Jagged.ColumnVector(new [] { 0.03, 0.1947, 0.425, 0.626, 1.253, 2.500, 3.740 });
double[] outputs = new[] { 0.05, 0.127, 0.094, 0.2122, 0.2729, 0.2665, 0.3317 };
// It is desired to find a curve (model function) of the form
//
// rate = \frac{V_{max}[S]}{K_M+[S]}
//
// that fits best the data in the least squares sense, with the parameters V_max
// and K_M to be determined. Let's start by writing model equation below:
LeastSquaresFunction function = (double[] parameters, double[] input) =>
{
return((parameters[0] * input[0]) / (parameters[1] + input[0]));
};
// Now, we can either write the gradient function of the model by hand or let
// the model compute it automatically using Newton's finite differences method:
LeastSquaresGradientFunction gradient = (double[] parameters, double[] input, double[] result) =>
{
result[0] = -((-input[0]) / (parameters[1] + input[0]));
result[1] = -((parameters[0] * input[0]) / Math.Pow(parameters[1] + input[0], 2));
};
// Create a new Levenberg-Marquardt algorithm
var gn = new LevenbergMarquardt(parameters: 2)
{
Function = function,
Gradient = gradient,
Solution = new[] { 0.9, 0.2 } // starting from b1 = 0.9 and b2 = 0.2
};
// Find the minimum value:
gn.Minimize(inputs, outputs);
// The solution will be at:
double b1 = gn.Solution[0]; // will be 0.362
double b2 = gn.Solution[1]; // will be 0.556
#endregion
Assert.AreEqual(0.362, b1, 1e-3);
Assert.AreEqual(0.556, b2, 3e-3);
}
public void nestedOptimizationTest()
{
//("Testing nested optimizations...");
OptimizationBasedCostFunction optimizationBasedCostFunction = new OptimizationBasedCostFunction();
NoConstraint constraint = new NoConstraint();
Vector initialValues = new Vector(1, 0.0);
Problem problem = new Problem(optimizationBasedCostFunction, constraint, initialValues);
LevenbergMarquardt optimizationMethod = new LevenbergMarquardt();
//Simplex optimizationMethod(0.1);
//ConjugateGradient optimizationMethod;
//SteepestDescent optimizationMethod;
EndCriteria endCriteria = new EndCriteria(1000, 100, 1e-5, 1e-5, 1e-5);
optimizationMethod.minimize(problem, endCriteria);
}
public void misra1a_test()
{
LevenbergMarquardt lm = new LevenbergMarquardt(2);
double[] outputs = new double[] { 10.07E0, 14.73E0, 17.94E0, 23.93E0, 29.61E0, 35.18E0, 40.02E0, 44.82E0, 50.76E0, 55.05E0, 61.01E0, 66.40E0, 75.47E0, 81.78E0 };
double[][] inputs = Jagged.ColumnVector(77.6E0, 114.9E0, 141.1E0, 190.8E0, 239.9E0, 289.0E0, 332.8E0, 378.4E0, 434.8E0, 477.3E0, 536.8E0, 593.1E0, 689.1E0, 760.0E0);
lm.Function = Function;
lm.Gradient = Gradient;
lm.Solution = new double[] { 250, 0.0005 }; // starting values
double error = lm.Minimize(inputs, outputs);
Assert.AreEqual(238.944658680792, lm.Solution[0], 1e-5);
Assert.AreEqual(0.00055014847409921093, lm.Solution[1], 1e-5);
}
public void TestOptimization()
{
// generate x_i, y_i observations on test function
var random = new Random();
int n = 200;
var matX = Vector <double> .Build.Dense(n);
var matY = Vector <double> .Build.Dense(n);
double a = 100;
double b = 102;
for (int i = 0; i < n; i++)
{
double x = (random.NextDouble() / (Math.PI / 4.0)) - (Math.PI / 8.0);
double y = (a * Math.Cos(b * x)) + (b * Math.Sin(a * x)) + (random.NextDouble() * 0.1);
matX[i] = x;
matY[i] = y;
}
LevenbergMarquardt.Function f = (Vector <double> parameters) =>
{
// return y_i - f(x_i, parameters) as column vector
var error = Vector <double> .Build.Dense(n);
double a2 = parameters[0];
double b2 = parameters[1];
for (int i = 0; i < n; i++)
{
double y = (a2 * Math.Cos(b2 * matX[i])) + (b2 * Math.Sin(a2 * matX[i]));
error[i] = matY[i] - y;
}
return(error);
};
var levenbergMarquardt = new LevenbergMarquardt(f);
var parameters0 = Vector <double> .Build.Dense(2);
parameters0[0] = 90;
parameters0[1] = 96;
var rmsError = levenbergMarquardt.Minimize(parameters0);
}
private WcsSolution SolveLM()
{
Vector2d temp = Points[0].Image - Points[1].Image;
double imageLength = temp.Length;
double angularSperation = CAAAngularSeparation.Separation(Points[0].Celestial.RA, Points[0].Celestial.Dec, Points[1].Celestial.RA, Points[1].Celestial.Dec);
// Degrees per pixel
double scale = angularSperation / imageLength;
WcsSolution sinit = Solve(Points[0], Points[1]);
TanSolver ts = new TanSolver(sinit.CenterX, sinit.CenterY, sinit.Rotation - 180, sinit.Scale);
foreach (CorresponencePoint cp in Points)
{
SolveList.Add(new CoorespondenceSolver(ts, cp, width, height));
}
regressionParameters.AddRange(ts.Parameters);
int count = SolveList.Count;
double[,] data = new double[2, count];
for (int i = 0; i < count; i++)
{
data[0, i] = i;
data[1, i] = 0;
}
Parameter[] observed = new Parameter[] { ParmeterIndex };
lm = new LevenbergMarquardt(new functionDelegate(SolveFunction), regressionParameters.ToArray(), observed, data);
for (int d = 0; d < 50; d++)
{
lm.Iterate();
}
WcsSolution s = ts.GetSolution();
s.OffsetX = width / 2;
s.OfsetY = height / 2;
return(s);
}
public void SetupSolve(CalibrationInfo ci, bool useConstraints, bool radialDistortion)
{
foreach (ProjectorEntry pe in ci.Projectors)
{
SolveProjector sp = new SolveProjector(pe, ci.DomeSize, ci.ScreenType == ScreenTypes.FishEye ? ProjectionType.FishEye : ProjectionType.Projector, ScreenTypes.Spherical, ci.ScreenType == ScreenTypes.FishEye ? SolveParameters.FishEye : (SolveParameters)ci.SolveParameters);
sp.RadialDistorion = radialDistortion;
projectors.Add(sp);
if (useConstraints)
{
foreach (GroundTruthPoint gt in pe.Constraints)
{
SolveList.Add(new Constraint(sp, gt));
}
}
}
foreach (Edge edge in ci.Edges)
{
foreach (EdgePoint pnt in edge.Points)
{
SolveList.Add(new Coorespondence(projectors[edge.Left - 1], projectors[edge.Right - 1], pnt));
}
}
foreach (SolveProjector sp in projectors)
{
regressionParameters.AddRange(sp.Parameters);
}
int count = SolveList.Count;
double[,] data = new double[2, count];
for (int i = 0; i < count; i++)
{
data[0, i] = i;
data[1, i] = 0;
}
Parameter[] observed = new Parameter[] { ParmeterIndex };
lm = new LevenbergMarquardt(new functionDelegate(SolveFunction), regressionParameters.ToArray(), observed, data);
}
public override Vector values(Vector x)
{
// dummy nested optimization
Vector coefficients = new Vector(3, 1.0);
OneDimensionalPolynomialDegreeN oneDimensionalPolynomialDegreeN = new OneDimensionalPolynomialDegreeN(coefficients);
NoConstraint constraint = new NoConstraint();
Vector initialValues = new Vector(1, 100.0);
Problem problem = new Problem(oneDimensionalPolynomialDegreeN, constraint, initialValues);
LevenbergMarquardt optimizationMethod = new LevenbergMarquardt();
//Simplex optimizationMethod(0.1);
//ConjugateGradient optimizationMethod;
//SteepestDescent optimizationMethod;
EndCriteria endCriteria = new EndCriteria(1000, 100, 1e-5, 1e-5, 1e-5);
optimizationMethod.minimize(problem, endCriteria);
// return dummy result
Vector dummy = new Vector(1, 0);
return(dummy);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(LevenbergMarquardt obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
static double CalibrateColorCamera(List <Matrix> worldPoints, List <System.Drawing.PointF> imagePoints, Matrix cameraMatrix, Matrix distCoeffs, Matrix rotation, Matrix translation)
{
int nPoints = worldPoints.Count;
{
Matrix R, t;
CameraMath.DLT(cameraMatrix, distCoeffs, worldPoints, imagePoints, out R, out t);
//var r = Orientation.RotationVector(R);
var r = RoomAliveToolkit.ProjectorCameraEnsemble.RotationVectorFromRotationMatrix(R);
rotation.Copy(r);
translation.Copy(t);
}
// pack parameters into vector
// parameters: fx, fy, cx, cy, k1, k2, + 3 for rotation, 3 translation = 12
int nParameters = 12;
var parameters = new Matrix(nParameters, 1);
{
int pi = 0;
parameters[pi++] = cameraMatrix[0, 0]; // fx
parameters[pi++] = cameraMatrix[1, 1]; // fy
parameters[pi++] = cameraMatrix[0, 2]; // cx
parameters[pi++] = cameraMatrix[1, 2]; // cy
parameters[pi++] = distCoeffs[0]; // k1
parameters[pi++] = distCoeffs[1]; // k2
parameters[pi++] = rotation[0];
parameters[pi++] = rotation[1];
parameters[pi++] = rotation[2];
parameters[pi++] = translation[0];
parameters[pi++] = translation[1];
parameters[pi++] = translation[2];
}
// size of our error vector
int nValues = nPoints * 2; // each component (x,y) is a separate entry
LevenbergMarquardt.Function function = delegate(Matrix p)
{
var fvec = new Matrix(nValues, 1);
// unpack parameters
int pi = 0;
double fx = p[pi++];
double fy = p[pi++];
double cx = p[pi++];
double cy = p[pi++];
double k1 = p[pi++];
double k2 = p[pi++];
var K = Matrix.Identity(3, 3);
K[0, 0] = fx;
K[1, 1] = fy;
K[0, 2] = cx;
K[1, 2] = cy;
var d = Matrix.Zero(5, 1);
d[0] = k1;
d[1] = k2;
var r = new Matrix(3, 1);
r[0] = p[pi++];
r[1] = p[pi++];
r[2] = p[pi++];
var t = new Matrix(3, 1);
t[0] = p[pi++];
t[1] = p[pi++];
t[2] = p[pi++];
//var R = Orientation.Rodrigues(r);
var R = RoomAliveToolkit.ProjectorCameraEnsemble.RotationMatrixFromRotationVector(r);
var x = new Matrix(3, 1);
int fveci = 0;
for (int i = 0; i < worldPoints.Count; i++)
{
// transform world point to local camera coordinates
x.Mult(R, worldPoints[i]);
x.Add(t);
// fvec_i = y_i - f(x_i)
double u, v;
CameraMath.Project(K, d, x[0], x[1], x[2], out u, out v);
var imagePoint = imagePoints[i];
fvec[fveci++] = imagePoint.X - u;
fvec[fveci++] = imagePoint.Y - v;
}
return(fvec);
};
// optimize
var calibrate = new LevenbergMarquardt(function);
while (calibrate.State == LevenbergMarquardt.States.Running)
{
var rmsError = calibrate.MinimizeOneStep(parameters);
Console.WriteLine("rms error = " + rmsError);
}
for (int i = 0; i < nParameters; i++)
{
Console.WriteLine(parameters[i] + "\t");
}
Console.WriteLine();
// unpack parameters
{
int pi = 0;
double fx = parameters[pi++];
double fy = parameters[pi++];
double cx = parameters[pi++];
double cy = parameters[pi++];
double k1 = parameters[pi++];
double k2 = parameters[pi++];
cameraMatrix[0, 0] = fx;
cameraMatrix[1, 1] = fy;
cameraMatrix[0, 2] = cx;
cameraMatrix[1, 2] = cy;
distCoeffs[0] = k1;
distCoeffs[1] = k2;
rotation[0] = parameters[pi++];
rotation[1] = parameters[pi++];
rotation[2] = parameters[pi++];
translation[0] = parameters[pi++];
translation[1] = parameters[pi++];
translation[2] = parameters[pi++];
}
return(calibrate.RMSError);
}
static double CalibrateDepthCamera(List <Matrix> worldPoints, List <System.Drawing.PointF> imagePoints, Matrix cameraMatrix, Matrix distCoeffs)
{
int nPoints = worldPoints.Count;
// pack parameters into vector
// parameters: fx, fy, cx, cy, k1, k2 = 6 parameters
int nParameters = 6;
var parameters = new Matrix(nParameters, 1);
{
int pi = 0;
parameters[pi++] = cameraMatrix[0, 0]; // fx
parameters[pi++] = cameraMatrix[1, 1]; // fy
parameters[pi++] = cameraMatrix[0, 2]; // cx
parameters[pi++] = cameraMatrix[1, 2]; // cy
parameters[pi++] = distCoeffs[0]; // k1
parameters[pi++] = distCoeffs[1]; // k2
}
// size of our error vector
int nValues = nPoints * 2; // each component (x,y) is a separate entry
LevenbergMarquardt.Function function = delegate(Matrix p)
{
var fvec = new Matrix(nValues, 1);
// unpack parameters
int pi = 0;
double fx = p[pi++];
double fy = p[pi++];
double cx = p[pi++];
double cy = p[pi++];
double k1 = p[pi++];
double k2 = p[pi++];
var K = Matrix.Identity(3, 3);
K[0, 0] = fx;
K[1, 1] = fy;
K[0, 2] = cx;
K[1, 2] = cy;
var d = Matrix.Zero(5, 1);
d[0] = k1;
d[1] = k2;
int fveci = 0;
for (int i = 0; i < worldPoints.Count; i++)
{
// fvec_i = y_i - f(x_i)
double u, v;
var x = worldPoints[i];
CameraMath.Project(K, d, x[0], x[1], x[2], out u, out v);
var imagePoint = imagePoints[i];
fvec[fveci++] = imagePoint.X - u;
fvec[fveci++] = imagePoint.Y - v;
}
return(fvec);
};
// optimize
var calibrate = new LevenbergMarquardt(function);
while (calibrate.State == LevenbergMarquardt.States.Running)
{
var rmsError = calibrate.MinimizeOneStep(parameters);
Console.WriteLine("rms error = " + rmsError);
}
for (int i = 0; i < nParameters; i++)
{
Console.WriteLine(parameters[i] + "\t");
}
Console.WriteLine();
// unpack parameters
{
int pi = 0;
double fx = parameters[pi++];
double fy = parameters[pi++];
double cx = parameters[pi++];
double cy = parameters[pi++];
double k1 = parameters[pi++];
double k2 = parameters[pi++];
cameraMatrix[0, 0] = fx;
cameraMatrix[1, 1] = fy;
cameraMatrix[0, 2] = cx;
cameraMatrix[1, 2] = cy;
distCoeffs[0] = k1;
distCoeffs[1] = k2;
}
return(calibrate.RMSError);
}
public static void Run(bool generate = false, bool generate_from_db = false)
{
Dictionary <string, string> dicSettings = new Dictionary <string, string>();
dicSettings["APP_NAME"] = "Midax";
dicSettings["PUBLISHING_START_TIME"] = "2016-01-22 08:00:00";
dicSettings["PUBLISHING_STOP_TIME"] = "2016-01-22 09:00:00";
dicSettings["REPLAY_MODE"] = "CSV";
dicSettings["REPLAY_POPUP"] = "1";
dicSettings["TRADING_START_TIME"] = "2016-01-22 08:45:00";
dicSettings["TRADING_STOP_TIME"] = "2016-01-22 08:59:00";
dicSettings["TRADING_CLOSING_TIME"] = "2016-01-22 08:57:00";
dicSettings["TRADING_MODE"] = "REPLAY";
dicSettings["TRADING_SIGNAL"] = "MacD_1_5_IX.D.DAX.DAILY.IP";
dicSettings["TRADING_LIMIT_PER_BP"] = "10";
dicSettings["TRADING_CURRENCY"] = "GBP";
Config.Settings = dicSettings;
string action = generate ? "Generating" : "Testing";
var dax = new MarketData("DAX:IX.D.DAX.DAILY.IP");
List <string> tests = new List <string>();
Console.WriteLine(action + " WMA...");
// Test weighted moving average with long intervals
tests.Add(@"..\..\expected_results\testWMA.csv");
dicSettings["REPLAY_CSV"] = Config.TestList(tests);
if (generate)
{
dicSettings["PUBLISHING_CSV"] = string.Format("..\\..\\expected_results\\testWMAgen.csv");
}
var macDTestWMA = new ModelMacDTest(dax, 1, 2, 3);
MarketDataConnection.Instance.Connect(null);
macDTestWMA.StartSignals();
macDTestWMA.StopSignals();
// Test weighted moving average with short intervals
tests = new List <string>();
tests.Add(@"..\..\expected_results\testWMA2.csv");
dicSettings["REPLAY_CSV"] = Config.TestList(tests);
if (generate)
{
dicSettings["PUBLISHING_CSV"] = string.Format("..\\..\\expected_results\\testWMA2gen.csv");
}
dax.Clear();
macDTestWMA = new ModelMacDTest(dax, 1, 2, 3);
MarketDataConnection.Instance.Connect(null);
macDTestWMA.StartSignals();
macDTestWMA.StopSignals();
// Test weighted moving average with linear time decay
tests = new List <string>();
tests.Add(@"..\..\expected_results\testWMA3.csv");
dicSettings["REPLAY_CSV"] = Config.TestList(tests);
dicSettings["TIME_DECAY_FACTOR"] = "3";
if (generate)
{
dicSettings["PUBLISHING_CSV"] = string.Format("..\\..\\expected_results\\testWMA3gen.csv");
}
dax.Clear();
macDTestWMA = new ModelMacDTest(dax, 1, 2, 3);
MarketDataConnection.Instance.Connect(null);
macDTestWMA.StartSignals();
macDTestWMA.StopSignals();
// Test volume weighted moving average with linear time decay
/*
* tests = new List<string>();
* tests.Add(@"..\..\expected_results\testWMA4.csv");
* dicSettings["REPLAY_CSV"] = Config.TestList(tests);
* if (generate)
* dicSettings["PUBLISHING_CSV"] = string.Format("..\\..\\expected_results\\testWMA4gen.csv");
* var macDVTest = new ModelMacDVTest(dax, 1, 2, 3);
* MarketDataConnection.Instance.Connect(null);
* macDVTest.StartSignals();
* macDVTest.StopSignals();*/
dicSettings.Remove("TIME_DECAY_FACTOR");
// Test RSI and Correlation indicators
tests = new List <string>();
tests.Add(@"..\..\expected_results\testRsiCorrel.csv");
dicSettings["INDEX_ICEDOW"] = "DOW:IceConnection_DOW";
dicSettings["INDEX_DOW"] = "DOW:IX.D.DOW.DAILY.IP";
dicSettings["INDEX_DAX"] = "DAX:IX.D.DAX.DAILY.IP";
dicSettings["REPLAY_CSV"] = Config.TestList(tests);
if (generate)
{
dicSettings["PUBLISHING_CSV"] = string.Format("..\\..\\expected_results\\testRsiCorrelgen.csv");
}
dax.Clear();
var icedow = new MarketData(dicSettings["INDEX_ICEDOW"]);
var dow = new MarketData(dicSettings["INDEX_DOW"]);
var macD = new ModelMacDTest(dax, 1, 2, 3);
//var macDV = new ModelMacDVTest(icedow, 1, 2, 3, dow);
var moleTest = new ModelMoleTest(macD);
MarketDataConnection.Instance.Connect(null);
macD.StartSignals(false);
//macDV.StartSignals(false);
moleTest.StartSignals(false);
MarketDataConnection.Instance.StartListening();
moleTest.StopSignals(false);
//macDV.StartSignals(false);
macD.StopSignals(false);
MarketDataConnection.Instance.StopListening();
Console.WriteLine(action + " calibration...");
// Test a 1mn linear regression
var mktData = new MarketData("testLRMktData");
var updateTime = Config.ParseDateTimeLocal(dicSettings["TRADING_START_TIME"]);
mktData.TimeSeries.Add(updateTime, new Price(100));
mktData.TimeSeries.Add(updateTime.AddSeconds(20), new Price(120));
mktData.TimeSeries.Add(updateTime.AddSeconds(40), new Price(140));
mktData.TimeSeries.Add(updateTime.AddSeconds(60), new Price(130));
mktData.TimeSeries.Add(updateTime.AddSeconds(80), new Price(145));
mktData.TimeSeries.Add(updateTime.AddSeconds(100), new Price(165));
mktData.TimeSeries.Add(updateTime.AddSeconds(120), new Price(145));
var linReg = new IndicatorLinearRegression(mktData, new TimeSpan(0, 2, 0));
var linRegCoeff = linReg.linearCoeff(updateTime.AddSeconds(120));
if (Math.Abs(linRegCoeff.Value - 0.821428571428573m) > 1e-8m)
{
throw new ApplicationException("Linear regression error");
}
// Test the optimization of function a * cos(b * x) + b * sin(a * x) using Levenberg Marquardt
LevenbergMarquardt.objective_func objFunc = (NRealMatrix x) => { NRealMatrix y = new NRealMatrix(x.Rows, 1);
for (int idxRow = 0; idxRow < y.Rows; idxRow++)
{
y.SetAt(idxRow, 0, new NDouble(2 * Math.Cos(x[idxRow, 0]) + Math.Sin(2 * x[idxRow, 0])));
}
return(y); };
List <double> inputs = new List <double>();
Random rnd = new Random(155);
for (int idxPt = 0; idxPt < 10; idxPt++)
{
inputs.Add(rnd.NextDouble() * 2);
}
List <Value> modelParams = new List <Value>();
modelParams.Add(new Value(-0.2)); modelParams.Add(new Value(0.3));
LevenbergMarquardt.model_func modelFunc = (NRealMatrix x, NRealMatrix weights) => { NRealMatrix y = new NRealMatrix(x.Rows, 1);
double a = weights[0, 0]; double b = weights[0, 1];
for (int idxRow = 0; idxRow < y.Rows; idxRow++)
{
y.SetAt(idxRow, 0, new NDouble(a * Math.Cos(b * x[idxRow, 0]) + b * Math.Sin(a * x[idxRow, 0])));
}
return(y); };
Func <double, double, double, double> derA = (double a, double b, double x) => Math.Cos(b * x) + b * x * Math.Cos(a * x);
Func <double, double, double, double> derB = (double a, double b, double x) => - a * x * Math.Sin(b * x) + Math.Sin(a * x);
LevenbergMarquardt.model_func jacFunc = (NRealMatrix x, NRealMatrix weights) =>
{
NRealMatrix jac = new NRealMatrix(x.Rows, 2);
double a = weights[0, 0]; double b = weights[0, 1];
for (int idxRow = 0; idxRow < jac.Rows; idxRow++)
{
jac.SetAt(idxRow, 0, new NDouble(-derA(a, b, x[idxRow, 0])));
jac.SetAt(idxRow, 1, new NDouble(-derB(a, b, x[idxRow, 0])));
}
return(jac);
};
LevenbergMarquardt calibModel = new LevenbergMarquardt(objFunc, inputs, modelParams, modelFunc, jacFunc);
calibModel.Solve();
if (Math.Abs(modelParams[0].X - 2) > calibModel.ObjectiveError || Math.Abs(modelParams[1].X - 1) > calibModel.ObjectiveError)
{
throw new ApplicationException("LevenbergMarquardt calibration error");
}
// Parity-2 problem
NeuralNetwork ann = new NeuralNetwork(2, 1, new List <int>()
{
2
});
List <List <double> > annInputs = new List <List <double> >();
annInputs.Add(new List <double>()
{
-1, -1
});
annInputs.Add(new List <double>()
{
-1, 1
});
annInputs.Add(new List <double>()
{
1, -1
});
annInputs.Add(new List <double>()
{
1, 1
});
List <List <double> > annOutputs = new List <List <double> >();
annOutputs.Add(new List <double>()
{
1
});
annOutputs.Add(new List <double>()
{
-1
});
annOutputs.Add(new List <double>()
{
-1
});
annOutputs.Add(new List <double>()
{
1
});
// test forward propagation
ann._outputs.Neurons[0].Weights[0].X = 1;
ann._outputs.Neurons[0].Weights[1].X = -1;
ann._outputs.Neurons[0].Weights[2].X = -1;
ann._innerLayers[0].Neurons[0].Weights[0].X = 1;
ann._innerLayers[0].Neurons[0].Weights[1].X = 1;
ann._innerLayers[0].Neurons[0].Weights[2].X = 1;
ann._innerLayers[0].Neurons[1].Weights[0].X = 1;
ann._innerLayers[0].Neurons[1].Weights[1].X = 1;
ann._innerLayers[0].Neurons[1].Weights[2].X = -1;
ann._inputs.Neurons[0].Value.X = -1;
ann._inputs.Neurons[1].Value.X = -1;
if (Math.Abs(ann._outputs.Neurons[0].Activation() - -0.38873457229297215) > calibModel.ObjectiveError)
{
throw new ApplicationException("Neural network forward propagation error");
}
// Test neural network training for parity-2 problem
ann = new NeuralNetwork(2, 1, new List <int>()
{
2
});
ann.Train(annInputs, annOutputs);
// Test neural network training for parity-3 problem
ann = new NeuralNetwork(3, 1, new List <int>()
{
2
});
annInputs = new List <List <double> >();
annInputs.Add(new List <double>()
{
-1, -1, -1
});
annInputs.Add(new List <double>()
{
-1, -1, 1
});
annInputs.Add(new List <double>()
{
-1, 1, -1
});
annInputs.Add(new List <double>()
{
-1, 1, 1
});
annInputs.Add(new List <double>()
{
1, -1, -1
});
annInputs.Add(new List <double>()
{
1, -1, 1
});
annInputs.Add(new List <double>()
{
1, 1, -1
});
annInputs.Add(new List <double>()
{
1, 1, 1
});
annOutputs = new List <List <double> >();
annOutputs.Add(new List <double>()
{
-1
});
annOutputs.Add(new List <double>()
{
1
});
annOutputs.Add(new List <double>()
{
1
});
annOutputs.Add(new List <double>()
{
-1
});
annOutputs.Add(new List <double>()
{
1
});
annOutputs.Add(new List <double>()
{
-1
});
annOutputs.Add(new List <double>()
{
-1
});
annOutputs.Add(new List <double>()
{
1
});
ann.Train(annInputs, annOutputs);
Console.WriteLine(action + " live indicators and signals...");
tests = new List <string>();
tests.Add(@"..\..\expected_results\core_22_1_2016.csv");
if (generate_from_db)
{
dicSettings["DB_CONTACTPOINT"] = "192.168.1.26";
}
dicSettings["REPLAY_MODE"] = generate_from_db ? "DB" : "CSV";
dicSettings["REPLAY_CSV"] = Config.TestList(tests);
if (generate)
{
dicSettings["PUBLISHING_CSV"] = string.Format("..\\..\\expected_results\\coregen_22_1_2016.csv");
}
MarketDataConnection.Instance.Connect(null);
dax.Clear();
var model = new ModelMacDTest(dax);
model.StartSignals();
Console.WriteLine(action + " daily indicators...");
model.StopSignals();
Thread.Sleep(1000);
if (!dicSettings.ContainsKey("PUBLISHING_CSV"))
{
// the program is expected to throw exceptions in this scope, just press continue if you are debugging
// all exceptions should be handled, and the program should terminate with a success message box
// test that the right numer of trades was placed. this is an extra sanity check to make sure the program is not idle
if (ReplayTester.Instance.NbProducedTrades != ReplayTester.Instance.NbExpectedTrades)
{
model.ProcessError(string.Format("the model did not produced the expected number of trades. It produced {0} trades instead of {1} expected",
ReplayTester.Instance.NbProducedTrades, ReplayTester.Instance.NbExpectedTrades));
}
// test trade booking
MarketDataConnection.Instance = new ReplayConnection(true);
model = new ModelMacDTest(dax);
MarketDataConnection.Instance.Connect(null);
Console.WriteLine(action + " trade booking...");
var tradeTime = Config.ParseDateTimeLocal(dicSettings["TRADING_CLOSING_TIME"]).AddSeconds(-1);
var tradeTest = new Trade(tradeTime, dax.Id, SIGNAL_CODE.SELL, 10, 10000m);
var expectedTrades = new Dictionary <KeyValuePair <string, DateTime>, Trade>();
expectedTrades[new KeyValuePair <string, DateTime>("###DUMMY_TRADE_REF1###", tradeTime)] = tradeTest;
ReplayTester.Instance.SetExpectedResults(null, null, expectedTrades, null);
var task = model.PTF.Subscribe();
task.Wait();
model.PTF.BookTrade(tradeTest, dax.Name);
Thread.Sleep(5000);
if (model.PTF.GetPosition(tradeTest.Epic).Quantity != -10)
{
throw new ApplicationException("SELL Trade booking error");
}
var expectedTrade = new Trade(tradeTime, dax.Id, SIGNAL_CODE.BUY, 10, 10000m);
expectedTrade.Reference = "###CLOSE_DUMMY_TRADE_REF2###";
expectedTrade.Id = "###DUMMY_TRADE_ID1###";
expectedTrades[new KeyValuePair <string, DateTime>(expectedTrade.Reference, tradeTime)] = expectedTrade;
model.PTF.ClosePosition(tradeTest, tradeTime);
Thread.Sleep(5000);
if (model.PTF.GetPosition(tradeTest.Epic).Quantity != 0)
{
throw new ApplicationException("Trade position closing error");
}
expectedTrade.Reference = "###DUMMY_TRADE_REF3###";
expectedTrade.Id = "###DUMMY_TRADE_ID2###";
expectedTrades[new KeyValuePair <string, DateTime>(expectedTrade.Reference, tradeTime)] = expectedTrade;
model.PTF.BookTrade(new Trade(tradeTest, true, tradeTime), dax.Name);
Thread.Sleep(5000);
if (model.PTF.GetPosition(tradeTest.Epic).Quantity != 10)
{
throw new ApplicationException("BUY Trade booking error");
}
expectedTrade = new Trade(tradeTime, dax.Id, SIGNAL_CODE.SELL, 10, 0m);
expectedTrade.Reference = "###CLOSE_DUMMY_TRADE_REF4###";
expectedTrade.Id = "###DUMMY_TRADE_ID2###";
expectedTrades[new KeyValuePair <string, DateTime>(expectedTrade.Reference, tradeTime)] = expectedTrade;
Portfolio.Instance.CloseAllPositions(tradeTest.TradingTime);
Thread.Sleep(5000);
// test synchronization issues with the broker
List <string> testsSync = new List <string>();
testsSync.Add(@"..\..\expected_results\sync.csv");
dicSettings["REPLAY_CSV"] = Config.TestList(testsSync);
MarketDataConnection.Instance = new ReplayCrazySeller();
model = new ModelMacDTest(dax);
Console.WriteLine(action + " synchronization...");
MarketDataConnection.Instance.Connect(null);
model.StartSignals();
model.StopSignals();
testsSync = new List <string>();
testsSync.Add(@"..\..\expected_results\sync2.csv");
dicSettings["REPLAY_CSV"] = Config.TestList(testsSync);
MarketDataConnection.Instance = new ReplayCrazyBuyer();
model = new ModelMacDTest(dax);
MarketDataConnection.Instance.Connect(null);
model.StartSignals();
model.StopSignals();
Console.WriteLine(action + " expected exceptions...");
dicSettings["REPLAY_CSV"] = Config.TestList(tests);
MarketDataConnection.Instance = new ReplayConnection(true);
MarketDataConnection.Instance.Connect(null);
List <string> testError = new List <string>();
testError.Add(@"..\..\expected_results\error.csv");
dicSettings["REPLAY_CSV"] = Config.TestList(testError);
var modelErr = new ModelMacDTest(dax);
string expected;
bool success = false;
try
{
MarketDataConnection.Instance.Connect(null);
modelErr.StartSignals();
}
catch (Exception exc)
{
expected = "Test failed: indicator EMA_1_IX.D.DAX.DAILY.IP time 08:30 expected value 9740.791666666666666666666667 != 9740.3";
success = (exc.Message.Replace(" AM", "") == expected);
if (!success)
{
model.ProcessError(exc.Message, expected);
}
}
if (!success)
{
model.ProcessError("An expected exception has not been thrown");
}
success = false;
try
{
modelErr.StopSignals();
}
catch (Exception exc)
{
model.ProcessError(exc.Message + " - Wrong daily mean exception removed");
}
success = false;
try
{
model.StopSignals();
}
catch (Exception exc)
{
model.ProcessError(exc.Message + " - Double EOD publishing exception removed");
}
success = false;
try
{
MarketDataConnection.Instance = new ReplayConnection(true);
MarketDataConnection.Instance.Connect(null);
model = new ModelMacDTest(new MarketData(dax.Id));
model.StartSignals();
}
catch (Exception exc)
{
expected = "Test failed: indicator EMA_1_IX.D.DAX.DAILY.IP time 08:30 expected value 9740.791666666666666666666667 != 9740.3";
success = (exc.Message.Replace(" AM", "") == expected);
if (!success)
{
model.ProcessError(exc.Message, expected);
}
}
if (!success)
{
model.ProcessError("An expected exception has not been thrown");
}
success = false;
try
{
MarketDataConnection.Instance.Resume();
}
catch (Exception exc)
{
expected = "Time series do not accept values in the past";
success = (exc.Message.Replace(" AM", "") == expected);
if (!success)
{
model.ProcessError(exc.Message, expected);
}
}
if (!success)
{
model.ProcessError("An expected exception has not been thrown");
}
model.StopSignals();
success = false;
}
}
static void Main(string[] args)
{
DateTime timer = DateTime.Now;
//////////////// DATES //////////////////////////////////////////////
Calendar calendar = new TARGET();
Date todaysDate = new Date(15, Month.January, 2017);
Date settlementDate = new Date(todaysDate);
Settings.setEvaluationDate(todaysDate);
DayCounter dayCounter = new Actual365Fixed();
//////////////// MARKET //////////////////////////////////////////////
// Spot
double underlying = 4468.17;
Handle <Quote> underlyingH = new Handle <Quote>(new SimpleQuote(underlying));
// riskfree
double riskFreeRate = 0.035;
Handle <YieldTermStructure> flatTermStructure = new Handle <YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
// dividend
double dividendYield = 0.0;
double fixedDiv = 5.0;
Handle <YieldTermStructure> flatDividendTS = new Handle <YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
Handle <YieldTermStructure> FixedDivTermStructure = new Handle <YieldTermStructure>(new FixedForward(settlementDate, fixedDiv, underlying, dayCounter));
// vol surface
Date StartDateVol = settlementDate + new Period(1, TimeUnit.Months);
List <int> maturityInDays = new InitializedList <int>()
{
0, 13, 41, 90, 165, 256, 345, 524, 703
};
List <Date> datesVol = new InitializedList <Date>();
for (int d = 1; d < maturityInDays.Count; d++)
{
datesVol.Add(calendar.advance(settlementDate, new Period(maturityInDays[d], TimeUnit.Days)));
}
List <double> strikes = new InitializedList <double>()
{
3400, 3600, 3800, 4000, 4200, 4400, 4500, 4600, 4800, 5000, 5200, 5400, 5600
};
Matrix blackVolMatrix = new Matrix(maturityInDays.Count - 1, strikes.Count, 0.2);
var vols = new InitializedList <double>()
{
0.6625, 0.4875, 0.4204, 0.3667, 0.3431, 0.3267, 0.3121, 0.3121,
0.6007, 0.4543, 0.3967, 0.3511, 0.3279, 0.3154, 0.2984, 0.2921,
0.5084, 0.4221, 0.3718, 0.3327, 0.3155, 0.3027, 0.2919, 0.2889,
0.4541, 0.3869, 0.3492, 0.3149, 0.2963, 0.2926, 0.2819, 0.2800,
0.4060, 0.3607, 0.3330, 0.2999, 0.2887, 0.2811, 0.2751, 0.2775,
0.3726, 0.3396, 0.3108, 0.2781, 0.2788, 0.2722, 0.2661, 0.2686,
0.3550, 0.3277, 0.3012, 0.2781, 0.2781, 0.2661, 0.2661, 0.2681,
0.3428, 0.3209, 0.2958, 0.2740, 0.2688, 0.2627, 0.2580, 0.2620,
0.3302, 0.3062, 0.2799, 0.2631, 0.2573, 0.2533, 0.2504, 0.2544,
0.3343, 0.2959, 0.2705, 0.2540, 0.2504, 0.2464, 0.2448, 0.2462,
0.3460, 0.2845, 0.2624, 0.2463, 0.2425, 0.2385, 0.2373, 0.2422,
0.3857, 0.2860, 0.2578, 0.2399, 0.2357, 0.2327, 0.2312, 0.2351,
0.3976, 0.2860, 0.2607, 0.2356, 0.2297, 0.2268, 0.2241, 0.2320
};
for (int i = 0; i < vols.Count; i++)
{
int testraw = (int)(i % (datesVol.Count));
int testcol = (int)(i / (datesVol.Count));
blackVolMatrix[testraw, testcol] = vols[i];
}
BlackVarianceSurface mySurface = new BlackVarianceSurface(settlementDate, calendar, datesVol,
strikes, Matrix.transpose(blackVolMatrix), dayCounter);
Handle <BlackVolTermStructure> mySurfaceH = new Handle <BlackVolTermStructure>(mySurface);
//////////////// CALIBRATION //////////////////////////////////////////////
Period helperPeriod = new Period();
//helpers
List <CalibrationHelper> calibrationHelpers = new List <CalibrationHelper>();
for (int k = 0; k < strikes.Count; k++)
{
for (int d = 0; d < datesVol.Count; d++)
{
helperPeriod = new Period(datesVol[d] - settlementDate, TimeUnit.Days);
calibrationHelpers.Add(new HestonModelHelper(helperPeriod,
calendar,
underlying,
strikes[k],
new Handle <Quote>(new SimpleQuote(blackVolMatrix[d, k])),
flatTermStructure,
flatDividendTS,
CalibrationHelper.CalibrationErrorType.ImpliedVolError));
}
}
// starting data
double v0 = 0.1;
double kappa = 1.0;
double theta = 0.1;
double sigma = 0.5;
double rho = -0.5;
// model
HestonProcess hestonProcess = new HestonProcess(flatTermStructure,
flatDividendTS,
underlyingH,
v0, kappa, theta, sigma, rho);
HestonModel hestonmodel = new HestonModel(hestonProcess);
AnalyticHestonEngine analyticHestonEngine = new AnalyticHestonEngine(hestonmodel);
foreach (HestonModelHelper hmh in calibrationHelpers)
{
hmh.setPricingEngine(analyticHestonEngine);
}
// optimization
double tolerance = 1.0e-8;
LevenbergMarquardt optimizationmethod = new LevenbergMarquardt(tolerance, tolerance, tolerance);
hestonmodel.calibrate(calibrationHelpers, optimizationmethod, new EndCriteria(400, 40, tolerance, tolerance, tolerance));
double error = 0.0;
List <double> errorList = new InitializedList <double>();
//////////////// CALIBRATION RESULTS //////////////////////////////////////////////
Console.WriteLine("Calbration :");
Console.WriteLine("-----------");
foreach (HestonModelHelper hmh in calibrationHelpers)
{
error += Math.Abs(hmh.calibrationError());
errorList.Add(Math.Abs(hmh.calibrationError()));
}
Vector hestonParameters = hestonmodel.parameters();
Console.WriteLine("v0 = {0:0.00%}", hestonParameters[4]);
Console.WriteLine("kappa = {0:0.00%}", hestonParameters[1]);
Console.WriteLine("theta = {0:0.00%}", hestonParameters[0]);
Console.WriteLine("sigma = {0:0.00%}", hestonParameters[2]);
Console.WriteLine("rho = {0:0.00%}", hestonParameters[3]);
Console.WriteLine();
Console.WriteLine("Total error = {0:0.0000}", error);
Console.WriteLine("Mean error = {0:0.0000%}", error / (errorList.Count - 1));
Console.WriteLine();
int StepsPerYear = 52;
double absoluteTolerance = 80.0;
ulong mcSeed = 42;
// MC Heston process
HestonProcess calibratedHestonProcess = new HestonProcess(flatTermStructure,
flatDividendTS,
underlyingH,
hestonParameters[4],
hestonParameters[1],
hestonParameters[0],
hestonParameters[2],
hestonParameters[3]);
// BS process
GeneralizedBlackScholesProcessTolerance bsmProcess = new GeneralizedBlackScholesProcessTolerance(underlyingH, FixedDivTermStructure, flatTermStructure, mySurfaceH);
//////////////// ENGINES /////////////////////////////////////////////////
IPricingEngine mcHestonEngine = new MakeMCEuropeanHestonEngine <PseudoRandom, Statistics>(calibratedHestonProcess)
.withStepsPerYear(StepsPerYear)
.withAbsoluteTolerance(absoluteTolerance)
.withSeed(mcSeed)
.getAsPricingEngine();
double absoluteTolerance2 = 1.0;
IPricingEngine mcGenHestonEngineTestbs = new MakeMCGenericScriptInstrument <PseudoRandom>(bsmProcess)
.withStepsPerYear(StepsPerYear)
.withAbsoluteTolerance(absoluteTolerance2)
.withSeed(mcSeed)
.value();
IPricingEngine mcGenHestonEngineTestbs2 = new MakeMCGenericScriptInstrument <PseudoRandom>(calibratedHestonProcess)
.withStepsPerYear(StepsPerYear)
.withAbsoluteTolerance(absoluteTolerance2)
.withSeed(mcSeed)
.value();
//////////////// PRICING //////////////////////////////////////////////
Console.WriteLine("Pricing Vanilla:");
Console.WriteLine("---------------");
Date maturity = new Date(17, Month.May, 2019);
Exercise europeanExercise = new EuropeanExercise(maturity);
Option.Type type = Option.Type.Call;
double strike = underlying;
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
VanillaOption europeanOption = new VanillaOption(payoff, europeanExercise);
// heston
europeanOption.setPricingEngine(analyticHestonEngine);
Console.Write("Heston pricing = {0:0.0000}", europeanOption.NPV());
Console.WriteLine(" -> {0:0.0000%}", europeanOption.NPV() / underlying);
// Mc heston
europeanOption.setPricingEngine(mcHestonEngine);
Console.Write("HestMC pricing = {0:0.0000}", europeanOption.NPV());
Console.Write(" -> {0:0.0000%}", europeanOption.NPV() / underlying);
Console.WriteLine(" tolerance {0:0.0} / {1:0.00%}", absoluteTolerance, absoluteTolerance / underlying);
// analytic bs
europeanOption.setPricingEngine(new AnalyticEuropeanEngine(bsmProcess));
Console.Write("BS pricing = {0:0.0000}", europeanOption.NPV());
Console.WriteLine(" -> {0:0.0000%}", europeanOption.NPV() / underlying);
Console.WriteLine();
//////////////// AUTOCALL HESTON //////////////////////////////////////////////
List <Date> fixingdates = new InitializedList <Date>();
double coupon = 0.05;
double barrierlvl = 0.6;
for (int i = 1; i <= 4; i++)
{
fixingdates.Add(settlementDate + new Period(i, TimeUnit.Years));
}
ScriptGenericAutocall myGenericAutocallHTTEst = new ScriptGenericAutocall(fixingdates, coupon, barrierlvl, underlying);
myGenericAutocallHTTEst.setPricingEngine(mcGenHestonEngineTestbs);
Console.WriteLine("Pricing Autocall BS :");
Console.WriteLine("---------------------");
Console.WriteLine("test = {0:0.0000}", myGenericAutocallHTTEst.NPV());
Console.WriteLine("Err = {0:0.0000%}", myGenericAutocallHTTEst.errorEstimate() / myGenericAutocallHTTEst.NPV());
Console.WriteLine("Samples = {0}", myGenericAutocallHTTEst.samples());
Console.Write("\n");
for (int i = 0; i < 4; i++)
{
Console.WriteLine("ProbaCall {1} = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaCall " + i), i + 1);
}
Console.WriteLine("ProbaMid = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaMid"));
Console.WriteLine("probaDown = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaDown"));
Console.WriteLine("test = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaDown"));
Console.WriteLine("AvgDown/Proba = {0:0.0000%}", myGenericAutocallHTTEst.inspout("AvgDown") / myGenericAutocallHTTEst.inspout("ProbaDown"));
Console.Write("\n");
myGenericAutocallHTTEst.setPricingEngine(mcGenHestonEngineTestbs2);
Console.WriteLine("Pricing Autocall Heston:");
Console.WriteLine("------------------------");
Console.WriteLine("test = {0:0.0000}", myGenericAutocallHTTEst.NPV());
Console.WriteLine("Err = {0:0.0000%}", myGenericAutocallHTTEst.errorEstimate() / myGenericAutocallHTTEst.NPV());
Console.WriteLine("Samples = {0}", myGenericAutocallHTTEst.samples());
Console.Write("\n");
for (int i = 0; i < 4; i++)
{
Console.WriteLine("ProbaCall {1} = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaCall " + i), i + 1);
}
Console.WriteLine("ProbaMid = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaMid"));
Console.WriteLine("probaDown = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaDown"));
Console.WriteLine("test = {0:0.0000%}", myGenericAutocallHTTEst.inspout("ProbaDown"));
Console.WriteLine("AvgDown/Proba = {0:0.0000%}", myGenericAutocallHTTEst.inspout("AvgDown") / myGenericAutocallHTTEst.inspout("ProbaDown"));
Console.Write("\n");
//////////////// END TEST //////////////////////////////////////////////
Console.WriteLine();
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
static void Main(string[] args)
{
// Suppose we would like to fit a circle to the given points.
double[][] inputs = new double[][]
{
new [] { 1.0, 7.0 },
new [] { 2.0, 6.0 },
new [] { 5.0, 8.0 },
new [] { 7.0, 7.0 },
new [] { 9.0, 5.0 },
new [] { 3.0, 7.0 }
};
// In a least squares sense, we want the distance between a point and
// the ideal circle center minus the radius to be zero.
double[] outputs = Vector.Zeros(inputs.GetColumn(0).Length);
// Setup the solver with the Regression and Gradient functions and an
// initial solution guess. We'll solve for 3 parameters: the circle
// center and the radius.
LevenbergMarquardt lm = new LevenbergMarquardt(3)
{
Function = (w, k) =>
{
double dx = w[0] - k[0];
double dy = w[1] - k[1];
double dr = Math.Sqrt(dx * dx + dy * dy) - w[2];
return(dr);
},
Gradient = (w, k, m) =>
{
double dx = w[0] - k[0];
double dy = w[1] - k[1];
double di = Math.Sqrt(dx * dx + dy * dy);
m[0] = dx / di;
m[1] = dy / di;
m[2] = -1;
},
Solution = new double[] { 5.3794, 7.2532, 3.037 }
};
// Iteratively solve for the optimal solution according to some
// convergence criteria
double error = double.MaxValue;
for (int i = 0; i < 50; i++)
{
lm.Minimize(inputs, outputs);
if (lm.Value < error && error - lm.Value < 1.0e-12)
{
break;
}
error = lm.Value;
}
double x = lm.Solution[0]; // 4.7398
double y = lm.Solution[1]; // 2.9835
double r = lm.Solution[2]; // 4.7142
Console.WriteLine(x);
Console.WriteLine(y);
Console.WriteLine(r);
Console.ReadLine();
}
private void test(double initialSill, double initialRange)
{
// double[] temperature = new double[] { 229.15, 247.85, 256.95, 267.15, 278.15, 285.25, 294.35, 307.95, 323.05, 337.85 };
// double[] pressure = new double[] { 133.3224898, 666.6124489, 1333.224898, 2666.449795, 5332.899591, 7999.349386, 13332.24898, 26664.49795, 53328.99591, 101325.0922 };
double[,] z = new double[2, spatial.GetDistancesValues().Length];
for (int i = 0; i < spatial.GetDistancesValues().Length; i++)
{
z[0, i] = spatial.GetDistancesValues()[i];
z[1, i] = spatial.GetSemivariancesValues()[i];
}
Parameter S = new Parameter(initialSill);
Parameter R = new Parameter(initialRange);
Parameter D = new Parameter(0.0);
Func<double> regressionFunction = () => S * (1 - Math.Exp((-3* Math.Abs(D))/R));
Parameter[] regressionParameters = new Parameter[] {R, S};
Parameter[] observedParameters = new Parameter[] { D };
LevenbergMarquardt levenbergMarquardt = new LevenbergMarquardt(regressionFunction, regressionParameters, observedParameters, z);
for (int i = 0; i < 50; i++)
{
levenbergMarquardt.Iterate();
}
}
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,
false);
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)
{
Assert.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 IKrigingModel GetFunction(Model model, double sill, double range, double nugget)
{
msill = new Parameter(sill);
mrange = new Parameter(range);
mnugget = new Parameter(nugget);
distance = new Parameter();
// Parameter[] regressionParameters=null;
// Parameter[] observedParameters = null; ;
observedParameters = new Parameter[] { distance };
// regressionParameters = new Parameter[] { mrange, msill,mnugget };
DefineParametersCalculation();
switch (model)
{
case Model.Circular:
krigingModel = new ModelCircular();
regressionFunction = () =>
distance > 0 && distance <= Math.Abs(this.mrange) ? this.mnugget + (((2 * Math.Abs(this.msill)) / Math.PI) * (((distance / Math.Abs(this.mrange)) * Math.Sqrt(1 - ((distance * distance) / (Math.Abs(this.mrange) * Math.Abs(this.mrange))))) + Math.Asin(distance / Math.Abs(this.mrange)))) : distance >Math.Abs(this.mrange)?this.mnugget +Math.Abs(this.msill):0
;
break;
case Model.Exponential:
krigingModel = new ModelExponential();
regressionFunction = () =>distance>0?
Math.Abs(this.mnugget) + (Math.Abs(this.msill) * (1 - Math.Exp(-3 * Math.Abs(distance) / Math.Abs(this.mrange)))):0;
break;
case Model.Gaussian:
krigingModel = new ModelGaussian();
regressionFunction = () =>distance>0?
Math.Abs(this.mnugget) + (Math.Abs(this.msill) * (1 - Math.Exp(-3 * (Math.Abs(distance) / Math.Abs(this.mrange)) * (Math.Abs(distance) / Math.Abs(this.mrange))))):0;
break;
case Model.Spherical:
krigingModel = new ModelSpherical();
regressionFunction = () =>
distance > 0 && distance <= Math.Abs(this.mrange) ?
Math.Abs(this.mnugget) + (Math.Abs(this.msill) * ((1.5 * (this.distance / Math.Abs(this.mrange))) -
(0.5 * (this.distance / Math.Abs(this.mrange)) * (this.distance / Math.Abs(this.mrange)) * (this.distance / Math.Abs(this.mrange))))) :
distance > Math.Abs(this.mrange) ?
Math.Abs(this.mnugget) + Math.Abs(this.msill) :
0;
break;
}
if (regressionParameters.Length == 0)
{
krigingModel.Range =range;
krigingModel.C1 = sill ;
if (nugget < 0)
{
krigingModel.C0 = 0;
}
else
{
krigingModel.C0 = nugget;
}
OnChangedKriginParameter(EventArgs.Empty);
return krigingModel;
}
LevenbergMarquardt levenbergMarquardt;
if (regressionParameters != null)
{
try
{
levenbergMarquardt = new LevenbergMarquardt(regressionFunction, regressionParameters, observedParameters, z,2);
for (int i = 0; i < 50; i++)
{
levenbergMarquardt.Iterate();
}
DefineParametersCalculationValues(sill, range, nugget);
}
catch
{
DefineParametersCalculationValues(sill, range, nugget);
krigingModel.Range = range;
krigingModel.C1 = sill;
if (nugget < 0)
{
krigingModel.C0 = 0;
}
else
{
krigingModel.C0 = nugget;
}
OnChangedKriginParameter(EventArgs.Empty);
return krigingModel;
}
}
OnChangedKriginParameter(EventArgs.Empty);
return krigingModel;
}
public void testCalibration()
{
// Testing calibration of a Libor forward model
const int size = 14;
const double tolerance = 8e-3;
double[] capVols = { 0.145708, 0.158465, 0.166248, 0.168672,
0.169007, 0.167956, 0.166261, 0.164239,
0.162082, 0.159923, 0.157781, 0.155745,
0.153776, 0.151950, 0.150189, 0.148582,
0.147034, 0.145598, 0.144248 };
double[] swaptionVols = { 0.170595, 0.166844, 0.158306, 0.147444,
0.136930, 0.126833, 0.118135, 0.175963,
0.166359, 0.155203, 0.143712, 0.132769,
0.122947, 0.114310, 0.174455, 0.162265,
0.150539, 0.138734, 0.128215, 0.118470,
0.110540, 0.169780, 0.156860, 0.144821,
0.133537, 0.123167, 0.114363, 0.106500,
0.164521, 0.151223, 0.139670, 0.128632,
0.119123, 0.110330, 0.103114, 0.158956,
0.146036, 0.134555, 0.124393, 0.115038,
0.106996, 0.100064 };
IborIndex index = makeIndex();
LiborForwardModelProcess process = new LiborForwardModelProcess(size, index);
Handle <YieldTermStructure> termStructure = index.forwardingTermStructure();
// set-up the model
LmVolatilityModel volaModel = new LmExtLinearExponentialVolModel(process.fixingTimes(),
0.5, 0.6, 0.1, 0.1);
LmCorrelationModel corrModel = new LmLinearExponentialCorrelationModel(size, 0.5, 0.8);
LiborForwardModel model = new LiborForwardModel(process, volaModel, corrModel);
int swapVolIndex = 0;
DayCounter dayCounter = index.forwardingTermStructure().link.dayCounter();
// set-up calibration helper
List <CalibrationHelper> calibrationHelper = new List <CalibrationHelper>();
int i;
for (i = 2; i < size; ++i)
{
Period maturity = i * index.tenor();
Handle <Quote> capVol = new Handle <Quote>(new SimpleQuote(capVols[i - 2]));
CalibrationHelper caphelper = new CapHelper(maturity, capVol, index, Frequency.Annual,
index.dayCounter(), true, termStructure, CalibrationHelper.CalibrationErrorType.ImpliedVolError);
caphelper.setPricingEngine(new AnalyticCapFloorEngine(model, termStructure));
calibrationHelper.Add(caphelper);
if (i <= size / 2)
{
// add a few swaptions to test swaption calibration as well
for (int j = 1; j <= size / 2; ++j)
{
Period len = j * index.tenor();
Handle <Quote> swaptionVol = new Handle <Quote>(
new SimpleQuote(swaptionVols[swapVolIndex++]));
CalibrationHelper swaptionHelper =
new SwaptionHelper(maturity, len, swaptionVol, index,
index.tenor(), dayCounter,
index.dayCounter(),
termStructure, CalibrationHelper.CalibrationErrorType.ImpliedVolError);
swaptionHelper.setPricingEngine(new LfmSwaptionEngine(model, termStructure));
calibrationHelper.Add(swaptionHelper);
}
}
}
LevenbergMarquardt om = new LevenbergMarquardt(1e-6, 1e-6, 1e-6);
//ConjugateGradient gc = new ConjugateGradient();
model.calibrate(calibrationHelper,
om,
new EndCriteria(2000, 100, 1e-6, 1e-6, 1e-6),
new Constraint(),
new List <double>());
// measure the calibration error
double calculated = 0.0;
for (i = 0; i < calibrationHelper.Count; ++i)
{
double diff = calibrationHelper[i].calibrationError();
calculated += diff * diff;
}
if (Math.Sqrt(calculated) > tolerance)
{
QAssert.Fail("Failed to calibrate libor forward model"
+ "\n calculated diff: " + Math.Sqrt(calculated)
+ "\n expected : smaller than " + tolerance);
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(LevenbergMarquardt obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
