crossassetmodel2.cpp

Go to the documentation of this file.

/*
 Copyright (C) 2016 Quaternion Risk Management Ltd
 All rights reserved.
 
 This file is part of ORE, a free-software/open-source library
 for transparent pricing and risk analysis - http://opensourcerisk.org
 
 ORE is free software: you can redistribute it and/or modify it
 under the terms of the Modified BSD License.  You should have received a
 copy of the license along with this program.
 The license is also available online at <http://opensourcerisk.org>
 
 This program is distributed on the basis that it will form a useful
 contribution to risk analytics and model standardisation, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
*/
 
#include "toplevelfixture.hpp"
#include "utilities.hpp"
#include <boost/test/unit_test.hpp>
#include <qle/methods/multipathgeneratorbase.hpp>
#include <qle/models/cdsoptionhelper.hpp>
#include <qle/models/cpicapfloorhelper.hpp>
#include <qle/models/crlgm1fparametrization.hpp>
#include <qle/models/crossassetanalytics.hpp>
#include <qle/models/crossassetanalyticsbase.hpp>
#include <qle/models/crossassetmodel.hpp>
#include <qle/models/crossassetmodelimpliedeqvoltermstructure.hpp>
#include <qle/models/crossassetmodelimpliedfxvoltermstructure.hpp>
#include <qle/models/dkimpliedyoyinflationtermstructure.hpp>
#include <qle/models/dkimpliedzeroinflationtermstructure.hpp>
#include <qle/models/eqbsconstantparametrization.hpp>
#include <qle/models/eqbsparametrization.hpp>
#include <qle/models/eqbspiecewiseconstantparametrization.hpp>
#include <qle/models/fxbsconstantparametrization.hpp>
#include <qle/models/fxbsparametrization.hpp>
#include <qle/models/fxbspiecewiseconstantparametrization.hpp>
#include <qle/models/fxeqoptionhelper.hpp>
#include <qle/models/gaussian1dcrossassetadaptor.hpp>
#include <qle/models/infdkparametrization.hpp>
#include <qle/models/irlgm1fconstantparametrization.hpp>
#include <qle/models/irlgm1fparametrization.hpp>
#include <qle/models/irlgm1fpiecewiseconstanthullwhiteadaptor.hpp>
#include <qle/models/irlgm1fpiecewiseconstantparametrization.hpp>
#include <qle/models/irlgm1fpiecewiselinearparametrization.hpp>
#include <qle/models/lgm.hpp>
#include <qle/models/lgmimplieddefaulttermstructure.hpp>
#include <qle/models/lgmimpliedyieldtermstructure.hpp>
#include <qle/models/linkablecalibratedmodel.hpp>
#include <qle/models/parametrization.hpp>
#include <qle/models/piecewiseconstanthelper.hpp>
#include <qle/models/pseudoparameter.hpp>
#include <qle/pricingengines/analyticcclgmfxoptionengine.hpp>
#include <qle/pricingengines/analyticdkcpicapfloorengine.hpp>
#include <qle/pricingengines/analyticlgmcdsoptionengine.hpp>
#include <qle/pricingengines/analyticlgmswaptionengine.hpp>
#include <qle/pricingengines/analyticxassetlgmeqoptionengine.hpp>
#include <qle/pricingengines/blackcdsoptionengine.hpp>
#include <qle/pricingengines/crossccyswapengine.hpp>
#include <qle/pricingengines/depositengine.hpp>
#include <qle/pricingengines/discountingcommodityforwardengine.hpp>
#include <qle/pricingengines/discountingcurrencyswapengine.hpp>
#include <qle/pricingengines/discountingequityforwardengine.hpp>
#include <qle/pricingengines/discountingfxforwardengine.hpp>
#include <qle/pricingengines/discountingriskybondengine.hpp>
#include <qle/pricingengines/discountingswapenginemulticurve.hpp>
#include <qle/pricingengines/numericlgmmultilegoptionengine.hpp>
#include <qle/pricingengines/oiccbasisswapengine.hpp>
#include <qle/pricingengines/paymentdiscountingengine.hpp>
 
#include <ql/currencies/all.hpp>
#include <ql/indexes/ibor/euribor.hpp>
#include <ql/instruments/vanillaoption.hpp>
#include <ql/math/matrixutilities/symmetricschurdecomposition.hpp>
#include <ql/math/optimization/levenbergmarquardt.hpp>
#include <ql/math/randomnumbers/rngtraits.hpp>
#include <ql/math/statistics/incrementalstatistics.hpp>
#include <ql/methods/montecarlo/multipathgenerator.hpp>
#include <ql/methods/montecarlo/pathgenerator.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/time/calendars/target.hpp>
#include <ql/time/daycounters/actual360.hpp>
#include <ql/time/daycounters/actualactual.hpp>
#include <ql/time/daycounters/thirty360.hpp>
 
#include <boost/make_shared.hpp>
// fix for boost 1.64, see https://lists.boost.org/Archives/boost/2016/11/231756.php
#if BOOST_VERSION >= 106400
#include <boost/serialization/array_wrapper.hpp>
#endif
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/covariance.hpp>
#include <boost/accumulators/statistics/error_of_mean.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/variates/covariate.hpp>
 
using namespace QuantLib;
using namespace QuantExt;
 
using boost::unit_test_framework::test_suite;
using namespace boost::accumulators;
 
namespace {
 
struct Lgm31fTestData {
    Lgm31fTestData()
        : refDate(18, Dec, 2015),
          yts(QuantLib::ext::make_shared<FlatForward>(refDate, 0.02, ActualActual(ActualActual::ISDA))) {
 
        Settings::instance().evaluationDate() = refDate;
        Size tmp[31] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 16, 17, 18,
                         19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 13, 29, 14, 30, 15 };
        for (Size i = 0; i < 31; ++i) {
            mapping[i] = tmp[i];
            invMapping[mapping[i]] = i;
        }
 
        // ========================================================
        // correlation matrix (13 ccy, 12 fx, 3 inf pairs (CPI,RR))
        // ========================================================
 
        // we map the CPI index and RR to pseudo-FX components here,
        // therefore non EUR inflation components (i.e. the UK region)
        // will produce deviating results, since implicitly we assume
        // EUR as the inflation currency
 
        // also, we have a mapping from the original indices to the new
        // indices because of the CPI components, as follows
        // (original => here)
        // 0-12 => 0-12
        // 13-24 => 16-27
        // 25 => 28
        // 26 => 13
        // 27 => 29
        // 28 => 14
        // 29 => 30
        // 30 => 15
 
