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_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_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 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");
	}


}
コード例 #6
0
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
		);
}
コード例 #7
0
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() )
}
コード例 #8
0
Correlation_PTR marketData_LMM_Correlation_calibration(const LmmCalibrationConfig& config, LmmSwaptionMarketData_PTR pLmmSwaptionMarketData , const QuantLib::Array& found_abcd)
{
	size_t nbYear = pLmmSwaptionMarketData->get_nbYear();
	std::string base_name = pLmmSwaptionMarketData->get_MarketDataBaseFileName() ;

	Tenor tenorfixedleg = Tenor::_1YR ;
	Tenor tenorfloatleg = Tenor::_6M  ;
	size_t fixedfloatRatio = tenorfixedleg.ratioTo(tenorfloatleg);

	//create LMM components
	LMMTenorStructure_PTR pLMMTenorStructure( new LMMTenorStructure(tenorfloatleg,nbYear) );

	const double a=found_abcd[0],b=found_abcd[1],c=found_abcd[2],d=found_abcd[3];

	Shifted_HGVolatilityParam::ABCDParameter abcdParam(a,b,c,d);
	ConstShifted_HGVolatilityParam_PTR pNoShifted_HGVolatilityParam( new ConstShifted_HGVolatilityParam(pLMMTenorStructure, abcdParam, 1., 0.));

	//! create correlation
	Correlation_PTR pCorrelation = create_InitCorrelation(config);

	Shifted_HGVolatilityFunction_PTR pVolatilityFunction (new ConstShifted_HGVolatilityFunction(pLMMTenorStructure, pCorrelation, pNoShifted_HGVolatilityParam)); 
	Dispersion dispersion(pVolatilityFunction);
	Lmm_PTR lmm_ptr(new Lmm(dispersion) );

	//! Create Approximation Rebonato 
	LmmVanillaSwaptionApproxPricer_Rebonato_PTR pLmmVanillaSwaptionApproxPricer_Rebonato(new LmmVanillaSwaptionApproxPricer_Rebonato(lmm_ptr));	

	pLmmVanillaSwaptionApproxPricer_Rebonato->update_VolatilityParam(pNoShifted_HGVolatilityParam);

	LmmBaseCostFunction_PTR pLmmCorrelationCostFunction(new LmmCorrelationCostFunction
		(
		pLmmVanillaSwaptionApproxPricer_Rebonato
		, pLmmSwaptionMarketData->get_LiborQuotes()
		, pLmmSwaptionMarketData->get_SwaptionQuotes_ATM()
		, pCorrelation
		) );


	////// Correlation calibrator
	QuantLib::Array xy_correlation_init = pCorrelation->get_ArrayFrom_Correlation();
	QuantLib::Size maxIterations =1000;
	QuantLib::Size minStatIterations =100;
	QuantLib::Real rootEpsilon = 1e-8;
	QuantLib::Real functionEpsilon =  1e-8;


	LmmCorrelationCalibrator lmmCorrelationCalibrator
		(
		xy_correlation_init
		, maxIterations
		, rootEpsilon
		,functionEpsilon
		, pLmmCorrelationCostFunction
		);

	lmmCorrelationCalibrator.solve();

	std::string result_file =base_name + "_correlation_calibration_result.csv";
	lmmCorrelationCalibrator.printPlusPlus(result_file);

	std::string calibrated_correlation_file =base_name + "_correlation_calibrated.csv";
	Correlation_PTR calibrated_correl_ptr = lmmCorrelationCalibrator.get_Found_Correlation() ;
	calibrated_correl_ptr->print(calibrated_correlation_file);

	// print in a common file
	{
		std::string common_result_file_name = "calib_result_Correlation.csv";
		std::string full_common_result_file = LMMPATH::get_Root_OutputPath() + common_result_file_name ;

		std::ofstream final_result ;
		final_result.open(full_common_result_file.c_str(), std::ios::app);

		final_result<<std::endl<<std::endl<< "============= Test At    "<<LMMPATH::get_TimeDateNow()
			<<",,,,,, Error LInf, "<<lmmCorrelationCalibrator.get_QuoteError_LInf() <<std::endl ;
		final_result<< lmmCorrelationCalibrator.get_BaseGeneral_Result_Info();

		final_result.close();	
	}

	return calibrated_correl_ptr ;
}
コード例 #9
0
QuantLib::Array marketData_LMM_ABCD_calibration(const LmmCalibrationConfig& config, LmmSwaptionMarketData_PTR pLmmSwaptionMarketData)
{
	std::string base_name = pLmmSwaptionMarketData->get_MarketDataBaseFileName() ;

	size_t nbYear = pLmmSwaptionMarketData->get_nbYear();
	Tenor tenorfixedleg = Tenor::_1YR ;
	Tenor tenorfloatleg = Tenor::_6M  ;
	size_t fixedfloatRatio = tenorfixedleg.ratioTo(tenorfloatleg);

	//create LMM components
	LMMTenorStructure_PTR pLMMTenorStructure( new LMMTenorStructure(tenorfloatleg,nbYear) );


	ConstShifted_HGVolatilityParam_PTR pNoShifted_HGVolatilityParam( new ConstShifted_HGVolatilityParam(pLMMTenorStructure, config.vol_abcd_ , 1., 0.));

	//! create correlation
	Correlation_PTR pCorrelation = create_InitCorrelation(config);

	Shifted_HGVolatilityFunction_PTR pVolatilityFunction (new ConstShifted_HGVolatilityFunction(pLMMTenorStructure, pCorrelation, pNoShifted_HGVolatilityParam)); 
	Dispersion dispersion(pVolatilityFunction);
	Lmm_PTR lmm_ptr(new Lmm(dispersion) );

	//! Create Approximation Rebonato 
	LmmVanillaSwaptionApproxPricer_Rebonato_PTR pLmmVanillaSwaptionApproxPricer_Rebonato(new LmmVanillaSwaptionApproxPricer_Rebonato(lmm_ptr));	

	pLmmVanillaSwaptionApproxPricer_Rebonato->update_VolatilityParam(pNoShifted_HGVolatilityParam);

	LmmBaseCostFunction_PTR abcd_costFucntion (new LmmABCDCostFunction ( pLmmVanillaSwaptionApproxPricer_Rebonato
		, pLmmSwaptionMarketData->get_LiborQuotes()
		, pLmmSwaptionMarketData->get_SwaptionQuotes_ATM()
		, pNoShifted_HGVolatilityParam
		));

	QuantLib::Array init_abcd(4);
	init_abcd[0]=config.vol_abcd_.a_;
	init_abcd[1]=config.vol_abcd_.b_;
	init_abcd[2]=config.vol_abcd_.c_;
	init_abcd[3]=config.vol_abcd_.d_;

	size_t maxIterations = 1000;
	size_t minStatIterations = 100;
	double rootEpsilon =1e-14;
	double functionEpsilon =1e-14;
	double gradientNormEpsilon =0;

	LmmABCDCalibrator  lmm_abcd_calibrator(init_abcd, maxIterations, rootEpsilon,functionEpsilon,abcd_costFucntion);


	//lmm_abcd_calibrator.add_ConstraintCell(std::pair<size_t,size_t>(1,1) );
	//lmm_abcd_calibrator.add_ConstraintCell(std::pair<size_t,size_t>(2,2) );
	////lmm_abcd_calibrator.add_ConstraintCell(std::pair<size_t,size_t>(3,3) );
	//lmm_abcd_calibrator.add_ConstraintCell(std::pair<size_t,size_t>(4,4) );
	//lmm_abcd_calibrator.add_ConstraintCell(std::pair<size_t,size_t>(6,6) );
	//lmm_abcd_calibrator.add_ConstraintCell(std::pair<size_t,size_t>(8,8) );

	lmm_abcd_calibrator.activate_PositiveConstraint();
	lmm_abcd_calibrator.solve();

	std::string result_file =base_name + "_abcd_calibration_result.csv";
	lmm_abcd_calibrator.printPlusPlus(result_file);

	std::string calibrated_abcd_file = base_name + "_abcd_calibrated.csv";
	pNoShifted_HGVolatilityParam->print(calibrated_abcd_file);

	// print in a common file
	{
		std::string common_result_file_name = "calib_result_ABCD.csv";
		std::string full_common_result_file = LMMPATH::get_Root_OutputPath() + common_result_file_name ;

		std::ofstream final_result ;
		final_result.open(full_common_result_file.c_str(), std::ios::app);

		final_result<<std::endl<<std::endl<< "============= Test At    "<<LMMPATH::get_TimeDateNow()
			<<",,,,,, Error LInf, "<<lmm_abcd_calibrator.get_QuoteError_LInf() <<std::endl ;
		final_result<< lmm_abcd_calibrator.get_BaseGeneral_Result_Info();

		final_result.close();	
	}

	return lmm_abcd_calibrator.get_Found_ABCD();
}