Example #1
0
        public void testSabrVols()
        {
            // Testing swaption volatility cube (sabr interpolation)
            CommonVars vars = new CommonVars();

            List <List <Handle <Quote> > > parametersGuess = new InitializedList <List <Handle <Quote> > >(
                vars.cube.tenors.options.Count * vars.cube.tenors.swaps.Count);

            for (int i = 0; i < vars.cube.tenors.options.Count * vars.cube.tenors.swaps.Count; i++)
            {
                parametersGuess[i]    = new InitializedList <Handle <Quote> >(4);
                parametersGuess[i][0] = new Handle <Quote>(new SimpleQuote(0.2));
                parametersGuess[i][1] = new Handle <Quote>(new SimpleQuote(0.5));
                parametersGuess[i][2] = new Handle <Quote>(new SimpleQuote(0.4));
                parametersGuess[i][3] = new Handle <Quote>(new SimpleQuote(0.0));
            }
            List <bool> isParameterFixed = new InitializedList <bool>(4, false);

            SwaptionVolCube1x volCube = new SwaptionVolCube1x
                                            (vars.atmVolMatrix, vars.cube.tenors.options, vars.cube.tenors.swaps, vars.cube.strikeSpreads,
                                            vars.cube.volSpreadsHandle, vars.swapIndexBase, vars.shortSwapIndexBase, vars.vegaWeighedSmileFit,
                                            parametersGuess, isParameterFixed, true);
            double tolerance = 3.0e-4;

            vars.makeAtmVolTest(volCube, tolerance);

            tolerance = 12.0e-4;
            vars.makeVolSpreadsTest(volCube, tolerance);
        }
Example #2
0
        public void testObservability()
        {
            // Testing volatility cube observability
            CommonVars vars = new CommonVars();

            List <List <Handle <Quote> > > parametersGuess =
                new InitializedList <List <Handle <Quote> > >(vars.cube.tenors.options.Count * vars.cube.tenors.swaps.Count);

            for (int i = 0; i < vars.cube.tenors.options.Count * vars.cube.tenors.swaps.Count; i++)
            {
                parametersGuess[i]    = new InitializedList <Handle <Quote> >(4);
                parametersGuess[i][0] = new Handle <Quote>(new SimpleQuote(0.2));
                parametersGuess[i][1] = new Handle <Quote>(new SimpleQuote(0.5));
                parametersGuess[i][2] = new Handle <Quote>(new SimpleQuote(0.4));
                parametersGuess[i][3] = new Handle <Quote>(new SimpleQuote(0.0));
            }
            List <bool> isParameterFixed = new InitializedList <bool>(4, false);

            SwaptionVolCube1x volCube1_0, volCube1_1;

            // VolCube created before change of reference date
            volCube1_0 = new SwaptionVolCube1x(vars.atmVolMatrix,
                                               vars.cube.tenors.options,
                                               vars.cube.tenors.swaps,
                                               vars.cube.strikeSpreads,
                                               vars.cube.volSpreadsHandle,
                                               vars.swapIndexBase,
                                               vars.shortSwapIndexBase,
                                               vars.vegaWeighedSmileFit,
                                               parametersGuess,
                                               isParameterFixed,
                                               true);

            Date referenceDate = Settings.evaluationDate();

            Settings.setEvaluationDate(vars.conventions.calendar.advance(referenceDate, new Period(1, TimeUnit.Days),
                                                                         vars.conventions.optionBdc));

            // VolCube created after change of reference date
            volCube1_1 = new SwaptionVolCube1x(vars.atmVolMatrix,
                                               vars.cube.tenors.options,
                                               vars.cube.tenors.swaps,
                                               vars.cube.strikeSpreads,
                                               vars.cube.volSpreadsHandle,
                                               vars.swapIndexBase,
                                               vars.shortSwapIndexBase,
                                               vars.vegaWeighedSmileFit,
                                               parametersGuess,
                                               isParameterFixed,
                                               true);
            double dummyStrike = 0.03;

            for (int i = 0; i < vars.cube.tenors.options.Count; i++)
            {
                for (int j = 0; j < vars.cube.tenors.swaps.Count; j++)
                {
                    for (int k = 0; k < vars.cube.strikeSpreads.Count; k++)
                    {
                        double v0 = volCube1_0.volatility(vars.cube.tenors.options[i],
                                                          vars.cube.tenors.swaps[j],
                                                          dummyStrike + vars.cube.strikeSpreads[k],
                                                          false);
                        double v1 = volCube1_1.volatility(vars.cube.tenors.options[i],
                                                          vars.cube.tenors.swaps[j],
                                                          dummyStrike + vars.cube.strikeSpreads[k],
                                                          false);
                        if (Math.Abs(v0 - v1) > 1e-14)
                        {
                            QAssert.Fail(" option tenor = " + vars.cube.tenors.options[i] +
                                         " swap tenor = " + vars.cube.tenors.swaps[j] +
                                         " strike = " + (dummyStrike + vars.cube.strikeSpreads[k]) +
                                         "  v0 = " + (v0) +
                                         "  v1 = " + (v1) +
                                         "  error = " + Math.Abs(v1 - v0));
                        }
                    }
                }
            }

            Settings.setEvaluationDate(referenceDate);

            SwaptionVolCube2 volCube2_0, volCube2_1;

            // VolCube created before change of reference date
            volCube2_0 = new SwaptionVolCube2(vars.atmVolMatrix,
                                              vars.cube.tenors.options,
                                              vars.cube.tenors.swaps,
                                              vars.cube.strikeSpreads,
                                              vars.cube.volSpreadsHandle,
                                              vars.swapIndexBase,
                                              vars.shortSwapIndexBase,
                                              vars.vegaWeighedSmileFit);
            Settings.setEvaluationDate(vars.conventions.calendar.advance(referenceDate, new Period(1, TimeUnit.Days),
                                                                         vars.conventions.optionBdc));

            // VolCube created after change of reference date
            volCube2_1 = new SwaptionVolCube2(vars.atmVolMatrix,
                                              vars.cube.tenors.options,
                                              vars.cube.tenors.swaps,
                                              vars.cube.strikeSpreads,
                                              vars.cube.volSpreadsHandle,
                                              vars.swapIndexBase,
                                              vars.shortSwapIndexBase,
                                              vars.vegaWeighedSmileFit);

            for (int i = 0; i < vars.cube.tenors.options.Count; i++)
            {
                for (int j = 0; j < vars.cube.tenors.swaps.Count; j++)
                {
                    for (int k = 0; k < vars.cube.strikeSpreads.Count; k++)
                    {
                        double v0 = volCube2_0.volatility(vars.cube.tenors.options[i],
                                                          vars.cube.tenors.swaps[j],
                                                          dummyStrike + vars.cube.strikeSpreads[k],
                                                          false);
                        double v1 = volCube2_1.volatility(vars.cube.tenors.options[i],
                                                          vars.cube.tenors.swaps[j],
                                                          dummyStrike + vars.cube.strikeSpreads[k],
                                                          false);
                        if (Math.Abs(v0 - v1) > 1e-14)
                        {
                            QAssert.Fail(" option tenor = " + vars.cube.tenors.options[i] +
                                         " swap tenor = " + vars.cube.tenors.swaps[j] +
                                         " strike = " + (dummyStrike + vars.cube.strikeSpreads[k]) +
                                         "  v0 = " + (v0) +
                                         "  v1 = " + (v1) +
                                         "  error = " + Math.Abs(v1 - v0));
                        }
                    }
                }
            }

            Settings.setEvaluationDate(referenceDate);
        }