        // the procution correlation matrix is replaced with a random matrix
        Real cTmp[31][31] = {
            { 1,
              0.0343941943887,
              0.0419721265321,
              -0.142932369598,
              -0.386557229367,
              0.295980379198,
              0.239653818382,
              -0.0763295458047,
              0.212498186632,
              0.118054743124,
              -0.224766256083,
              0.0853451819853,
              -0.0511995874871,
              0.174426283844,
              -0.115460813133,
              -0.0721582349166,
              -0.214211359774,
              -0.372084086492,
              0.0469382929157,
              0.30664207438,
              -0.133293417835,
              0.0548758513486,
              0.189912198964,
              -0.0998094066064,
              0.116105136048,
              -0.199567439204,
              -0.179792210522,
              -0.453605090893,
              0.0344684113421,
              -0.132400972608,
              -0.0805829297654 },
            { 0.0343941943887,  1,
              -0.147392177981,  0.190600641536,
              -0.145481590883,  0.294365640605,
              0.0601368008482,  -0.00283945283275,
              -0.116431730925,  -0.0716820259802,
              0.00544003244763, -0.0758559072172,
              -0.237919974947,  0.000824706024761,
              0.179058963744,   0.132955192962,
              -0.167456315193,  -0.140212134815,
              0.270173086657,   0.0461584452481,
              0.174592984613,   0.479050202449,
              0.231241635614,   -0.365940995584,
              -0.0300723876502, -0.0105021785277,
              -0.0793226259723, 0.0364552498451,
              -0.0428313590286, 0.00045179600518,
              0.157958640397 },
            { 0.0419721265321,  -0.147392177981, 1,
              -0.205721605587,  0.176351903075,  -0.173886364182,
              -0.176531389565,  0.0171718091121, -0.161928720878,
              -0.223807424589,  0.227847712733,  -0.129833355428,
              -0.0765470112144, 0.0603061533934, -0.184873264163,
              -0.0392532615883, 0.103720246234,  0.185194385726,
              0.00352650332331, 0.147170801505,  0.138074664199,
              -0.0750107965393, -0.075044498716, -0.135712263795,
              0.0435965536933,  -0.196699468487, -0.133209415874,
              0.0669018267551,  0.0411062492118, 0.10827807138,
              0.285547544897 },
            { -0.142932369598,  0.190600641536,   -0.205721605587, 1,
              0.111438752029,   -0.154504285602,  -0.240592717398, 0.228776139817,
              -0.0408638740298, 0.139994885856,   0.010428290396,  -0.0266321253259,
              0.235772909297,   -0.0550148577982, 0.011581957914,  -0.0958782780357,
              -0.0356439790974, 0.167623910315,   0.282668618187,  -0.116049244115,
              0.0378447443195,  0.416830955389,   0.125613729312,  0.0751289225199,
              0.0474611193829,  0.119515798352,   -0.186354768062, 0.00463486576889,
              0.0895319580574,  -0.42296528782,   -0.0250457680104 },
            { -0.386557229367,  -0.145481590883,  0.176351903075,   0.111438752029,   1,
              -0.0948655518868, -0.156442491224,  0.091693504433,   -0.037767000351,  -0.235460535367,
              0.0676834096513,  -0.36550450905,   0.013058702437,   0.173947911446,   -0.0894751146898,
              -0.0697842787023, 0.330415682457,   0.105948381112,   0.213956029639,   -0.306516644502,
              0.03156673834,    -0.0438700627351, -0.0471934284693, -0.0479093575566, -0.191764263322,
              0.0691491923609,  -0.0169112375186, 0.418856276254,   -0.587952407744,  -0.11074678055,
              0.118830155093 },
            { 0.295980379198,  0.294365640605,   -0.173886364182, -0.154504285602, -0.0948655518868, 1,
              0.312150303064,  -0.296339376122,  0.222818035874,  -0.333383472886, 0.045665647834,   -0.178734828838,
              0.233294477666,  0.00914551279587, 0.16991477323,   0.237871041338,  -0.107953837139,  -0.196472981313,
              -0.197667927622, 0.243660580044,   0.283222098211,  0.255181424113,  0.0738214833113,  -0.0875506146088,
              0.0228176567117, -0.021839186816,  -0.200983147135, 0.118339983121,  -0.0380308812843, 0.0697554664965,
              -0.290573412107 },
            { 0.239653818382,
              0.0601368008482,
              -0.176531389565,
              -0.240592717398,
              -0.156442491224,
              0.312150303064,
              1,
              0.16427616005,
              0.187114559514,
              -0.128567362633,
              -0.0298087283209,
              0.310220353467,
              -0.155650952549,
              -0.0907943245024,
              0.150077574282,
              0.233831100752,
              0.14510564225,
              -0.106158234925,
              -0.186638489406,
              0.108493899313,
              0.186677617029,
              0.154962485957,
              0.0976503099009,
              0.33619746008,
              -0.312902806374,
              0.0140051435466,
              -0.190085542485,
              0.123111359938,
              -0.168127163542,
              0.242451056895,
              -0.232220701345 },
            { -0.0763295458047, -0.00283945283275, 0.0171718091121,  0.228776139817,
              0.091693504433,   -0.296339376122,   0.16427616005,    1,
              0.129840657268,   0.373604952144,    -0.18155715237,   0.184536654159,
              -0.12285053934,   -0.103909813725,   0.178625377032,   -0.127501582044,
              0.184446540159,   -0.127735616891,   0.147895324128,   -0.0107588297873,
              -0.0821799717041, -0.151013843371,   0.390822002417,   -0.164177564227,
              -0.199345876795,  0.154417641829,    0.00493479680788, 0.264074419131,
              -0.106509969327,  0.132504591079,    0.118207101753 },
            { 0.212498186632,   -0.116431730925, -0.161928720878,
              -0.0408638740298, -0.037767000351, 0.222818035874,
              0.187114559514,   0.129840657268,  1,
              0.108639498651,   -0.111431570017, -0.132299603334,
              0.129609578068,   -0.277997943625, 0.0906182176236,
              -0.0864325336051, 0.186001578615,  -0.113884465526,
              -0.0294749190212, 0.454853572071,  -0.246249803796,
              -0.0266738922467, 0.0933959821836, 0.224461162875,
              0.0357834934973,  0.0616445434762, -0.276568357088,
              -0.393316724461,  -0.223125458693, 0.133084418997,
              -0.0221629196894 },
            { 0.118054743124,  -0.0716820259802, -0.223807424589, 0.139994885856,   -0.235460535367,
              -0.333383472886, -0.128567362633,  0.373604952144,  0.108639498651,   1,
              -0.095793838259, 0.190541253672,   -0.107707903939, 0.12756217432,    -0.117262111977,
              -0.509787601852, -0.108689074131,  -0.324588172992, 0.051847818326,   0.0322332954595,
              -0.386223228013, -0.124632351583,  0.106212483012,  -0.0762653306681, 0.014765861204,
              -0.150505016721, 0.311501433571,   -0.177761397412, -0.0501147422963, -0.288372982612,
              -0.185072823068 },
            { -0.224766256083,
              0.00544003244763,
              0.227847712733,
              0.010428290396,
              0.0676834096513,
              0.045665647834,
              -0.0298087283209,
              -0.18155715237,
              -0.111431570017,
              -0.095793838259,
              1,
              0.0693613681381,
              0.14249383007,
              0.096010698022,
              0.0329554088922,
              0.167604841583,
              -0.109041125342,
              0.00514826039023,
              -0.340130764259,
              0.182645718058,
              0.321991863536,
              0.214142882681,
              -0.0987553659026,
              0.150628401488,
              0.00422661848883,
              0.109346488736,
              0.23059270105,
              0.140534087809,
              -0.0173708508572,
              0.0528427482968,
              0.0182217569681 },
            { 0.0853451819853,   -0.0758559072172, -0.129833355428, -0.0266321253259,
              -0.36550450905,    -0.178734828838,  0.310220353467,  0.184536654159,
              -0.132299603334,   0.190541253672,   0.0693613681381, 1,
              -0.0132125282718,  0.0140768369271,  0.310955525226,  -0.189708953222,
              0.0488388998416,   -0.0181791685819, 0.11515442249,   -0.0712393291188,
              -0.0911379512289,  -0.117558064762,  0.0978226722782, 0.0494832889518,
              -0.0176606846725,  0.250581766454,   0.209191012806,  -0.143815875961,
              -0.00668495669111, 0.0976950082078,  0.0252520373904 },
            { -0.0511995874871,
              -0.237919974947,
              -0.0765470112144,
              0.235772909297,
              0.013058702437,
              0.233294477666,
              -0.155650952549,
              -0.12285053934,
              0.129609578068,
              -0.107707903939,
              0.14249383007,
              -0.0132125282718,
              1,
              -0.101546509191,
              0.145043037821,
              0.0141222526045,
              -0.239190286473,
              -0.219267351706,
              0.0493026087034,
              -0.145364905371,
              0.0244975164846,
              0.187668533638,
              -0.216542028379,
              0.0784389764486,
              0.207793807098,
              -0.0149171885526,
              0.154689284382,
              0.0874179510403,
              0.197509990962,
              -0.0438009094431,
              -0.00831859585832 },
            { 0.174426283844,   0.000824706024761,
              0.0603061533934,  -0.0550148577982,
              0.173947911446,   0.00914551279587,
              -0.0907943245024, -0.103909813725,
              -0.277997943625,  0.12756217432,
              0.096010698022,   0.0140768369271,
              -0.101546509191,  1,
              -0.254967689473,  0.023478890628,
              0.115201664433,   -0.0570864596218,
              -0.0552759708479, -0.147365625016,
              0.0461995467521,  -0.0168974295344,
              -0.205845653683,  -0.0381073980444,
              -0.0927040293872, 0.0821202714574,
              -0.0171498152037, -0.0834025047453,
              -0.187260914639,  -0.348707805644,
              -0.364440606696 },
            { -0.115460813133, 0.179058963744,   -0.184873264163, 0.011581957914,  -0.0894751146898,
              0.16991477323,   0.150077574282,   0.178625377032,  0.0906182176236, -0.117262111977,
              0.0329554088922, 0.310955525226,   0.145043037821,  -0.254967689473, 1,
              0.0748037899029, 0.294695159049,   -0.213228245006, 0.128441907683,  -0.0150217790452,
              0.0480199310254, -0.0713509454034, 0.197367018953,  -0.243142199375, -0.029497320023,
              0.433216618742,  0.0396133169903,  0.103851408345,  -0.219874832922, 0.296174894116,
              0.168545305888 },
            { -0.0721582349166, 0.132955192962,  -0.0392532615883,  -0.0958782780357,
              -0.0697842787023, 0.237871041338,  0.233831100752,    -0.127501582044,
              -0.0864325336051, -0.509787601852, 0.167604841583,    -0.189708953222,
              0.0141222526045,  0.023478890628,  0.0748037899029,   1,
              -0.010499616039,  0.0804925210972, -0.325690654432,   -0.060487358233,
              0.538581289688,   0.196496308155,  -0.00839726071219, -0.0306510212363,
              -0.060101906245,  0.0793563779709, -0.14609815746,    0.186079456094,
              0.230110905512,   0.143609506491,  -0.0255809432735 },
            { -0.214211359774,
              -0.167456315193,
              0.103720246234,
              -0.0356439790974,
              0.330415682457,
              -0.107953837139,
              0.14510564225,
              0.184446540159,
              0.186001578615,
              -0.108689074131,
              -0.109041125342,
              0.0488388998416,
              -0.239190286473,
              0.115201664433,
              0.294695159049,
              -0.010499616039,
              1,
              0.0636415350089,
              0.198977446582,
              0.102363853401,
              0.145107868245,
              -0.386835660762,
              0.0923139397147,
              0.200427396567,
              -0.510849948347,
              0.492499933089,
              -0.221537617801,
              -0.0594708004309,
              -0.372450613443,
              -0.0359700742084,
              0.102546226539 },
            { -0.372084086492, -0.140212134815,  0.185194385726,   0.167623910315,   0.105948381112,   -0.196472981313,
              -0.106158234925, -0.127735616891,  -0.113884465526,  -0.324588172992,  0.00514826039023, -0.0181791685819,
              -0.219267351706, -0.0570864596218, -0.213228245006,  0.0804925210972,  0.0636415350089,  1,
              -0.245275780278, -0.052398080821,  -0.0188922810343, 0.0085014187696,  -0.0457942205268, 0.161812363359,
              0.236909237629,  0.244605289825,   -0.20847963897,   -0.0224010202566, 0.184642764044,   0.0383411294219,
              -0.107154013475 },
            { 0.0469382929157,
              0.270173086657,
              0.00352650332331,
              0.282668618187,
              0.213956029639,
              -0.197667927622,
              -0.186638489406,
              0.147895324128,
              -0.0294749190212,
              0.051847818326,
              -0.340130764259,
              0.11515442249,
              0.0493026087034,
              -0.0552759708479,
              0.128441907683,
              -0.325690654432,
              0.198977446582,
              -0.245275780278,
              1,
              -0.247362833882,
              -0.193578615193,
              -0.0105721360587,
              0.14336132262,
              -0.112587281635,
              -0.171469357693,
              0.100772472825,
              0.0751101396305,
              0.0700089923819,
              -0.248914435569,
              0.0263247635683,
              0.451050068349 },
            { 0.30664207438,   0.0461584452481,  0.147170801505,   -0.116049244115, -0.306516644502,
              0.243660580044,  0.108493899313,   -0.0107588297873, 0.454853572071,  0.0322332954595,
              0.182645718058,  -0.0712393291188, -0.145364905371,  -0.147365625016, -0.0150217790452,
              -0.060487358233, 0.102363853401,   -0.052398080821,  -0.247362833882, 1,
              0.136263767432,  -0.137495220906,  -0.127307183268,  0.0972788938582, 0.00258934288855,
              -0.130331299046, -0.428102669619,  -0.263740815975,  0.0737931248832, 0.301730685794,
              -0.110280327757 },
            { -0.133293417835, 0.174592984613,   0.138074664199,
              0.0378447443195, 0.03156673834,    0.283222098211,
              0.186677617029,  -0.0821799717041, -0.246249803796,
              -0.386223228013, 0.321991863536,   -0.0911379512289,
              0.0244975164846, 0.0461995467521,  0.0480199310254,
              0.538581289688,  0.145107868245,   -0.0188922810343,
              -0.193578615193, 0.136263767432,   1,
              0.0250867014821, -0.207548146929,  0.141487666396,
              -0.332927391225, 0.043757104046,   -0.26277621567,
              0.28995584194,   0.13757556845,    -0.061923788279,
              0.0464984161357 },
            { 0.0548758513486,  0.479050202449,
              -0.0750107965393, 0.416830955389,
              -0.0438700627351, 0.255181424113,
              0.154962485957,   -0.151013843371,
              -0.0266738922467, -0.124632351583,
              0.214142882681,   -0.117558064762,
              0.187668533638,   -0.0168974295344,
              -0.0713509454034, 0.196496308155,
              -0.386835660762,  0.0085014187696,
              -0.0105721360587, -0.137495220906,
              0.0250867014821,  1,
              0.148426221032,   -0.0796451648888,
              0.121998419258,   -0.120561962297,
              0.0039300328991,  -0.0616564684715,
              0.0834127185137,  -0.194091860738,
              -0.0540900287065 },
            { 0.189912198964,
              0.231241635614,
              -0.075044498716,
              0.125613729312,
              -0.0471934284693,
              0.0738214833113,
              0.0976503099009,
              0.390822002417,
              0.0933959821836,
              0.106212483012,
              -0.0987553659026,
              0.0978226722782,
              -0.216542028379,
              -0.205845653683,
              0.197367018953,
              -0.00839726071219,
              0.0923139397147,
              -0.0457942205268,
              0.14336132262,
              -0.127307183268,
              -0.207548146929,
              0.148426221032,
              1,
              -0.197544922079,
              -0.0620733221402,
              0.337598014925,
              0.115127292041,
              -0.191005066833,
              -0.0542551151481,
              -0.150856466315,
              0.287965489293 },
            { -0.0998094066064, -0.365940995584,  -0.135712263795, 0.0751289225199,  -0.0479093575566, -0.0875506146088,
              0.33619746008,    -0.164177564227,  0.224461162875,  -0.0762653306681, 0.150628401488,   0.0494832889518,
              0.0784389764486,  -0.0381073980444, -0.243142199375, -0.0306510212363, 0.200427396567,   0.161812363359,
              -0.112587281635,  0.0972788938582,  0.141487666396,  -0.0796451648888, -0.197544922079,  1,
              -0.455928132901,  -0.0349650249016, -0.147487712981, -0.123072528825,  0.0016310683966,  -0.0929856384075,
              -0.0844827518471 },
            { 0.116105136048,   -0.0300723876502, 0.0435965536933,  0.0474611193829,  -0.191764263322,
              0.0228176567117,  -0.312902806374,  -0.199345876795,  0.0357834934973,  0.014765861204,
              0.00422661848883, -0.0176606846725, 0.207793807098,   -0.0927040293872, -0.029497320023,
              -0.060101906245,  -0.510849948347,  0.236909237629,   -0.171469357693,  0.00258934288855,
              -0.332927391225,  0.121998419258,   -0.0620733221402, -0.455928132901,  1,
              -0.0366860627562, 0.0789958683979,  -0.130701036026,  0.25671818269,    0.0196168003514,
              -0.102190074804 },
            { -0.199567439204,  -0.0105021785277,
              -0.196699468487,  0.119515798352,
              0.0691491923609,  -0.021839186816,
              0.0140051435466,  0.154417641829,
              0.0616445434762,  -0.150505016721,
              0.109346488736,   0.250581766454,
              -0.0149171885526, 0.0821202714574,
              0.433216618742,   0.0793563779709,
              0.492499933089,   0.244605289825,
              0.100772472825,   -0.130331299046,
              0.043757104046,   -0.120561962297,
              0.337598014925,   -0.0349650249016,
              -0.0366860627562, 1,
              -0.0794978681331, -0.0982755084996,
              -0.206145124721,  0.084681240391,
              -0.0748773856947 },
            { -0.179792210522, -0.0793226259723,  -0.133209415874,
              -0.186354768062, -0.0169112375186,  -0.200983147135,
              -0.190085542485, 0.00493479680788,  -0.276568357088,
              0.311501433571,  0.23059270105,     0.209191012806,
              0.154689284382,  -0.0171498152037,  0.0396133169903,
              -0.14609815746,  -0.221537617801,   -0.20847963897,
              0.0751101396305, -0.428102669619,   -0.26277621567,
              0.0039300328991, 0.115127292041,    -0.147487712981,
              0.0789958683979, -0.0794978681331,  1,
              0.166530515474,  -0.00626506702444, -0.105755638618,
              0.17213920952 },
            { -0.453605090893,  0.0364552498451,  0.0669018267551, 0.00463486576889,
              0.418856276254,   0.118339983121,   0.123111359938,  0.264074419131,
              -0.393316724461,  -0.177761397412,  0.140534087809,  -0.143815875961,
              0.0874179510403,  -0.0834025047453, 0.103851408345,  0.186079456094,
              -0.0594708004309, -0.0224010202566, 0.0700089923819, -0.263740815975,
              0.28995584194,    -0.0616564684715, -0.191005066833, -0.123072528825,
              -0.130701036026,  -0.0982755084996, 0.166530515474,  1,
              -0.170804441061,  0.392158807614,   -0.0667901382994 },
            { 0.0344684113421,
              -0.0428313590286,
              0.0411062492118,
              0.0895319580574,
              -0.587952407744,
              -0.0380308812843,
              -0.168127163542,
              -0.106509969327,
              -0.223125458693,
              -0.0501147422963,
              -0.0173708508572,
              -0.00668495669111,
              0.197509990962,
              -0.187260914639,
              -0.219874832922,
              0.230110905512,
              -0.372450613443,
              0.184642764044,
              -0.248914435569,
              0.0737931248832,
              0.13757556845,
              0.0834127185137,
              -0.0542551151481,
              0.0016310683966,
              0.25671818269,
              -0.206145124721,
              -0.00626506702444,
              -0.170804441061,
              1,
              -0.0642244501279,
              0.116777659542 },
            { -0.132400972608,  0.00045179600518, 0.10827807138,   -0.42296528782,  -0.11074678055,   0.0697554664965,
              0.242451056895,   0.132504591079,   0.133084418997,  -0.288372982612, 0.0528427482968,  0.0976950082078,
              -0.0438009094431, -0.348707805644,  0.296174894116,  0.143609506491,  -0.0359700742084, 0.0383411294219,
              0.0263247635683,  0.301730685794,   -0.061923788279, -0.194091860738, -0.150856466315,  -0.0929856384075,
              0.0196168003514,  0.084681240391,   -0.105755638618, 0.392158807614,  -0.0642244501279, 1,
              0.0494702308271 },
            { -0.0805829297654,
              0.157958640397,
              0.285547544897,
              -0.0250457680104,
              0.118830155093,
              -0.290573412107,
              -0.232220701345,
              0.118207101753,
              -0.0221629196894,
              -0.185072823068,
              0.0182217569681,
              0.0252520373904,
              -0.00831859585832,
              -0.364440606696,
              0.168545305888,
              -0.0255809432735,
              0.102546226539,
              -0.107154013475,
              0.451050068349,
              -0.110280327757,
              0.0464984161357,
              -0.0540900287065,
              0.287965489293,
              -0.0844827518471,
              -0.102190074804,
              -0.0748773856947,
              0.17213920952,
              -0.0667901382994,
              0.116777659542,
              0.0494702308271,
              1 },
        };
 
