void test_calib_gMatrixNegative_allData()
{
std::vector<std::string> mkt_file_list = InputFileManager::get_VCUB_FileList();
//size_t nbFile = 2;
size_t nbFile = mkt_file_list.size();
LmmCalibrationConfig config;
config.model_nbYear_=16;
//std::cout<<"------------------------------------------------------ HORIZON "<<nbYear<<" YR "<<std::endl;//ctndebug_calib_todelete
for(size_t iFile=0 ; iFile< nbFile ; ++iFile)
{
std::string folder_name;// = "TotalCalib\\" ; config.use_positive_constraint_=true;
std::string base_name_file = LMMPATH::get_BaseFileName(mkt_file_list[iFile]) + "\\";
folder_name+=base_name_file;
LMMPATH::reset_Output_SubFolder(folder_name );
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_file_list[iFile]);
config.correl_ReducedRank_= 30 ; config.correl_alpha_ = 0.000000001 ; config.correl_beta_ = 0.05;
QuantLib::Array found_abcd = marketData_LMM_ABCD_calibration(config,pLmmSwaptionMarketData);
//Correlation_PTR found_correlation_ptr = marketData_LMM_Correlation_calibration(config,pLmmSwaptionMarketData,found_abcd);
config.correl_ReducedRank_= 3 ;
//marketData_LMM_CascadeExact_calibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config) );
//config.use_local_calib_=true;
//marketData_LMM_Local_gCalibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config), GMatrixMapping_PTR() );
//config.use_local_calib_=false;
//config.penalty_time_homogeneity_ = 1e-4 ; config.penalty_libor_ = 1e-6 ; config.use_positive_constraint_=false;
marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config), GMatrixMapping_PTR() );
}
}
void test_calib_gMatrix_OneFile(const std::string& mkt_data_file)
{
std::string folder_name;// = "TotalCalib\\" ; config.use_positive_constraint_=true;
std::string base_name_file = LMMPATH::get_BaseFileName(mkt_data_file) + "\\";
folder_name+=base_name_file;
LMMPATH::reset_Output_SubFolder(folder_name );
LmmCalibrationConfig config;
config.model_nbYear_=16;
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_file);
config.correl_ReducedRank_= 30 ; config.correl_alpha_ = 0.000000001 ; config.correl_beta_ = 0.05;
QuantLib::Array found_abcd = marketData_LMM_ABCD_calibration(config,pLmmSwaptionMarketData);
//Correlation_PTR found_correlation_ptr = marketData_LMM_Correlation_calibration(config,pLmmSwaptionMarketData,found_abcd);
config.correl_ReducedRank_= 3 ;
//marketData_LMM_CascadeExact_calibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config) );
//config.use_local_calib_=true;
//marketData_LMM_Local_gCalibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config), GMatrixMapping_PTR() );
//config.use_local_calib_=false;
config.penalty_time_homogeneity_ = 1e-4 ; config.penalty_libor_ = 1e-6 ; config.use_positive_constraint_= true;
marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config), GMatrixMapping_PTR() );
}
void test_Calib_gMatrix(const LmmCalibrationConfig& config , const std::string& mkt_data_filename)
{
std::string folder_data_file = "WithPositiveConstraint\\" + LMMPATH::get_BaseFileName(mkt_data_filename) + "\\";
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_filename);
{
std::string sub_folder_data_file = folder_data_file + "Cascade\\";
LMMPATH::reset_Output_SubFolder(sub_folder_data_file );
GMatrixMapping_PTR pGMatrixMapping = marketData_LMM_CascadeExact_calibration(config, pLmmSwaptionMarketData, config.get_abcdArray() ,create_InitCorrelation(config));
config.print("calib_config.csv");
}
{
config.use_local_calib_=false;
std::string sub_folder_data_file = folder_data_file + "Global\\";
LMMPATH::reset_Output_SubFolder(sub_folder_data_file );
marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData,config.get_abcdArray(),create_InitCorrelation(config), GMatrixMapping_PTR() );
config.print("calib_config.csv");
}
{
config.use_local_calib_=true;
std::string sub_folder_data_file = folder_data_file + "Local\\";
LMMPATH::reset_Output_SubFolder(sub_folder_data_file );
marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData,config.get_abcdArray(),create_InitCorrelation(config), GMatrixMapping_PTR() );
config.print("calib_config.csv");
}
}
void test_calibration_Cascade_then_Global(const std::string& mkt_data_filename)
{
LmmCalibrationConfig config;
config.reset_nbYear(16);
config.correl_ReducedRank_= 3;
config.correl_alpha_ = 0.000000001;
config.correl_beta_ = 0.05;
config.vol_abcd_.a_ = 0.25673;
config.vol_abcd_.b_ = 0.00002;
config.vol_abcd_.c_ = 0.547;
config.vol_abcd_.d_ = 0.13998;
config.use_positive_constraint_=true;
std::stringstream foldername ;
std::string base_name_file = LMMPATH::get_BaseFileName(mkt_data_filename) + "\\";
foldername<<"Cascade_Then_Global\\";
foldername << base_name_file ;
LMMPATH::reset_Output_SubFolder(foldername.str() );
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_filename );
GMatrixMapping_PTR pGMatrixMapping = marketData_LMM_CascadeExact_calibration(config, pLmmSwaptionMarketData, config.get_abcdArray() ,create_InitCorrelation(config));
marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData,config.get_abcdArray(),create_InitCorrelation(config),pGMatrixMapping );
}
void JB_test_calib_shift_gMatrix_OneFile(const std::string& mkt_data_file)
{
std::string folder_name;// = "TotalCalib\\" ; config.use_positive_constraint_=true;
std::string base_name_file = LMMPATH::get_BaseFileName(mkt_data_file) + "\\";
folder_name+=base_name_file;
LMMPATH::reset_Output_SubFolder(folder_name );
LmmCalibrationConfig config;
config.model_nbYear_=16;
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_file);
config.correl_ReducedRank_= 30 ; config.correl_alpha_ = 0.000000001 ; config.correl_beta_ = 0.05;
Shifted_HGVolatilityFunction_PTR shifted_HGVolatilityFunction= JB_marketData_LMM_ABCD_calibration(config,pLmmSwaptionMarketData);
//Correlation_PTR found_correlation_ptr = marketData_LMM_Correlation_calibration(config,pLmmSwaptionMarketData,found_abcd);
config.correl_ReducedRank_= 3 ;
//marketData_LMM_CascadeExact_calibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config) );
//config.use_local_calib_=true;
//marketData_LMM_Local_gCalibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config), GMatrixMapping_PTR() );
//config.use_local_calib_=false;
config.penalty_time_homogeneity_ = 1e-4 ; config.penalty_libor_ = 1e-6 ; config.use_positive_constraint_= true;
GMatrix_Vol_gMapping gMatrix_Vol_gMapping = JB_marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData, shifted_HGVolatilityFunction, create_InitCorrelation(config), GMatrixMapping_PTR() );
Shifted_HGVolatilityFunction_PTR param_h_g_shifted = JB_marketData_LMM_shift_Calibration( config
, pLmmSwaptionMarketData
, gMatrix_Vol_gMapping.first
);
JB_marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData, param_h_g_shifted , create_InitCorrelation(config), gMatrix_Vol_gMapping.second );
cout << "end of program" << endl;
// JB_marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config), GMatrixMapping_PTR() )
}
void test_LmmGenericSensitivity(const std::string& mkt_data_filename)
{
LmmCalibrationConfig config;
config.reset_nbYear(16);
config.correl_ReducedRank_= 3;
config.correl_alpha_ = 0.000000001;
config.correl_beta_ = 0.05;
config.vol_abcd_.a_ = 0.136554 ;
config.vol_abcd_.b_ = 8.45E-06 ;
config.vol_abcd_.c_ = 0.0439938 ;
config.vol_abcd_.d_ = 0.0269172 ;
config.penalty_libor_ = 1e-6;
config.penalty_time_homogeneity_ = 1e-4;
config.use_positive_constraint_=true;
std::stringstream foldername ;
std::string base_name_file = LMMPATH::get_BaseFileName(mkt_data_filename) + "\\";
foldername<<"Regularized_";
foldername << base_name_file ;
LMMPATH::reset_Output_SubFolder(foldername.str() );
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_filename );
//config.print("config_for_abcd_calibration.csv");
//QuantLib::Array calibrated_abcd = marketData_LMM_ABCD_calibration(config,pLmmSwaptionMarketData);
marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData,config.get_abcdArray(),create_InitCorrelation(config), GMatrixMapping_PTR() );
//QuantLib::Array calibrated_abcd(4);
//config.correl_alpha_= 1e-7 ; config.correl_beta_= 1;
//calibrated_abcd[0]=0.223519;calibrated_abcd[1]=1.36E-05;calibrated_abcd[2]=0.455953;calibrated_abcd[3]=0.140501;
//Correlation_PTR pCorrelation = marketData_LMM_Correlation_calibration(config,pLmmSwaptionMarketData, calibrated_abcd );
//config.print("config_for_correlation_calibration.csv");
//Correlation_PTR pCorrelation = marketData_LMM_Correlation_calibration(config,pLmmSwaptionMarketData, calibrated_abcd );
//Correlation_PTR pCorrelation = create_InitCorrelation(config);
//GMatrixMapping_PTR pGMatrixMapping = marketData_LMM_CascadeExact_calibration(config, pLmmSwaptionMarketData, config.get_abcdArray() ,pCorrelation);
//marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData,config.get_abcdArray(),pCorrelation, pGMatrixMapping );
foldername.str( std::string() ) ;
}
void test_Stability_ABCD_vs_Correl(const std::string& mkt_data_filename)
{
// loop testing if calib of abcd, then correl, then reiterate by the result is stable
LmmCalibrationConfig config;
config.reset_nbYear(16);
config.correl_ReducedRank_= 30;
config.correl_alpha_= 1. ;
config.correl_beta_= 1. ;
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_filename );
size_t loop_counter=0;
std::string base_folder = "Test_ABCD_vs_Correl\\";
const std::string base_path = LMMPATH::get_output_path() + base_folder;
std::string common_result_file = base_path + "Evolution_abcd_correlation.csv";
while(loop_counter<10)
{
{
std::ofstream common_result ; common_result.open(common_result_file.c_str(), std::ios::app);
common_result<<"-------------- loop "<<loop_counter<<std::endl;
common_result<<"a,b,c,d, ,, alpha,beta,"<<std::endl;
common_result<<"a,b,c,d, ,, alpha,beta,"<<std::endl;
common_result<<config.vol_abcd_.a_<<","<<config.vol_abcd_.b_<<","<<config.vol_abcd_.c_<<","<<config.vol_abcd_.d_<<", ,,";
common_result<<config.correl_alpha_<<","<<config.correl_beta_<<","<<std::endl<<std::endl;
common_result.close();
}
std::stringstream foldername ;
foldername<<"loop_"<<loop_counter;
std::string full_path_folder = base_folder + foldername.str() + "\\";
LMMPATH::reset_Output_SubFolder( full_path_folder );
QuantLib::Array calibrated_abcd = marketData_LMM_ABCD_calibration(config,pLmmSwaptionMarketData);
config.vol_abcd_.a_ = calibrated_abcd[0];
config.vol_abcd_.b_ = calibrated_abcd[1];
config.vol_abcd_.c_ = calibrated_abcd[2];
config.vol_abcd_.d_ = calibrated_abcd[3];
Correlation_PTR pCorrelation = marketData_LMM_Correlation_calibration(config,pLmmSwaptionMarketData, calibrated_abcd );
QuantLib::Array calibrated_correlation = pCorrelation->get_ArrayFrom_Correlation();
config.correl_alpha_= calibrated_correlation[0];
config.correl_beta_= calibrated_correlation[1];
++loop_counter;
}
}
void test_ABCDSensitivity_ABCD_vs_nbFactor_N_Alpha()
{
///// create a grid of nbFactor and alpha, calibrate abcd throu this grid and see the quality of calibrator
std::vector<std::string> file_list = InputFileManager::get_VCUB_FileList();
const std::string& mkt_data_filename = file_list.back();
std::string base_output_folder = "Test_ABCDSensitivity\\";
std::string base_name_file = LMMPATH::get_BaseFileName(mkt_data_filename);
for(size_t nbFactor =3; nbFactor<33; nbFactor+=5)
{
for(double correl_alpha=0.0000001;correl_alpha<=0.00000011;correl_alpha+=0.03)
{
LmmCalibrationConfig config;
config.reset_nbYear(16);
config.correl_ReducedRank_= nbFactor;
config.correl_alpha_= 0.0000001;
config.correl_beta_= correl_alpha;
std::ostringstream sub_folder_name;
sub_folder_name<<"_nbF_"<<nbFactor<<"_alp_"<<correl_alpha;
std::string output_folder = base_output_folder + sub_folder_name.str() + "\\";
LMMPATH::reset_Output_SubFolder(output_folder );
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_filename );
QuantLib::Array calibrated_abcd = marketData_LMM_ABCD_calibration(config,pLmmSwaptionMarketData);
}
}
}
void test_LmmSensitivityCorrelationReducedRank()
{
std::vector<std::string> mkt_file_list = InputFileManager::get_VCUB_FileList();
size_t nbFile = mkt_file_list.size();
LmmCalibrationConfig config;
config.reset_nbYear(16);
config.vol_abcd_.a_ = 0.148975 ;
config.vol_abcd_.b_ = 0.0197503 ;
config.vol_abcd_.c_ = 0.108518 ;
config.vol_abcd_.d_ = 1.38E-08 ;
std::vector<size_t> reduced_rank_list;
reduced_rank_list.push_back(3);
reduced_rank_list.push_back(5);
reduced_rank_list.push_back(10);
reduced_rank_list.push_back(15);
reduced_rank_list.push_back(20);
reduced_rank_list.push_back(25);
reduced_rank_list.push_back(30);
std::stringstream foldername ;
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_file_list[0]);
for(size_t i=0; i<reduced_rank_list.size();++i)
{
config.correl_ReducedRank_ = reduced_rank_list[i] ;
foldername << LMMPATH::get_BaseFileName(mkt_file_list[0])<<"\\"<<"ReducedRank_"<<reduced_rank_list[i]<<"\\";
LMMPATH::reset_Output_SubFolder(foldername.str() );
Correlation_PTR pCorrelation = marketData_LMM_Correlation_calibration(config,pLmmSwaptionMarketData,config.get_abcdArray() );
foldername.str( std::string() ) ;
}
}
void Test_evaluation_basis()
{
LMM::Index indexStart = 2; //1Y
LMM::Index indexEnd = 20; //10Y
Tenor floatingLegTenorType = Tenor::_6M;
Tenor fixedLegTenorType = Tenor::_1YR;
assert(indexStart%2==0&&indexEnd%2==0);
LMMTenorStructure_PTR lmmTenorStructure( new LMMTenorStructure(floatingLegTenorType, indexEnd/2));
std::vector<std::string> mkt_file_list = InputFileManager::get_VCUB_FileList();
const std::string& mkt_data_file = mkt_file_list.back();
std::string folder_name; // = "TotalCalib\\" ; config.use_positive_constraint_=true;
std::string base_name_file = LMMPATH::get_BaseFileName(mkt_data_file) + "\\";
folder_name+=base_name_file;
LMMPATH::reset_Output_SubFolder(folder_name );
LmmCalibrationConfig config;
config.floatLegTenor_=floatingLegTenorType;
config.fixedLegTenor_=fixedLegTenorType;
config.model_nbYear_ = indexEnd/2;
size_t fixedFloatRatio = config.fixedLegTenor_.ratioTo(config.floatLegTenor_);
config.correl_FullRank_ = fixedFloatRatio*config.model_nbYear_+1;
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData = get_LmmSwaptionMarketData(config, mkt_data_file);
const std::vector<double>& initLiborValues = pLmmSwaptionMarketData->get_LiborQuotes()->get_InitLibor();
double strike = 0.0137;
std::vector<LMM::Index> exerciseDates;
exerciseDates.push_back(2);
//exerciseDates.push_back(4);
//exerciseDates.push_back(6);
//exerciseDates.push_back(8);
//exerciseDates.push_back(10);
//exerciseDates.push_back(12);
//exerciseDates.push_back(14);
//exerciseDates.push_back(16);
//exerciseDates.push_back(18);
exerciseDates.push_back(20);
McLmm_PTR mcLmm_for_pricer = getMcLmmExample(lmmTenorStructure, initLiborValues, LmmCalibrationConfig());
size_t fixedFloatingRatio = fixedLegTenorType.ratioTo(floatingLegTenorType);
std::vector<std::vector<size_t>> subset;
for(size_t i = 0; i <= 2; i++)
{
subset.push_back(std::vector<size_t>());
subset.back().push_back(0);
subset.back().push_back(0);
subset.back().push_back(i);
}
//for(size_t j = 1; j <= 2; j++)
//{
// subset.push_back(std::vector<size_t>());
// subset.back().push_back(0);
// subset.back().push_back(j);
// subset.back().push_back(0);
//}
/* for(size_t k = 1; k <= 2; k++)
{
subset.push_back(std::vector<size_t>());
subset.back().push_back(k);
subset.back().push_back(0);
subset.back().push_back(0);
} */
size_t regressionIndex=2;
LMM::Index liborIndex = indexStart + regressionIndex*fixedFloatingRatio;
LMM::Index paymentIndex = indexStart + regressionIndex*fixedFloatingRatio + 1;
VanillaSwap vanillaSwap( strike,
liborIndex,
indexEnd,
floatingLegTenorType,
fixedLegTenorType,
lmmTenorStructure);
std::vector<Basis_CONSTPTR> basis_vect;
std::vector<Basis_Evaluator_CONSTPTR> basis_evaluator_vect;
for(size_t basisIndex = 0; basisIndex<subset.size(); basisIndex++)
{
basis_vect.push_back(getBasis(subset[basisIndex], 1.0, vanillaSwap, strike, liborIndex));
basis_evaluator_vect.push_back(getBasisEvaluator(subset[basisIndex], McLmmVanillaSwapPricer(mcLmm_for_pricer)));
}
LS::Regression rg(LS::RegressionRepresentation(basis_vect, basis_evaluator_vect));
McLmm_PTR mcLmm = getMcLmmExample(lmmTenorStructure, initLiborValues, LmmCalibrationConfig());
McLmm_LS mcLmm_LS(mcLmm);
mcLmm_LS.simulateLMM(1);
size_t nb = 30000;
clock_t startTime = clock();
std::vector<std::vector<double>> vect(nb);
for(size_t i=0; i<nb; i++)
{
//rg.getRegressionRepresentation().evaluate_basis(mcLmm_LS.lmmSimualtionResults_[0]);
vect[i].resize(3);
vect[i]=rg.getRegressionRepresentation().getBasis_val_buffer();
vect[i]=std::vector<double>(3, 1.0);
}
clock_t endTime = clock();
clock_t time = endTime - startTime;
double time_in_second = time/(double) CLOCKS_PER_SEC;
cout << "time_in_second "<< time_in_second << endl;
const matrix& m = mcLmm_LS.lmmSimualtionResults_[0].get_liborMatrix();
const std::vector<double>& numeraire = mcLmm_LS.lmmSimualtionResults_[0].get_numeraire();
std::vector<size_t> basis1;
basis1.push_back(1);
basis1.push_back(0);
basis1.push_back(0);
Basis_CONSTPTR basisA=getBasis(basis1, 1.0, vanillaSwap, strike, liborIndex);
Basis_Evaluator_CONSTPTR basis_EvaluatorA = getBasisEvaluator(basis1, McLmmVanillaSwapPricer(mcLmm_for_pricer));
basis_EvaluatorA->evaluate(basisA,m, numeraire);
clock_t startTime1 = clock();
for(size_t i=0; i<1000; i++)
basis_EvaluatorA->evaluate(basisA,m, numeraire);
clock_t endTime1 = clock();
clock_t time1 = endTime1 - startTime1;
double time1_in_second = time1/(double) CLOCKS_PER_SEC;
cout << "time1_in_second "<< time1_in_second << endl;
std::vector<size_t> basis2;
basis2.push_back(0);
basis2.push_back(1);
basis2.push_back(0);
Basis_CONSTPTR basisB=getBasis(basis2, 1.0, vanillaSwap, strike, liborIndex);
Basis_Evaluator_CONSTPTR basis_EvaluatorB = getBasisEvaluator(basis2, McLmmVanillaSwapPricer(mcLmm_for_pricer));
clock_t startTime2 = clock();
for(size_t i=0; i<1000; i++)
basis_EvaluatorB->evaluate(basisB, m, numeraire);
clock_t endTime2 = clock();
clock_t time2 = endTime2 - startTime2;
double time2_in_second = time2/(double) CLOCKS_PER_SEC;
cout << "time2_in_second "<< time2_in_second << endl;
std::vector<size_t> basis3;
basis3.push_back(0);
basis3.push_back(0);
basis3.push_back(1);
Basis_CONSTPTR basisC=getBasis(basis3, 1.0, vanillaSwap, strike, liborIndex);
Basis_Evaluator_CONSTPTR basis_EvaluatorC = getBasisEvaluator(basis3, McLmmVanillaSwapPricer(mcLmm_for_pricer));
clock_t startTime3 = clock();
for(size_t i=0; i<1000; i++)
basis_EvaluatorC->evaluate(basisC, m, numeraire);
clock_t endTime3 = clock();
clock_t time3 = endTime3 - startTime3;
double time3_in_second = time3/(double) CLOCKS_PER_SEC;
cout << "time3_in_second "<< time3_in_second << endl;
EV_Evaluator_CONSTPTR ev_evaluator_libor(new EV_LiborRate_Evaluator());
EV_Evaluator_CONSTPTR ev_evaluator_swaprate(new EV_VanillaSwapRate_Evaluator(McLmmVanillaSwapPricer(mcLmm_for_pricer)));
EV_CONSTPTR ev_swaprate(new EV_VanillaSwapRate( Rate1_CONSTPTR( new VanillaSwapRate(VanillaSwap(vanillaSwap)))));
EV_CONSTPTR ev_libor(new EV_LiborRate(Rate1_CONSTPTR(new LiborRate(2,Tenor(Tenor::_6M)))));
clock_t startTime4 = clock();
for(size_t i=0; i<1000; i++)
ev_evaluator_swaprate->evaluate(ev_swaprate,m,numeraire);
clock_t endTime4 = clock();
clock_t time4 = endTime4 - startTime4;
double time4_in_second = time4/(double) CLOCKS_PER_SEC;
cout << "time4_in_second "<< time4_in_second << endl;
clock_t startTime5 = clock();
for(size_t i=0; i<1000; i++)
ev_evaluator_libor->evaluate(ev_libor,m,numeraire);
clock_t endTime5 = clock();
clock_t time5 = endTime5 - startTime5;
double time5_in_second = time5/(double) CLOCKS_PER_SEC;
cout << "time5_in_second "<< time5_in_second << endl;
}
void test_LmmRegularizedCalibrationMarketData_OneFile(const std::string& mkt_data_file)
{
LmmCalibrationConfig config;
config.reset_nbYear(16);
LmmSwaptionMarketData_PTR pLmmSwaptionMarketData=get_LmmSwaptionMarketData(config, mkt_data_file);
config.correl_ReducedRank_= 30 ; config.correl_alpha_ = 0.000000001 ; config.correl_beta_ = 0.05;
QuantLib::Array found_abcd = marketData_LMM_ABCD_calibration(config,pLmmSwaptionMarketData);
config.correl_ReducedRank_= 3;
config.use_positive_constraint_= true;
std::vector<double> pel_time ;
std::vector<double> pel_libor;
generating_penalties_values(pel_time, pel_libor);
const size_t penalty_matrix_size1 = pel_time.size();
const size_t penalty_matrix_size2 = pel_libor.size();
boost::numeric::ublas::matrix<double> quote_error_l2(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> quote_error_l1(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> quote_error_linf(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> pel_timehomo_error_l2(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> pel_timehomo_error_l1(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> pel_timehomo_error_linf(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> pel_liborsmoth_error_l2(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> pel_liborsmoth_error_l1(penalty_matrix_size1,penalty_matrix_size2);
boost::numeric::ublas::matrix<double> pel_liborsmoth_error_linf(penalty_matrix_size1,penalty_matrix_size2);
for(size_t iPelTime=0;iPelTime<penalty_matrix_size1;++iPelTime)
{
for(size_t jPelLibor=0;jPelLibor<penalty_matrix_size2;++jPelLibor)
{
config.penalty_time_homogeneity_ = pel_time[iPelTime] ;
config.penalty_libor_ = pel_libor[jPelLibor];
marketData_LMM_Global_gCalibration(config, pLmmSwaptionMarketData, found_abcd , create_InitCorrelation(config), GMatrixMapping_PTR() );
quote_error_l2(iPelTime,jPelLibor) = config.result_quote_error_l2 ;
quote_error_l1(iPelTime,jPelLibor) = config.result_quote_error_l1 ;
quote_error_linf(iPelTime,jPelLibor) = config.result_quote_error_linf ;
pel_timehomo_error_l2(iPelTime,jPelLibor) = config.result_pelTime_error_l2 ;
pel_timehomo_error_l1(iPelTime,jPelLibor) = config.result_pelTime_error_l1 ;
pel_timehomo_error_linf(iPelTime,jPelLibor) = config.result_pelTime_error_linf ;
pel_liborsmoth_error_l2(iPelTime,jPelLibor) = config.result_pelLibor_error_l2 ;
pel_liborsmoth_error_l1(iPelTime,jPelLibor) = config.result_pelLibor_error_l1 ;
pel_liborsmoth_error_linf(iPelTime,jPelLibor) = config.result_pelLibor_error_linf ;
config.reset_result();
}
}
print_matrices_error
(
pel_time
,pel_libor
,quote_error_l2
,quote_error_l1
,quote_error_linf
,pel_timehomo_error_l2
,pel_timehomo_error_l1
,pel_timehomo_error_linf
,pel_liborsmoth_error_l2
,pel_liborsmoth_error_l1
,pel_liborsmoth_error_linf
);
}