        rho = Matrix(31, 31);
        for (Size i = 0; i < 31; ++i) {
            for (Size j = 0; j < 31; ++j) {
                rho[mapping[i]][mapping[j]] = cTmp[i][j];
            }
        }
 
        // =========================================
        // IR components
        // =========================================
 
        Period irTen[] = { 3 * Months, 6 * Months, 1 * Years,  4 * Years,  6 * Years,  8 * Years,
                           10 * Years, 12 * Years, 14 * Years, 16 * Years, 24 * Years, 28 * Years,
                           30 * Years, 35 * Years, 40 * Years, 45 * Years, 50 * Years };
 
        Array irTimes(LENGTH(irTen));
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            irTimes[i] = ActualActual(ActualActual::ISDA).yearFraction(refDate, TARGET().advance(refDate, irTen[i]));
        }
        // for parametrization set up (without last time)
        Array irTimes2(irTimes.begin(), irTimes.end() - 1);
 
        QuantLib::ext::shared_ptr<IrLgm1fParametrization> tmpIr;
 
        // dummy yts (we check covariances here for which the yts does not
        // matter)
        Handle<YieldTermStructure> yts(
            QuantLib::ext::make_shared<FlatForward>(refDate, 0.02, ActualActual(ActualActual::ISDA)));
 
        Array alpha(LENGTH(irTen)), lambda(LENGTH(irTen));
 
        // IR #1 EUR
        Real H_EUR[] = { 0.24842958, 0.49885636, 0.99512038, 3.9210561, 5.8235466, 7.6883654,
                         9.5162582,  11.307956,  13.064176,  14.785621, 21.337214, 24.421626,
                         25.918178,  29.531191,  32.967995,  36.237252, 39.346934 };
        Real zeta_EUR[] = { 9.0701982e-06, 1.0608339e-05, 1.1620875e-05, 0.00015177493, 0.00031122807, 0.00046892033,
                            0.00061743761, 0.00075125711, 0.00089906517, 0.001101485,   0.0016151376,  0.0018395256,
                            0.0020329435,  0.0026210991,  0.0032963998,  0.004125193,   0.0045825323 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_EUR[i] - (i == 0 ? 0.0 : zeta_EUR[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
            lambda[i] =
                std::sqrt((H_EUR[i] - (i == 0 ? 0.0 : H_EUR[i - 1])) / (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(EURCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #2 GBP (H is shared between all currencies)
        Real zeta_GBP[] = { 5.3989367e-06, 9.8331458e-06, 4.6388054e-05, 0.00040863507, 0.00062437912, 0.00076368123,
                            0.00083880053, 0.00097274237, 0.0011247902,  0.0011807996,  0.0016212442,  0.0016897153,
                            0.0019250142,  0.0023629707,  0.0028444473,  0.0033775638,  0.0035846398 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_GBP[i] - (i == 0 ? 0.0 : zeta_GBP[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(GBPCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #3 USD
        Real zeta_USD[] = { 2.0116489e-06, 9.869679e-06,  3.8294263e-05, 0.00035235619, 0.00056544819, 0.00071428218,
                            0.00086773977, 0.00096413044, 0.0010223302,  0.0011499527,  0.0015443309,  0.0017400941,
                            0.0019520896,  0.0024675239,  0.0030556253,  0.0037297585,  0.0040647036 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_USD[i] - (i == 0 ? 0.0 : zeta_USD[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(USDCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #4 JPY
        Real zeta_JPY[] = { 2.3553293e-07, 4.7232546e-07, 1.6760723e-06, 2.7562061e-05, 7.5069821e-05, 0.00016052372,
                            0.00032273232, 0.00070327448, 0.00082690882, 0.0014144869,  0.0019465284,  0.0019707646,
                            0.00219778,    0.0026321698,  0.0030966507,  0.0035997538,  0.0037455693 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_JPY[i] - (i == 0 ? 0.0 : zeta_JPY[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(JPYCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #5 AUD
        Real zeta_AUD[] = { 7.7367295e-06, 1.3455117e-05, 3.6148337e-05, 0.00035739546, 0.0006449375, 0.0010106854,
                            0.0014263234,  0.001839049,   0.0021976553,  0.0027602048,  0.0038615771, 0.0038724338,
                            0.0043593179,  0.0054144983,  0.0065917297,  0.0079097947,  0.0086340945 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_AUD[i] - (i == 0 ? 0.0 : zeta_AUD[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(AUDCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #6 CAD
        Real zeta_CAD[] = { 7.1764671e-06, 1.199943e-05,  3.0336942e-05, 0.00023188566, 0.00038850625, 0.00050854554,
                            0.0005611467,  0.00071498642, 0.0008629815,  0.00087117906, 0.0010263932,  0.0011534502,
                            0.0013161557,  0.0016666467,  0.0020675357,  0.0025277164,  0.00275934 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_CAD[i] - (i == 0 ? 0.0 : zeta_CAD[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(CADCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #7 CHF
        Real zeta_CHF[] = { 2.0285111e-06, 1.1611047e-05, 1.4434095e-05, 4.6520687e-05, 0.00031520268, 0.00067093245,
                            0.00078748667, 0.0010554702,  0.0011654964,  0.0014978801,  0.0018047495,  0.0018047762,
                            0.0019504756,  0.0022601499,  0.0025871501,  0.0029619175,  0.0031895455 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_CHF[i] - (i == 0 ? 0.0 : zeta_CHF[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(CHFCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #8 DKK
        Real zeta_DKK[] = { 3.95942e-06,  1.6524019e-05, 2.7177507e-05, 0.00029766543, 0.00065437464, 0.001221066,
                            0.0017487336, 0.0021895397,  0.0025464983,  0.0027541051,  0.0027541403,  0.0028892292,
                            0.0031707705, 0.0037313519,  0.0043215627,  0.0049612987,  0.0052460193 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_DKK[i] - (i == 0 ? 0.0 : zeta_DKK[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(DKKCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #9 NOK
        Real zeta_NOK[] = { 2.1747207e-05, 4.2144995e-05, 4.2145974e-05, 0.00036357391, 0.00054458124, 0.00074627758,
                            0.00081604641, 0.00092208188, 0.0011002273,  0.0012189063,  0.0018979681,  0.0019753582,
                            0.0022190637,  0.0027605153,  0.0033563053,  0.0040315714,  0.0044332994 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_NOK[i] - (i == 0 ? 0.0 : zeta_NOK[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(NOKCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #10 PLN
        Real zeta_PLN[] = { 9.0701982e-06, 1.0608339e-05, 1.1620875e-05, 0.00015177493, 0.00031122807, 0.00046892033,
                            0.00061743761, 0.00075125711, 0.00089906517, 0.001101485,   0.0016151376,  0.0018395256,
                            0.0020329435,  0.0026210991,  0.0032963998,  0.004125193,   0.0045825323 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_PLN[i] - (i == 0 ? 0.0 : zeta_PLN[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(PLNCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #11 SEK
        Real zeta_SEK[] = { 6.330515e-06,  7.5521582e-06, 9.9440922e-06, 0.00032860183, 0.0005331322, 0.00071660054,
                            0.00086542894, 0.0011098021,  0.0013293011,  0.0017246094,  0.0027609916, 0.0027611132,
                            0.0030808796,  0.0038392582,  0.0046789792,  0.005628121,   0.0063423051 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_SEK[i] - (i == 0 ? 0.0 : zeta_SEK[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(SEKCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #12 SGD
        Real zeta_SGD[] = { 9.0701982e-06, 1.0608339e-05, 1.1620875e-05, 0.00015177493, 0.00031122807, 0.00046892033,
                            0.00061743761, 0.00075125711, 0.00089906517, 0.001101485,   0.0016151376,  0.0018395256,
                            0.0020329435,  0.0026210991,  0.0032963998,  0.004125193,   0.0045825323 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_SGD[i] - (i == 0 ? 0.0 : zeta_SGD[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(SGDCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // IR #13 INR
        Real zeta_INR[] = { 9.0701982e-06, 1.0608339e-05, 1.1620875e-05, 0.00015177493, 0.00031122807, 0.00046892033,
                            0.00061743761, 0.00075125711, 0.00089906517, 0.001101485,   0.0016151376,  0.0018395256,
                            0.0020329435,  0.0026210991,  0.0032963998,  0.004125193,   0.0045825323 };
        for (Size i = 0; i < LENGTH(irTen); ++i) {
            alpha[i] = std::sqrt((zeta_INR[i] - (i == 0 ? 0.0 : zeta_INR[i - 1])) /
                                 (irTimes[i] - (i == 0 ? 0.0 : irTimes[i - 1])));
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(INRCurrency(), yts, irTimes2, alpha, irTimes2,
                                                                          lambda);
        parametrizations.push_back(tmpIr);
 
        // =========================================
        // Inflation RR (as IR component here)
        // =========================================
 
        Period inflTen[] = { 1 * Years,  2 * Years,  3 * Years,  5 * Years, 7 * Years,
                             12 * Years, 15 * Years, 20 * Years, 30 * Years };
 
        Array inflTimes(LENGTH(inflTen));
        for (Size i = 0; i < LENGTH(inflTen); ++i) {
            inflTimes[i] = ActualActual(ActualActual::ISDA).yearFraction(refDate, TARGET().advance(refDate, inflTen[i]));
        }
        // for parametrization set up (without last time)
        Array inflTimes2(inflTimes.begin(), inflTimes.end() - 1);
        Array alphaInfl(LENGTH(inflTen)), lambdaInfl(LENGTH(inflTen));
 
        // IR #14 BGL = RR INFL EUR
 
        Real H_BGL[] = { 0.473128, 1.068300, 1.555252, 2.527081, 3.611487, 6.076270, 7.369295, 9.429210, 13.319564 };
        Real alpha_BGL[] = { 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02 };
        for (Size i = 0; i < LENGTH(inflTen); ++i) {
            lambdaInfl[i] = std::sqrt((H_BGL[i] - (i == 0 ? 0.0 : H_BGL[i - 1])) /
                                      (inflTimes[i] - (i == 0 ? 0.0 : inflTimes[i - 1])));
            alphaInfl[i] = alpha_BGL[i];
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(BGLCurrency(), yts, inflTimes2, alphaInfl,
                                                                          inflTimes2, lambdaInfl);
        parametrizations.push_back(tmpIr);
 
        // IR #16 BYR = RR INFL UK
 
        Real H_BYR[] = { 1.062214, 2.161263, 3.073939, 4.861583, 6.515747, 10.324476, 12.390876, 15.568734, 21.145007 };
        Real alpha_BYR[] = { 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02 };
        for (Size i = 0; i < LENGTH(inflTen); ++i) {
            lambdaInfl[i] = std::sqrt((H_BYR[i] - (i == 0 ? 0.0 : H_BYR[i - 1])) /
                                      (inflTimes[i] - (i == 0 ? 0.0 : inflTimes[i - 1])));
            alphaInfl[i] = alpha_BYR[i];
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(BYRCurrency(), yts, inflTimes2, alphaInfl,
                                                                          inflTimes2, lambdaInfl);
        parametrizations.push_back(tmpIr);
 
        // IR #17 BYR = RR INFL FR
 
        Real H_CZK[] = { 1.024666, 1.290138, 1.655453, 2.250962, 2.843277, 3.684875, 3.842543, 4.000118, 4.000213 };
        Real alpha_CZK[] = { 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02 };
        for (Size i = 0; i < LENGTH(inflTen); ++i) {
            lambdaInfl[i] = std::sqrt((H_CZK[i] - (i == 0 ? 0.0 : H_CZK[i - 1])) /
                                      (inflTimes[i] - (i == 0 ? 0.0 : inflTimes[i - 1])));
            alphaInfl[i] = alpha_CZK[i];
        }
        tmpIr = QuantLib::ext::make_shared<IrLgm1fPiecewiseLinearParametrization>(CZKCurrency(), yts, inflTimes2, alphaInfl,
                                                                          inflTimes2, lambdaInfl);
        parametrizations.push_back(tmpIr);
 
        // =========================================
        // FX components
        // =========================================
 
        Period fxTen[] = { 3 * Months,  6 * Months,  9 * Months, 12 * Months,
                           15 * Months, 18 * Months, 2 * Years,  3 * Years };
 
        Array fxTimes(LENGTH(fxTen));
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            fxTimes[i] = ActualActual(ActualActual::ISDA).yearFraction(refDate, TARGET().advance(refDate, fxTen[i]));
        }
        // for parametrization set up (without last time)
        Array fxTimes2(fxTimes.begin(), fxTimes.end() - 1);
 
        QuantLib::ext::shared_ptr<FxBsParametrization> tmpFx;
        Array sigma(LENGTH(fxTen));
 
        Handle<Quote> dummyFxSpot(QuantLib::ext::make_shared<SimpleQuote>(1.0));
 
        // FX #1 GBP
 
        Real sigma_GBP[] = { 0.080781, 0.088930, 0.098602, 0.105432, 0.100682, 0.100443, 0.100033, 0.103945 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_GBP[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(GBPCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #2 USD
 
        Real sigma_USD[] = { 0.100489, 0.100483, 0.101916, 0.100875, 0.099272, 0.099088, 0.098720, 0.105264 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_USD[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(USDCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #3 JPY
 
        Real sigma_JPY[] = { 0.088486, 0.100977, 0.109587, 0.112013, 0.115858, 0.115846, 0.115711, 0.122524 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_JPY[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(JPYCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #4 AUD
 
        Real sigma_AUD[] = { 0.125030, 0.123755, 0.123786, 0.122953, 0.123691, 0.123537, 0.123154, 0.121826 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_AUD[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(AUDCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #5 CAD
 
        Real sigma_CAD[] = { 0.113583, 0.109568, 0.108982, 0.109527, 0.110234, 0.110095, 0.109754, 0.108610 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_CAD[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(CADCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #6 CHF
 
        Real sigma_CHF[] = { 0.066449, 0.074224, 0.080625, 0.083341, 0.092719, 0.092715, 0.092488, 0.108220 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_CHF[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(CHFCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #7 DKK
 
        Real sigma_DKK[] = { 0.012913, 0.013110, 0.012621, 0.015782, 0.024053, 0.023408, 0.021574, 0.000000 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_DKK[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(DKKCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #8 NOK
 
        Real sigma_NOK[] = { 0.099987, 0.099916, 0.099795, 0.099668, 0.099532, 0.099321, 0.098811, 0.097166 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_NOK[i];
        }
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(NOKCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #9 PLN
 
        Real sigma_PLN[] = { 0.065094, 0.069539, 0.072197, 0.073313, 0.069963, 0.069777, 0.069391, 0.068027 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_PLN[i];
        }
 
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(PLNCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #10 SEK
 
        Real sigma_SEK[] = { 0.068977, 0.078492, 0.082604, 0.085282, 0.084029, 0.083851, 0.083398, 0.082871 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_SEK[i];
        }
 
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(SEKCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #11 SGD
 
        Real sigma_SGD[] = { 0.149995, 0.149970, 0.149935, 0.149903, 0.149861, 0.149791, 0.149611, 0.148984 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_SGD[i];
        }
 
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(SGDCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #12 INR
 
        Real sigma_INR[] = { 0.100486, 0.100462, 0.101885, 0.100864, 0.099298, 0.099177, 0.098906, 0.105704 };
        for (Size i = 0; i < LENGTH(fxTen); ++i) {
            sigma[i] = sigma_INR[i];
        }
 
        tmpFx = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(INRCurrency(), dummyFxSpot, fxTimes2, sigma);
        parametrizations.push_back(tmpFx);
 
        // FX #13, 14, 15 Inflation CPI EUR, UK, FR
 
        Array notimes(0);
        Array sigma_CPI(1, 0.0075);
 
        tmpFx =
            QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(BGLCurrency(), dummyFxSpot, notimes, sigma_CPI);
        parametrizations.push_back(tmpFx);
        tmpFx =
            QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(BYRCurrency(), dummyFxSpot, notimes, sigma_CPI);
        parametrizations.push_back(tmpFx);
        tmpFx =
            QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(CZKCurrency(), dummyFxSpot, notimes, sigma_CPI);
        parametrizations.push_back(tmpFx);
 
        // =========================================
        // CrossAsset model
        // =========================================
 
        xmodelExact =
            QuantLib::ext::make_shared<CrossAssetModel>(parametrizations, rho, SalvagingAlgorithm::None, IrModel::Measure::LGM,
                                                CrossAssetModel::Discretization::Exact);
        xmodelEuler =
            QuantLib::ext::make_shared<CrossAssetModel>(parametrizations, rho, SalvagingAlgorithm::None, IrModel::Measure::LGM,
                                                CrossAssetModel::Discretization::Euler);
    }
 
    SavedSettings backup;
    Date refDate;
    Size mapping[31], invMapping[31];
    Real c[31][31];
    Matrix rho;
    Handle<YieldTermStructure> yts;
    std::vector<QuantLib::ext::shared_ptr<Parametrization> > parametrizations;
    QuantLib::ext::shared_ptr<CrossAssetModel> xmodelExact, xmodelEuler;
};
 
} // namespace
 
BOOST_FIXTURE_TEST_SUITE(QuantExtTestSuite, qle::test::TopLevelFixture)
 
BOOST_AUTO_TEST_SUITE(CrossAssetModelTest2)
 
BOOST_AUTO_TEST_CASE(testLgm31fPositiveCovariance) {
 
    BOOST_TEST_MESSAGE("Testing for positive semidefinite covariance matrices "
                       "in Ccy LGM 31F model...");
 
    Lgm31fTestData d;
 
    // check eigenvalues of rho (this check is done in the model constructor
    // as well, we cross check this here)
 
    SymmetricSchurDecomposition ssd(d.rho);
    for (Size i = 0; i < ssd.eigenvalues().size(); ++i) {
        if (ssd.eigenvalues()[i] < 0.0) {
            BOOST_ERROR("negative eigenvalue in input matrix (#" << i << ", " << ssd.eigenvalues()[i]);
        }
    }
 
    // =========================================
    // time grid for RFE
    // =========================================
 
    std::vector<Time> simTimes_;
    simTimes_.push_back(0.0);
    for (Size i = 1; i <= 118; ++i) {
        Date tmp = TARGET().advance(d.refDate, i * Months);
        simTimes_.push_back(ActualActual(ActualActual::ISDA).yearFraction(d.refDate, tmp));
    }
    for (Size i = 1; i <= 40; ++i) {
        Date tmp = TARGET().advance(d.refDate, (117 + 3 * i) * Months);
        simTimes_.push_back(ActualActual(ActualActual::ISDA).yearFraction(d.refDate, tmp));
    }
    for (Size i = 1; i <= 31; ++i) {
        Date tmp = TARGET().advance(d.refDate, (19 + i) * Years);
        simTimes_.push_back(ActualActual(ActualActual::ISDA).yearFraction(d.refDate, tmp));
    }
    for (Size i = 1; i <= 10; ++i) {
        Date tmp = TARGET().advance(d.refDate, (50 + i * 5) * Years);
        simTimes_.push_back(ActualActual(ActualActual::ISDA).yearFraction(d.refDate, tmp));
    }
 
    QuantLib::ext::shared_ptr<StochasticProcess> p_exact = d.xmodelExact->stateProcess();
    QuantLib::ext::shared_ptr<StochasticProcess> p_euler = d.xmodelEuler->stateProcess();
 
    // check that covariance matrices are positive semidefinite
 
    Array x0 = p_exact->initialValues();
    for (Size i = 1; i < simTimes_.size(); ++i) {
        // x0 does not matter, since covariance does not depend on it
        Matrix cov = p_exact->covariance(simTimes_[i - 1], x0, simTimes_[i] - simTimes_[i - 1]);
        SymmetricSchurDecomposition ssd(cov);
        for (Size j = 0; j < ssd.eigenvalues().size(); ++j) {
            if (ssd.eigenvalues()[j] < 0.0) {
                BOOST_ERROR("negative eigenvalue at " << j << " in covariance matrix at t=" << simTimes_[i] << " ("
                                                      << ssd.eigenvalues()[j] << ")");
            }
        }
    }
 
    // check positive semidefiniteness for one super-large step
    Matrix cov = p_exact->covariance(0.0, x0, simTimes_.back());
    SymmetricSchurDecomposition ssd2(cov);
    for (Size i = 0; i < ssd2.eigenvalues().size(); ++i) {
        if (ssd2.eigenvalues()[i] < 0.0) {
            BOOST_ERROR("negative eigenvalue at " << i << " in covariance matrix at t=0.0 for dt=100.0"
                                                  << " (" << ssd2.eigenvalues()[i] << ")");
        }
    }
 
} // testLgm31fPositiveCovariance
 
BOOST_AUTO_TEST_CASE(testLgm31fMoments) {
 
    BOOST_TEST_MESSAGE("Check analytical moments against Euler simulation in "
                       "Ccy LGM 31F model...");
 
    Lgm31fTestData d;
 
    QuantLib::ext::shared_ptr<StochasticProcess> p_exact = d.xmodelExact->stateProcess();
    QuantLib::ext::shared_ptr<StochasticProcess> p_euler = d.xmodelEuler->stateProcess();
 
    Array x0 = p_exact->initialValues();
 
    // check the expectation and covariance over 0...T against euler
    Real T = 2.0;
    Size steps = static_cast<Size>(T * 10.0);
    Size paths = 25000;
    Size seed = 42;
    TimeGrid grid(T, steps);
 
    Array e_an = p_exact->expectation(0.0, x0, T);
    Matrix v_an = p_exact->covariance(0.0, x0, T);
 
    const Size dim = 31;
 
    if (auto tmp = QuantLib::ext::dynamic_pointer_cast<CrossAssetStateProcess>(p_euler)) {
        tmp->resetCache(grid.size() - 1 - 1);
    }
    MultiPathGeneratorSobolBrownianBridge pgen(p_euler, grid, SobolBrownianGenerator::Steps, seed);
 
    accumulator_set<double, stats<tag::mean, tag::error_of<tag::mean> > > e_eu[dim];
    accumulator_set<double, stats<tag::covariance<double, tag::covariate1> > > v_eu[dim][dim];
 
    for (Size i = 0; i < paths; ++i) {
        Sample<MultiPath> path = pgen.next();
        for (Size ii = 0; ii < dim; ++ii) {
            Real cii = path.value[ii].back();
            e_eu[ii](cii);
            for (Size jj = 0; jj <= ii; ++jj) {
                Real cjj = path.value[jj].back();
                v_eu[ii][jj](cii, covariate1 = cjj);
            }
        }
    }
 
    Real tol1 = 2.0E-4;  // ir
    Real tol2 = 15.0E-4; // fx
    Real tol3 = 2.0E-4;  // ir-ir
    Real tol4 = 2.0E-4;  // ir-fx
    Real tol5 = 15.0E-4; // fx-fx
 
    // error checks and output is in new indexes !
    Real tol;
    // the test cases involving the CPI indices are broken
    // this is because of extreme values for H, which seem
    // to cause problems in the Euler discretization
    for (Size i = 0; i < 28 /*dim*/; ++i) {
        if (i < 16) {
            tol = tol1;
        } else {
            tol = tol2;
        }
        if (std::fabs(mean(e_eu[i]) - e_an[i]) > tol) {
            BOOST_ERROR("analytical expectation at " << i << " (" << e_an[i]
                                                     << ") is inconsistent with numerical value (Euler "
                                                        "discretization, "
                                                     << mean(e_eu[i]) << ") error is " << e_an[i] - mean(e_eu[i])
                                                     << " tolerance is " << tol);
        }
        for (Size j = 0; j <= i; ++j) {
            if (i < 16) {
                tol = tol3;
            } else {
                if (j < 16) {
                    tol = tol4;
                } else {
                    tol = tol5;
                }
            }
            if (std::fabs(boost::accumulators::covariance(v_eu[i][j]) - v_an[i][j]) > tol) {
                BOOST_ERROR("analytical covariance at ("
                            << i << "," << j << ") (" << v_an[i][j]
                            << ") is inconsistent with numerical "
                               "value (Euler discretization, "
                            << boost::accumulators::covariance(v_eu[i][j]) << "), error is "
                            << v_an[i][j] - boost::accumulators::covariance(v_eu[i][j]) << " tolerance is " << tol);
            }
        }
    }
 
    // debug output
    // std::clog << "EXACT and error expectation" << std::endl;
    // for (Size ii = 0; ii < dim; ++ii) {
    //     std::clog << "#" << ii << " " << e_an[mapping[ii]] << " "
    //               << mean(e_eu[mapping[ii]]) << " "
    //               << mean(e_eu[mapping[ii]]) - e_an[mapping[ii]] << " +- "
    //               << error_of<tag::mean>(e_eu[mapping[ii]]) << " => mult "
    //               << (mean(e_eu[mapping[ii]]) - e_an[mapping[ii]]) /
    //                      error_of<tag::mean>(e_eu[mapping[ii]])
    //               << std::endl;
    // }
 
    // std::clog << "EXACT covariance" << std::endl;
    // for (Size ii = 0; ii < dim; ++ii) {
    //     std::clog << "| ";
    //     for (Size jj = 0; jj < ii; ++jj) {
    //         std::clog << v_an[mapping[ii]][mapping[jj]] << " ";
    //     }
    //     std::clog << " |" << std::endl;
    // }
    // std::clog << std::endl;
 
    // std::clog << "EULER covariance error" << std::endl;
    // for (Size ii = 0; ii < dim; ++ii) {
    //     std::clog << "| ";
    //     for (Size jj = 0; jj <= ii; ++jj) {
    //         std::clog << covariance(v_eu[mapping[ii]][mapping[jj]]) -
    //                          v_an[mapping[ii]][mapping[jj]]
    //                   << " ";
    //     }
    //     std::clog << " |" << std::endl;
    // }
    // std::clog << std::endl;
    // end debug output
 
} // testLgm31fMoments
 
BOOST_AUTO_TEST_CASE(testLgm31fMartingaleProperty) {
 
    BOOST_TEST_MESSAGE("Check martingale property in Ccy LGM 31F model...");
 
    Lgm31fTestData d;
 
    QuantLib::ext::shared_ptr<StochasticProcess> p_exact = d.xmodelExact->stateProcess();
    QuantLib::ext::shared_ptr<StochasticProcess> p_euler = d.xmodelEuler->stateProcess();
 
    Real T = 2.0;
    Size steps = static_cast<Size>(T * 10.0);
    Size paths = 25000;
    Size seed = 42;
    TimeGrid grid(T, steps);
 
    const Size dim = 31, nIr = 13 + 3;
 
    if (auto tmp = QuantLib::ext::dynamic_pointer_cast<CrossAssetStateProcess>(p_euler)) {
        tmp->resetCache(grid.size() - 1);
    }
    if (auto tmp = QuantLib::ext::dynamic_pointer_cast<CrossAssetStateProcess>(p_exact)) {
        tmp->resetCache(grid.size() - 1);
    }
    MultiPathGeneratorSobolBrownianBridge pgen(p_euler, grid, SobolBrownianGenerator::Steps, seed);
    MultiPathGeneratorSobolBrownianBridge pgen2(p_exact, grid, SobolBrownianGenerator::Steps, seed);
 
    accumulator_set<double, stats<tag::mean, tag::error_of<tag::mean> > > e_eu2[dim];
 
    for (Size i = 0; i < paths; ++i) {
        Sample<MultiPath> path = pgen.next();
        for (Size ii = 0; ii < nIr; ++ii) {
            if (ii == 0) {
                // domestic currency
                e_eu2[ii](1.0 / d.xmodelExact->numeraire(0, T, path.value[0].back()));
            } else {
                // foreign currencies
                e_eu2[ii](std::exp(path.value[nIr + (ii - 1)].back()) /
                          d.xmodelExact->numeraire(0, T, path.value[0].back()));
            }
        }
    }
 
    // as before we have to exclude the inflation indices
    Real tol = 0.5E-4;
    for (Size ii = 0; ii < nIr - 3; ++ii) {
        if (std::fabs(-std::log(mean(e_eu2[ii])) / T + std::log(d.yts->discount(T)) / T) > tol) {
            BOOST_ERROR("failed to verify martingale property for ccy "
                        << ii << ", equivalent simulated zero yield is " << -std::log(mean(e_eu2[ii])) / T
                        << " while theoretical value is " << -std::log(d.yts->discount(T)) / T << " difference is "
                        << -std::log(mean(e_eu2[ii])) / T + std::log(d.yts->discount(T)) / T << ", tolerance is "
                        << tol);
        }
    }
 
} // testLgm13fMartingaleProperty
 
BOOST_AUTO_TEST_SUITE_END()
 
BOOST_AUTO_TEST_SUITE_END()