예제 #1
0
//-------------------------------------------------------****MAIN FUNCTION ****------------------------------------------------
int main()
{
	
	init_devices();
	lcd_set_4bit();
	lcd_init();
    lcd_cursor(1,1);
	lcd_string("START");
	_delay_ms(rand());
//--*** GRIPPER INITAL POSITION ***---
	S2 = 0x73;
	cli();
	timer0_init();
	TIMSK |= (1 << OCIE0) | (1 << TOIE0); // timer 0 compare match and overflow interrupt enable 
	sei();
	pickup();
	
	while(1)
	{
	if( bot_id_set == 1)
	{	
	
		init_devices2();
		init_grid();
		dispersion();
		localize();
		region_division();
		break;
	}
	
 }
 }
예제 #2
0
void MICROSTRIP::calc()
{
    /* effective permeability */
    mur_eff_ms();
    /* static impedance */
    microstrip_Z0();
    /* calculate freq dependence of er and Z0 */
    dispersion();
    /* calculate electrical lengths */
    line_angle();
    /* calculate losses */
    attenuation();
}
예제 #3
0
UpperTriangleVanillaSwaptionQuotes_ConstPTR create_UpperTriangleVanillaSwaptionQuotes(LMMTenorStructure_PTR pLMMTenorStructure, const Tenor& tenorfixedleg, const Tenor& tenorfloatleg)
{
	/// Creation of Rebonato Approx ==================================

	size_t nbFactor       = 3; // need to test nbFactor  = 3, and nbFactor = 
	size_t correlFullRank = pLMMTenorStructure->get_horizon()+1;
	size_t correlReducedRank = nbFactor;
	CorrelationReductionType::CorrelationReductionType correlReductionType = CorrelationReductionType::PCA;
	double correlAlpha = 0.0;
	double correlBeta  = 0.1;
	Correlation_PTR correlation(new XY_beta_Correlation(correlFullRank,correlReducedRank, correlReductionType,correlAlpha,correlBeta));
	correlation->calculate(); // for print.

	double a=0.22,b=0.4,c=0.6,d=0.15;
	double g_constParam = 1.;
	double shift_constParam = 0.0;

	Shifted_HGVolatilityParam::ABCDParameter abcdParam(a,b,c,d);
	ConstShifted_HGVolatilityParam_PTR pConstShifted_HGVolatilityParam( new ConstShifted_HGVolatilityParam(pLMMTenorStructure, abcdParam, g_constParam, shift_constParam));


	Shifted_HGVolatilityFunction_PTR pVolatilityFunction (new ConstShifted_HGVolatilityFunction(pLMMTenorStructure, correlation, pConstShifted_HGVolatilityParam)); 

	//! Dispersion
	Dispersion dispersion(pVolatilityFunction);

	Lmm_PTR lmm_ptr(new Lmm(dispersion) );

	LmmVanillaSwaptionApproxPricer_Rebonato_PTR pLmmApproxVanillaSwaptionPricer(new LmmVanillaSwaptionApproxPricer_Rebonato(lmm_ptr));	
	/// End of creation of Rebonato Approx ==================================


	LiborQuotes_ConstPTR libor_quote_ptr = LiborQuotes::create_LiborInit(pLMMTenorStructure, 0.02);

	UpperTriangleVanillaSwaptionQuotes_ConstPTR atm_swaption_implied_vol_ptr = UpperTriangleVanillaSwaptionQuotes::create_ATMSwaptionImpliedVol(
		libor_quote_ptr,
		tenorfixedleg,
		tenorfloatleg,
		pLmmApproxVanillaSwaptionPricer
		);

	//assert( atm_swaption_implied_vol_ptr->check_swaprate_consistency(libor_quote_ptr) );

	return atm_swaption_implied_vol_ptr;
}
예제 #4
0
double ResponseTable::dispersionVospr() const
{
    assert(m_values.size() > 0);

    if(m_values[0].size() < 2)
    {
        return disp_at_center();
    }

    assert(m_values[0].size() > 1);
    double result = 0;
    int count = 0;

    for(size_t i = 0; i < m_values.size(); i++)
    {
        int freedoms  = trusted_values_at(i).size() - 1;
        double disp = dispersion(i);
        result += disp * freedoms;
        count += freedoms;
    }

    result = result / (double)count;
    return result;
}
예제 #5
0
int ResponseTable::ongenericalDispersion(StaticCriteria criteria, double prob)
{
    if(m_values.size() < 1 || m_values[0].size() < 2)
        return 1;

    vector<double> dispersions;

    for(size_t i = 0; i < m_values.size(); i++)
        dispersions.push_back(dispersion(i));

    if(criteria == Fisher)
    {
        double minD = dispersions[0], maxD = dispersions[0];
        int minF = trusted_values_at(0).size() - 1, maxF = trusted_values_at(0).size() - 1;

        for(size_t i = 1; i < dispersions.size(); i++)
        {
            double d = dispersions[i];
            int f = trusted_values_at(i).size() - 1;

            if(d < minD)
            {
                minD = d;
                minF = f;
            }

            if(d > maxD)
            {
                maxD = d;
                maxF = f;
            }
        }

        double Ft = FisherCriteria::GetFisherVal(minF, maxF);
        double F = 0;

        if(minD == 0)
            return false;
        else
            F =  maxD / minD;

        return Ft > F ? 1 : 0;
    }
    else if(criteria == Kohren)
    {
        size_t trusted = trusted_values_at(0).size() - 1;

        for(size_t i = 1; i < dispersions.size(); i++)
            if(trusted != trusted_values_at(i).size() - 1)
            {
                error = "Проверяемые дисперсии имеют разные степени свободы";
                return -1;
            }


        double maxDisp = 0, dispSum = 0;

        for(size_t i = 0; i < dispersions.size(); i++)
        {
            dispSum += dispersions[i];

            if(maxDisp < dispersions[i])
                maxDisp = dispersions[i];
        }

        double Cr = maxDisp / dispSum;
        double tableVal = KohrenCriteria::GetCriteriaVal(dispersions.size(), trusted_values_at(0).size() - 1);
        return Cr < tableVal ? 1 : 0;
    }
    else if(criteria == Bartlet)
    {
        for(size_t i = 0; i < dispersions.size(); i++)
            if(trusted_values_at(i).size() - 1 < 3)
            {
                error = "Степени свободы всех дисперсий должны быть больше 3х";
                return -1;
            }

        double svDisp = 0;
        int f_sum = 0;

        for(size_t i = 0; i < dispersions.size(); i++)
        {
            svDisp += dispersions[i] * (trusted_values_at(i).size() - 1);
            f_sum += trusted_values_at(i).size() - 1;
        }

        svDisp /= f_sum;

        if(svDisp == 0)
            return 1;

        double temp = 0;

        for(size_t i = 0; i < dispersions.size(); i++)
            temp += (trusted_values_at(i).size() - 1) * log10(dispersions[i]);

        temp = f_sum * log10(svDisp) - temp;
        temp *= 2.303;                         // chislitel

        double tmp = 0;

        for(size_t i = 0; i < dispersions.size(); i++)
            tmp += 1 / (double)(trusted_values_at(i).size() - 1);

        tmp -= 1 / (double)f_sum;
        tmp *= 1 / (double)(3 * (dispersions.size() - 1));
        tmp += 1;

        double B = temp / tmp;

        double val = BartleteCriteria::GetCriteriaVal((int)(f_sum / dispersions.size()), prob);

        return val > B ? 1 : 0;
    }



}
예제 #6
0
void Test_McGeneticSwapLMMPricer()
{

	//! Parameters
	double	strike			=	0.02;
	LMM::Index	indexStart	=	0;
	LMM::Index	indexEnd	=	20;
	Tenor	floatingTenor	=	Tenor::_6M;
	Tenor	fixedTenor		=	Tenor::_12M;
	Tenor	tenorStruture	=	Tenor::_6M;
	size_t	horizonYear		=	10;
	LMMTenorStructure_PTR lmmTenorStructure( new LMMTenorStructure(tenorStruture, horizonYear));

	cout	<<	"strike:                        "	<<	strike												<<	endl;
	cout	<<	"indexStart:                    "	<<	indexStart											<<	endl;
	cout	<<	"indexEnd:                      "	<<	indexEnd											<<	endl;
	cout	<<	"tenorStrutureYearFraction:     "	<<	lmmTenorStructure->get_tenorType().YearFraction()	<<	endl;
	cout	<<	"floatingVStenorStrutureRatio:  "	<<	floatingTenor.ratioTo(tenorStruture)				<<	endl;
	cout	<<	"fixedVStenorStrutureRatio:     "	<<	fixedTenor.ratioTo(tenorStruture)					<<	endl;

	double	fwdRate		=	0.02;
	std::vector<double> liborsInitValue(lmmTenorStructure->get_horizon()+1, fwdRate);
	cout	<<	"myInitialLibor:  ";
	for (size_t i = 0; i <liborsInitValue.size(); i++)
	{
		cout	<<	liborsInitValue[i]	<<	" ";
	}
	cout	<<	 endl;
	cout	<<	 endl;


	//VanillaSwap_Chi_Trang
	VanillaSwap firstVersionVanillaSwap(strike, indexStart , indexEnd, floatingTenor, fixedTenor, lmmTenorStructure);
	LmmVanillaSwapPricer myVSP(lmmTenorStructure);
	double FirstVersionSwapPrice	=	myVSP.swapNPV_Analytical_1(firstVersionVanillaSwap, liborsInitValue);

	//---------------------------Build Lmm and McLmm's structure--------------------------------------
	//! Parameter of h
	double a = -0.06;
	double b = 0.17;
	double c = 0.54;
	double d = 0.17;
	Shifted_HGVolatilityParam::ABCDParameter abcdParam (a,b,c,d);
	//Parameter of hg
	double g_constParam = 1.0;
	double shift_constParam = -0.01;
	ConstShifted_HGVolatilityParam_PTR hgParam( new ConstShifted_HGVolatilityParam(lmmTenorStructure,abcdParam,g_constParam,shift_constParam));
	
	//! Correlation 1
	size_t nbFactor       = 3; // need to test nbFactor  = 3, and nbFactor = 
	size_t correlFullRank = lmmTenorStructure->get_horizon()+1;
	size_t correlReducedRank = nbFactor;
	//!"Check Parameters(): Condition not implemented yet."
	std::cout << "checkParams(): ";
	CorrelationReductionType::CorrelationReductionType correlReductionType = CorrelationReductionType::PCA;
	double correlAlpha = 0.0;
	double correlBeta  = 0.1;
	Correlation_PTR correlation(new XY_beta_Correlation(correlFullRank,correlReducedRank, correlReductionType,correlAlpha,correlBeta));
	correlation->calculate(); // for print.
	correlation->print("test_McTerminalLmm_Correlation.csv");
	//hgVolatilityFunction
	ConstShifted_HGVolatilityFunction_PTR hgVolatilityFunction (new ConstShifted_HGVolatilityFunction(lmmTenorStructure, correlation, hgParam)); 
	hgVolatilityFunction->print("test_McTerminalLmm_Volatility.csv");
	//! Dispersion
	Dispersion dispersion(hgVolatilityFunction);

	unsigned long seed = 5033;
	RNGenerator_PTR  rnGenerator(new McGenerator(seed));

	//build lmm and mcLmm model
	Lmm_PTR shiftedLmm (new Lmm(dispersion));
	McLmm_PTR mcLmm(new McTerminalLmm(shiftedLmm, liborsInitValue, rnGenerator, MCSchemeType::EULER));

	//build a McGeneticSwapLMMPricer
	McGeneticSwapLMMPricer_PTR mcGeneticSwapLMMPricer(new McGeneticSwapLMMPricer(mcLmm));

	//build the geneticVanillaSwap
	GeneticSwap_CONSTPTR vanillaSwap_Genetic=InstrumentFactory::createVanillaSwap(
			strike,indexStart,indexEnd,floatingTenor,fixedTenor,lmmTenorStructure,1.0);

	//use Monte Carlo Method
	size_t nbSimulation=10000;
	double	MonteCarloPrice		=	mcGeneticSwapLMMPricer->swapNPV(vanillaSwap_Genetic, nbSimulation);

	//ordinaryGeneticVanillaSwapPricer
	GeneticVanillaSwapPricer_PTR geneticVanillaSwapPricer(new GeneticVanillaSwapPricer());
	double	OrdinaryGeneticVanillaSwapPrice		=	geneticVanillaSwapPricer->geneticVanillaSwap_Analytical(vanillaSwap_Genetic,liborsInitValue);

	//subVanillaSwap
	LMM::Index	subIndexStart	=	10;
	LMM::Index	subIndexEnd		=	16;
	GeneticSwap_CONSTPTR subVanillaSwap_Genetic=InstrumentFactory::createVanillaSwap(
			strike,subIndexStart,subIndexEnd,floatingTenor,fixedTenor,lmmTenorStructure,1.0);
	double	subMonteCarloPrice	=	mcGeneticSwapLMMPricer->swapNPV(subVanillaSwap_Genetic, nbSimulation);
	//subOrdinaryGeneticVanillaSwapPrice
	double	subOrdinaryGeneticVanillaSwapPrice		=	geneticVanillaSwapPricer->geneticVanillaSwap_Analytical(subVanillaSwap_Genetic,liborsInitValue);
	//subFirstVersionVanillaSwapPrice
	VanillaSwap subFirstVersionVanillaSwap(strike, subIndexStart , subIndexEnd, floatingTenor, fixedTenor, lmmTenorStructure);
	double subFirstVersionSwapPrice		=	myVSP.swapNPV_Analytical_1(subFirstVersionVanillaSwap, liborsInitValue);


	cout	<<	"MonteCarloPrice: "																		<<	MonteCarloPrice													<<	endl;
	cout	<<	"OrdinaryGeneticVanillaSwapPrice: "														<<	OrdinaryGeneticVanillaSwapPrice									<<	endl;
	cout	<< "FirstVersionSwapPrice: "																<< FirstVersionSwapPrice											<< endl;
	cout	<<	"Difference between MonteCarloPrice and OrdinaryGeneticVanillaSwapPrice: "				<<	MonteCarloPrice-OrdinaryGeneticVanillaSwapPrice					<<	endl;	
	cout	<<	"Difference between OrdinaryGeneticVanillaSwapPrice and FirstVersionSwapPrice: "		<<	OrdinaryGeneticVanillaSwapPrice-FirstVersionSwapPrice			<<	endl;	
	cout	<<	"subMonteCarloPrice: "																	<<	subMonteCarloPrice												<<	endl;
	cout	<<	"subOrdinaryGeneticVanillaSwapPrice: "													<<	subOrdinaryGeneticVanillaSwapPrice								<<	endl;
	cout	<< "subFirstVersionSwapPrice: "																<< subFirstVersionSwapPrice											<< endl;
	cout	<<	"Difference between subMonteCarloPrice and subOrdinaryGeneticVanillaSwapPrice: "		<<	subMonteCarloPrice-subOrdinaryGeneticVanillaSwapPrice			<<	endl;	
	cout	<<	"Difference between subOrdinaryGeneticVanillaSwapPrice and subFirstVersionSwapPrice: "	<<	subOrdinaryGeneticVanillaSwapPrice-subFirstVersionSwapPrice		<<	endl;

	ofstream o;
	o.open("TestResult_GeneticVanillaSwap_05_06.csv",  ios::out | ios::app );
	o	<<	endl;
	o	<<	endl;
	o	<<	endl;
	o	<<	"strike: "									<<	strike														<<	endl;
	o	<<	"indexStart: "								<<	indexStart													<<	endl;
	o	<<	"indexEnd: "								<<	indexEnd													<<	endl;
	o	<<	"floatingTenorVSLmmStructureTenorRatio: "	<<	floatingTenor.ratioTo(lmmTenorStructure->get_tenorType())	<<	endl;
	o	<<	"fixedTenorVSLmmStructureTenorRatio: "		<<	fixedTenor.ratioTo(lmmTenorStructure->get_tenorType())		<<	endl;
	o	<<	"floatingTenorYearFraction: "				<<	floatingTenor.YearFraction()								<<	endl;
	o	<<	"fixedTenorYearFraction: "					<<	fixedTenor.YearFraction()									<<	endl;
	o	<<	"horizonYear: "								<<	horizonYear													<<	endl;
	o	<<	"liborsInitValue: ";
	for(size_t i=0; i<liborsInitValue.size(); i++)
	{
		o	<<	liborsInitValue[i]	<<	" ";
	}
	o	<<	endl;
	o	<<	"nbSimulation: "																		<<	nbSimulation													<<	endl;
	o	<<	"PRICES: "	<<	endl;
	o	<<	"MonteCarloPrice: "																		<<	MonteCarloPrice													<<	endl;
	o	<<	"OrdinaryGeneticVanillaSwapPrice: "														<<	OrdinaryGeneticVanillaSwapPrice									<<	endl;
	o	<<	"FirstVersionSwapPrice: "																<< FirstVersionSwapPrice											<<	endl;
	o	<<	"Difference between MonteCarloPrice and OrdinaryGeneticVanillaSwapPrice: "				<<	MonteCarloPrice-OrdinaryGeneticVanillaSwapPrice					<<	endl;	
	o	<<	"Difference between OrdinaryGeneticVanillaSwapPrice and FirstVersionSwapPrice: "		<<	OrdinaryGeneticVanillaSwapPrice-FirstVersionSwapPrice			<<	endl;
	o	<<	"SUBPRICES: "<<	endl;
	o	<<	"subIndexStart: "																		<<	subIndexStart													<<	endl;
	o	<<	"subIndexEnd: "																			<<	subIndexEnd														<<	endl;
	o	<<	"subMonteCarloPrice: "																	<<	subMonteCarloPrice												<<	endl;
	o	<<	"subOrdinaryGeneticVanillaSwapPrice: "													<<	subOrdinaryGeneticVanillaSwapPrice								<<	endl;
	o	<<	"subFirstVersionSwapPrice: "															<< subFirstVersionSwapPrice											<<	endl;
	o	<<	"Difference between subMonteCarloPrice and subOrdinaryGeneticVanillaSwapPrice: "		<<	subMonteCarloPrice-subOrdinaryGeneticVanillaSwapPrice			<<	endl;	
	o	<<	"Difference between subOrdinaryGeneticVanillaSwapPrice and subFirstVersionSwapPrice: "	<<	subOrdinaryGeneticVanillaSwapPrice-subFirstVersionSwapPrice		<<	endl;	

	o.close();
}
예제 #7
0
static void *trigger_run(void *arg)
{
	int buttons_fd;
    int flags=0, flags2=0;


    struct st_caller *caller;
    buttons_fd = open("/dev/buttons", 0);
	if (buttons_fd < 0) {
		perror("open device buttons");
		exit(1);
	}
#if 1
	for (;;) {
		char current_buttons[6];
		if (read(buttons_fd, current_buttons, sizeof current_buttons) != sizeof current_buttons) {
			perror("read buttons:");
			exit(1);
		}

		if (current_buttons[3] == '1' && flags2== 0 ){
			usleep(5000);
		}
		if (current_buttons[3] == '0' && flags2 == 1){
			usleep(5000);
		}
		if (current_buttons[3] == '1' && flags2 == 0){
			int ret;
			struct st_matrix *matrix;
			struct st_action_unit unit;
			bzero(&unit, sizeof unit);
			flags2 = 1;

			pthread_mutex_lock( &plan_mutex);
			matrix = gmatrix;
			if (!matrix){
				printf("head_caller err, matrix is NULL\n");
				pthread_mutex_unlock(&plan_mutex);
				break;
			}
			if (current_buttons[4] == '0' && flags ==1 && ARM_STATE == CALLER_SEND_BUSY){
              flags = 0;
              pthread_mutex_lock( &plan_mutex);
              caller_op(CALLER_SEND_IDEL);
              pthread_mutex_unlock( &plan_mutex);
              printf(" CALLER - BUS = %x\n", ARM_STATE);

       		}

			ARM_STATE = CALLER_SEND_BUSY;
			matrix->matrix_state[MATRIX_STATE] = MATRIX_CALLER;
			unit.dev_addr = matrix->dev.addr;
			unit.sdata[0] = 1;
			unit.sdata[1] = 0xff;
			unit.ssize 	  = 2;
			ret = dispersion(&unit);
			if (ret < 0){
				printf("head_caller err, dispersion return err\n");
				matrix->matrix_state[MATRIX_STATE] = MATRIX_IDLE;
				pthread_mutex_unlock(&plan_mutex);
				break;
			}
			matrix->matrix_state[MATRIX_STATE] = MATRIX_BUSY;

			pthread_mutex_unlock( &plan_mutex);
			}
			else if ( current_buttons[3] == '0' && flags2 == 1 ){
				struct st_matrix *matrix;

				int ret;
				matrix = gmatrix;
				printf("free\n");
                //if( matrix->matrix_state[MATRIX_STATE] == MATRIX_BUSY) {
                //    matrix->matrix_state[MATRIX_STATE] = MATRIX_CALLER;
                    ret = matrix_load_state(matrix);
                    if( ret < 0)  matrix->matrix_state[MATRIX_STATE] =  MATRIX_ERR;
                    else matrix->matrix_state[MATRIX_STATE] = MATRIX_IDLE;
                //}

            {
                struct st_action_unit new_unit;
                struct st_select_amp *amp;
                bzero(&new_unit, sizeof(new_unit));

                for( amp= gselect_amp; amp; amp = amp->next) {
                    if( amp->select_state[SELECT_AMP_STATE] == SELECT_AMP_BUSY){
                        int ret;
                        amp->select_state[SELECT_AMP_STATE] = SELECT_AMP_CALLER;
                        ret = select_amp_load_state(amp);
                        if( ret < 0){
                               amp->select_state[SELECT_AMP_STATE] = SELECT_AMP_ERR;
                               continue;
                        }
                        amp->select_state[SELECT_AMP_STATE] = SELECT_AMP_IDLE;
                	}
                }
            }

			ARM_STATE = CALLER_SEND_IDEL;
			flags2 = 0;
		}
        if(current_buttons[4] == '1' && flags == 0 && ARM_STATE == CALLER_SEND_IDEL) {
            usleep(5000);
        }
           if( current_buttons[4] == '1' && flags == 0 && ARM_STATE == CALLER_SEND_IDEL) {
               int ret;
               flags =1;
               pthread_mutex_lock( &plan_mutex);
               ret = caller_op( CALLER_SEND_LOOP );
               if( ret < 0 ){
                   flags = 0;  pthread_mutex_unlock( &plan_mutex);
               }
               pthread_mutex_unlock( &plan_mutex);
               for(caller=gcaller; caller; caller = caller->next) {
               printf("caller: \n\taddr=%x\n\tstate = %x\n", caller->dev.addr, caller->caller_state);
        }
        printf(" CALLER - BUS = %x\n", ARM_STATE);
        }else if (current_buttons[4] == '0' && flags ==1 && ARM_STATE == CALLER_SEND_BUSY){
              flags = 0;
              pthread_mutex_lock( &plan_mutex);
              caller_op(CALLER_SEND_IDEL);
              pthread_mutex_unlock( &plan_mutex);
              for(caller=gcaller; caller; caller = caller->next) {
              printf("caller: \n\taddr=%x\n\tstate = %x\n", caller->dev.addr, caller->caller_state);
              }
                printf(" CALLER - BUS = %x\n", ARM_STATE);
 //               system("madplay /0.mp3");
        }
        sleep(1);
    }
#endif
	close(buttons_fd);
	return NULL;
}
예제 #8
0
 typename std::enable_if<sizeof...(Args) == D, real_type>::type 
 dispersion(std::tuple<Args...> in){
      auto f = [this](Args... in){return dispersion(in...);};
      return tuple_tools::unfold_tuple(f,in);
 };
예제 #9
0
 /** Returns an analytic std::function of the dispersion. */
 ArgFunType get_dispersion(){ return tools::extract_tuple_f(std::function<real_type(arg_tuple)>([this](arg_tuple in){return dispersion(in);})); }
예제 #10
0
Shifted_HGVolatilityFunction_PTR JB_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 ;      // A corriger
	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 = JB_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>(1,3) );
	lmm_abcd_calibrator.add_ConstraintCell(std::pair<size_t,size_t>(3,1) );
	//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 pVolatilityFunction;
}
예제 #11
0
파일: DMFT.hpp 프로젝트: aeantipov/fk_df
inline real_type LatticeDMFTSC<LatticeT>::dispersion(const std::tuple<ArgTypes...>& kpoints) const
{
    static_assert(sizeof...(ArgTypes) == _D, "Number of points mismatch!" );
    std::function<real_type(ArgTypes...)> f1 = [&](ArgTypes... kpoints)->real_type{return dispersion(kpoints...);};
    auto f2 =tools::tuple_f(f1);
    return std::real(f2(kpoints));
}
예제 #12
0
Shifted_HGVolatilityFunction_PTR JB_marketData_LMM_shift_Calibration(	const LmmCalibrationConfig& config
											, LmmSwaptionMarketData_PTR pLmmSwaptionMarketData 
											, Shifted_HGVolatilityFunction_PTR param_h_g_function
											)
{
	assert(!config.use_local_calib_);
	size_t  nbYear= pLmmSwaptionMarketData->get_nbYear();
	std::string base_file_name = pLmmSwaptionMarketData->get_MarketDataBaseFileName();

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

	std::string base_name;
	base_name = base_file_name+"_shift_gMatrix_Calibration" ;

	Shifted_HGVolatilityParam_PTR	param_h_g	=	param_h_g_function->get_ShiftedHGVolatilityParam_PTR();

	//create LMM components
	LMMTenorStructure_PTR pLMMTenorStructure( new LMMTenorStructure(tenorfloatleg,nbYear) );
	const double a=param_h_g->get_ABCD().a_;
	const double b=param_h_g->get_ABCD().b_;
	const double c=param_h_g->get_ABCD().c_;
	const double d=param_h_g->get_ABCD().d_;

	Shifted_HGVolatilityParam::ABCDParameter abcdParam(a,b,c,d);

	const Shifted_HGVolatilityParam::LowerTriangularMatrix& gMatrix=param_h_g->get_gMatrix();

	QuantLib::Array shiftValues_QL = param_h_g->get_ArrayFrom_Shift();
	std::vector<double> shiftValues(shiftValues_QL.size());
	for(size_t i=0; i<shiftValues_QL.size(); i++)
		shiftValues[i]=shiftValues_QL[i];
	//const std::vector<double> shiftedVector(gMatrix.size1(), 0.0);

	ConstShifted_HGVolatilityParam_PTR pShifted_HGVolatilityParam( new ConstShifted_HGVolatilityParam(
																pLMMTenorStructure, abcdParam, gMatrix, shiftValues));
	Shifted_HGVolatilityFunction_PTR pShifted_VolatilityFunction (new ConstShifted_HGVolatilityFunction(
										pLMMTenorStructure, param_h_g_function->get_Correlation_PTR(), pShifted_HGVolatilityParam)); 
	Dispersion dispersion(pShifted_VolatilityFunction);
	Lmm_PTR lmm_ptr(new Lmm(dispersion) );

	LmmVanillaSwaptionApproxPricer_Rebonato_PTR pLmmVanillaSwaptionApproxPricer_Rebonato(new LmmVanillaSwaptionApproxPricer_Rebonato(lmm_ptr));	

	// create gMatrixMapping
	//size_t        g_matrix_size = GMatrixMapping::get_gSizeFromNbYear(nbYear,fixedfloatRatio );
	//size_t delegate_matrix_size = GMatrixMapping::get_gDelegateSizeFromHorizon(pLMMTenorStructure->get_horizon() ,fixedfloatRatio );
	//UpperTriangularDoubleMatrix empty_delegate_matrix(delegate_matrix_size,delegate_matrix_size);



	//pShifted_HGVolatilityParam->reset_g_matrix(gMatrix);
	pLmmVanillaSwaptionApproxPricer_Rebonato->update_VolatilityParam(pShifted_HGVolatilityParam);

	// Create const function
	//LmmPenalty_PTR pLmmPenalty(new LmmPenalty(config.penalty_time_homogeneity_,config.penalty_libor_) );

	//LmmBaseCostFunction_PTR pLmmCostFunction(new LmmGlobal_gCostFunction
	//	(
	//	pLmmVanillaSwaptionApproxPricer_Rebonato,
	//	pLmmSwaptionMarketData->get_LiborQuotes(),
	//	pLmmSwaptionMarketData->get_SwaptionQuotes_ATM(),
	//	pGMatrixMapping,
	//	pNoShifted_HGVolatilityParam,
	//	pLmmPenalty
	//	) );

	const double const_rate=0.02;
	const double quoted_strike_bump=0.0001;
	LmmSwaptionMarketData_PTR lmmSwaptionMarketData(new LmmSwaptionMarketData(tenorfixedleg, tenorfloatleg, gMatrix.size1()+3));

	

	LmmSkewCostFunction lmmSkewCostFunction(	pLmmVanillaSwaptionApproxPricer_Rebonato                // pricer  
											   , pLmmSwaptionMarketData->get_LiborQuotes()
											   , quoted_strike_bump
											   , pLmmSwaptionMarketData->get_SwaptionQuotes_skew()// instrument to calibrate 
											   , param_h_g );

	//for(size_t i = 0; i < 3; i++)
	//{
	//	for (size_t j = 1; j < nbYear-i; j++)
	//		{
	//			lmmSkewCostFunction.addContraintCell(std::pair<size_t,size_t>(j,nbYear-i-j));
	//		}
	//}

	//costumize swaptions weights
	//UpperTriangularDoubleMatrix swpm_weight_matrix = pLmmCostFunction->get_SwaptionWeightMatrix();
	//swpm_weight_matrix(7,1)=1e-6;
	//swpm_weight_matrix(10,1)=1e-6;
	//swpm_weight_matrix(5,3)=0.;
	//pLmmCostFunction->reset_SwaptionWeightMatrix(swpm_weight_matrix);

	// Create Calibrator
	QuantLib::Array init_shift(gMatrix.size1(),0.01);
	



	LmmShiftCalibrator lmmShiftCalibrator							(	init_shift
																		, 200 //maxIter
																		, 1e-11   //x_epsilon
																		, 1e-11   //f_epsilon  
																		, lmmSkewCostFunction			
																	);


	//if(config.use_positive_constraint_)
	//	lmmShiftCalibrator.activate_PositiveConstraint();

	lmmShiftCalibrator.solve();

	std::ostringstream file_result_stream;file_result_stream<<base_name<<"_result.csv";
	std::string file_calibration_result(file_result_stream.str());
	lmmShiftCalibrator.printPlusPlus(file_calibration_result);

	std::ostringstream file_vol_stream; file_vol_stream<<base_name<<".csv";
	std::string file_calibrated_vol(file_vol_stream.str() );
	param_h_g->print(file_calibrated_vol);


	pLmmSwaptionMarketData->print("pLmmSwaptionMarketData.csv");

	//std::ostringstream file_result_stream;file_result_stream<<base_name<<penalty_info_str<<"_result.csv";
	//std::string file_calibration_result(file_result_stream.str());
	//lmmShiftCalibrator.printPlusPlus(file_calibration_result);


	//std::ostringstream file_vol_stream;file_vol_stream<<base_name<<penalty_info_str<<"_vol.csv";
	//std::string file_calibrated_vol(file_vol_stream.str() );
	//pShifted_HGVolatilityParam->print( file_calibrated_vol );


	//{
	//	std::string common_result_file_name = "calib_result_Shift_gGlobal.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, "<<lmmShiftCalibrator.get_QuoteError_LInf() <<std::endl ;
	//	final_result<< lmmShiftCalibrator.get_BaseGeneral_Result_Info();

	//	final_result.close();	
	//}

	return pShifted_VolatilityFunction;
}
예제 #13
0
GMatrix_Vol_gMapping JB_marketData_LMM_Global_gCalibration( const LmmCalibrationConfig& config
															, LmmSwaptionMarketData_PTR pLmmSwaptionMarketData 
															, Shifted_HGVolatilityFunction_PTR shifted_HGVolatilityFunction
															, Correlation_PTR found_correlation_ptr  
															, GMatrixMapping_PTR init_gMapping
															)
{
	assert(!config.use_local_calib_);				//?
	size_t nbYear = pLmmSwaptionMarketData->get_nbYear();				//nbYear
	std::string base_file_name = pLmmSwaptionMarketData->get_MarketDataBaseFileName();			

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

	std::string base_name;
	base_name = base_file_name+"_gMatrixGlobalCalibration" ;

	Shifted_HGVolatilityParam_PTR shifted_HGVolatilityParam	=	shifted_HGVolatilityFunction->get_ShiftedHGVolatilityParam_PTR();

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

	const double a=shifted_HGVolatilityParam->get_ABCD().a_;
	const double b=shifted_HGVolatilityParam->get_ABCD().b_;
	const double c=shifted_HGVolatilityParam->get_ABCD().c_;
	const double d=shifted_HGVolatilityParam->get_ABCD().d_;

	QuantLib::Array shiftValues_QL = shifted_HGVolatilityParam->get_ArrayFrom_Shift();
	std::vector<double> shiftValues(shiftValues_QL.size());
	for(size_t i=0; i<shiftValues_QL.size(); i++)
		shiftValues[i]=shiftValues_QL[i];
	const Shifted_HGVolatilityParam::LowerTriangularMatrix pGMatrix(shifted_HGVolatilityParam->get_gMatrix());
	Shifted_HGVolatilityParam::ABCDParameter abcdParam(a,b,c,d);

	ConstShifted_HGVolatilityParam_PTR pShifted_HGVolatilityParam( new ConstShifted_HGVolatilityParam(
				pLMMTenorStructure, abcdParam, pGMatrix, shiftValues));

	Shifted_HGVolatilityFunction_PTR pVolatilityFunction (new ConstShifted_HGVolatilityFunction(pLMMTenorStructure,  found_correlation_ptr, pShifted_HGVolatilityParam)); 
	Dispersion dispersion(pVolatilityFunction);
	Lmm_PTR lmm_ptr(new Lmm(dispersion) );

	LmmVanillaSwaptionApproxPricer_Rebonato_PTR pLmmVanillaSwaptionApproxPricer_Rebonato(new LmmVanillaSwaptionApproxPricer_Rebonato(lmm_ptr));	

	// create gMatrixMapping
	size_t        g_matrix_size = GMatrixMapping::get_gSizeFromNbYear(nbYear,fixedfloatRatio );
	size_t delegate_matrix_size = GMatrixMapping::get_gDelegateSizeFromHorizon(pLMMTenorStructure->get_horizon() ,fixedfloatRatio );
	UpperTriangularDoubleMatrix empty_delegate_matrix(delegate_matrix_size,delegate_matrix_size);

	GMatrixMapping_PTR pGMatrixMapping;
	if(init_gMapping)
	{
		pGMatrixMapping = init_gMapping;
	}
	else
	{
		//initiate gMatrixMapping all gDelegate to 1
		pGMatrixMapping.reset( new GMatrixMapping(g_matrix_size, empty_delegate_matrix, pLmmSwaptionMarketData->get_SwaptionQuotes_ATM()->get_UpperTriangularIndexPairMatrix())  );
		QuantLib::Array g_delegate_vector =  pGMatrixMapping->get_DelegateArray();
		for(size_t i=0;i<g_delegate_vector.size();++i) g_delegate_vector[i] = 1.;
		pGMatrixMapping->reset_gDelegate(g_delegate_vector);
	}

	pShifted_HGVolatilityParam->reset_g_matrix( pGMatrixMapping->get_g_Ref() );
	pLmmVanillaSwaptionApproxPricer_Rebonato->update_VolatilityParam(pShifted_HGVolatilityParam);

	// Create const function
	LmmPenalty_PTR pLmmPenalty(new LmmPenalty(config.penalty_time_homogeneity_,config.penalty_libor_) );

	LmmBaseCostFunction_PTR pLmmCostFunction(new LmmGlobal_gCostFunction
		(
		pLmmVanillaSwaptionApproxPricer_Rebonato,
		pLmmSwaptionMarketData->get_LiborQuotes(),
		pLmmSwaptionMarketData->get_SwaptionQuotes_ATM(),
		pGMatrixMapping,
		pShifted_HGVolatilityParam,
		pLmmPenalty
		) );

	//costumize swaptions weights
	UpperTriangularDoubleMatrix swpm_weight_matrix = pLmmCostFunction->get_SwaptionWeightMatrix();
	//swpm_weight_matrix(7,1)=1e-6;
	//swpm_weight_matrix(10,1)=1e-6;
	//swpm_weight_matrix(5,3)=0.;
	pLmmCostFunction->reset_SwaptionWeightMatrix(swpm_weight_matrix);

	//std::ostringstream file_costfunc_stream;file_costfunc_stream<<base_name<<"Calibration_"<<nbYear<<"YR_pel_time"<<penalty_time_homogene<<"_pel_lib"<<penalty_libor <<"_LmmCostFunction.csv";
	//pLmmCostFunction->print( file_costfunc_stream.str() );

	// Create Calibrator
	LmmGlobal_gCalibrator lmmCalibrator
		(
		*pGMatrixMapping.get()
		, 200 //maxIter
		, 1e-11   //x_epsilon
		, 1e-11   //f_epsilon    
		, pLmmCostFunction
		);

	if(config.use_positive_constraint_)
		lmmCalibrator.activate_PositiveConstraint();

	lmmCalibrator.solve();

	std::string penalty_info_str;
	if( !pLmmPenalty->isEmpty() )
	{
		const double pT = config.penalty_time_homogeneity_;
		const double pL = config.penalty_libor_ ;
		std::ostringstream pel; pel<<"_pT_"<<pT<<"_pL_"<<pL;
		penalty_info_str = pel.str();
	}

	std::ostringstream file_result_stream;file_result_stream<<base_name<<penalty_info_str<<"_result.csv";
	std::string file_calibration_result(file_result_stream.str());
	lmmCalibrator.printPlusPlus(file_calibration_result);

	std::ostringstream file_gDelegate_stream;file_gDelegate_stream<<base_name<<penalty_info_str<<"_gDelegate.csv";
	std::string file_gDelegate_vol(file_gDelegate_stream.str() );
	pGMatrixMapping->print(file_gDelegate_vol);

	std::ostringstream file_vol_stream;file_vol_stream<<base_name<<penalty_info_str<<"_vol.csv";
	std::string file_calibrated_vol(file_vol_stream.str() );
	pShifted_HGVolatilityParam->print( file_calibrated_vol );


	config.result_quote_error_l2 = lmmCalibrator.get_QuoteError_L2();
	config.result_quote_error_l1  = lmmCalibrator.get_QuoteError_L1();
	config.result_quote_error_linf  = lmmCalibrator.get_QuoteError_LInf();

	if( !pLmmPenalty->isEmpty() )
	{
		config.result_pelTime_error_l2  = lmmCalibrator.get_PenaltyTimeHomogeneity_L2();
		config.result_pelTime_error_l1  = lmmCalibrator.get_PenaltyTimeHomogeneity_L1();
		config.result_pelTime_error_linf  = lmmCalibrator.get_PenaltyTimeHomogeneity_L_INF();
		config.result_pelLibor_error_l2  = lmmCalibrator.get_PenaltySmoothMaturity_L2();
		config.result_pelLibor_error_l1  = lmmCalibrator.get_PenaltySmoothMaturity_L1();
		config.result_pelLibor_error_linf  = lmmCalibrator.get_PenaltySmoothMaturity_L_INF();
	}

	{
		std::string common_result_file_name = "calib_result_gGlobal.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, "<<lmmCalibrator.get_QuoteError_LInf() <<std::endl ;
		final_result<< lmmCalibrator.get_BaseGeneral_Result_Info();

		final_result.close();	
	}
	return GMatrix_Vol_gMapping(pVolatilityFunction,pGMatrixMapping);
}
예제 #14
0
Correlation_PTR JB_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 = JB_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 ;
}
예제 #15
0
void marketData_LMM_Local_gCalibration( const LmmCalibrationConfig& config
									   , LmmSwaptionMarketData_PTR pLmmSwaptionMarketData 
									   , const QuantLib::Array& abcd_param 
									   , Correlation_PTR found_correlation_ptr  
									   , GMatrixMapping_PTR init_gMapping 
									   )
{
	assert(config.use_local_calib_);
	size_t nbYear = pLmmSwaptionMarketData->get_nbYear();
	std::string base_file_name = pLmmSwaptionMarketData->get_MarketDataBaseFileName();

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

	std::string base_name;
	base_name = base_file_name+"_gMatrixLocalCalibration" ;

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

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

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

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

	LmmVanillaSwaptionApproxPricer_Rebonato_PTR pLmmVanillaSwaptionApproxPricer_Rebonato(new LmmVanillaSwaptionApproxPricer_Rebonato(lmm_ptr));	

	// create gMatrixMapping
	size_t        g_matrix_size = GMatrixMapping::get_gSizeFromNbYear(nbYear,fixedfloatRatio );
	size_t delegate_matrix_size = GMatrixMapping::get_gDelegateSizeFromHorizon(pLMMTenorStructure->get_horizon() ,fixedfloatRatio );
	UpperTriangularDoubleMatrix empty_delegate_matrix(delegate_matrix_size,delegate_matrix_size);

	GMatrixMapping_PTR pGMatrixMapping;
	if(init_gMapping)
	{
		pGMatrixMapping = init_gMapping;
	}
	else
	{
		//initiate gMatrixMapping all gDelegate to 1
		pGMatrixMapping.reset( new GMatrixMapping(g_matrix_size, empty_delegate_matrix, pLmmSwaptionMarketData->get_SwaptionQuotes_ATM()->get_UpperTriangularIndexPairMatrix())  );
		QuantLib::Array g_delegate_vector =  pGMatrixMapping->get_DelegateArray();
		for(size_t i=0;i<g_delegate_vector.size();++i) g_delegate_vector[i] = 1.;
		pGMatrixMapping->reset_gDelegate(g_delegate_vector);
	}

	pNoShifted_HGVolatilityParam->reset_g_matrix( pGMatrixMapping->get_g_Ref() );
	pLmmVanillaSwaptionApproxPricer_Rebonato->update_VolatilityParam(pNoShifted_HGVolatilityParam);

	LmmBaseCostFunction_PTR pLmmCostFunction(new LmmLocal_gCostFunction
		(
		pLmmVanillaSwaptionApproxPricer_Rebonato,
		pLmmSwaptionMarketData->get_LiborQuotes(),
		pLmmSwaptionMarketData->get_SwaptionQuotes_ATM(),
		pGMatrixMapping,
		pNoShifted_HGVolatilityParam
		) );

	//costumize swaptions weights
	UpperTriangularDoubleMatrix swpm_weight_matrix = pLmmCostFunction->get_SwaptionWeightMatrix();
	//swpm_weight_matrix(7,1)=1e-6;
	//swpm_weight_matrix(10,1)=1e-6;
	//swpm_weight_matrix(5,3)=0.;
	pLmmCostFunction->reset_SwaptionWeightMatrix(swpm_weight_matrix);

	// Create Calibrator
	LmmLocal_gCalibrator lmmCalibrator
		(
		*pGMatrixMapping.get()
		, 3000 //maxIter
		, 1e-11   //x_epsilon
		, 1e-11   //f_epsilon    
		, pLmmCostFunction
		);

	if(config.use_positive_constraint_)
		lmmCalibrator.activate_PositiveConstraint();

	lmmCalibrator.solve();

	std::ostringstream file_result_stream;file_result_stream<<base_name<<"_result.csv";
	std::string file_calibration_result(file_result_stream.str());
	lmmCalibrator.printPlusPlus(file_calibration_result);

	std::ostringstream file_gDelegate_stream;file_gDelegate_stream<<base_name<<"_gDelegate.csv";
	std::string file_gDelegate_vol(file_gDelegate_stream.str() );
	pGMatrixMapping->print(file_gDelegate_vol);

	std::ostringstream file_vol_stream;file_vol_stream<<base_name<<"_vol.csv";
	std::string file_calibrated_vol(file_vol_stream.str() );
	pNoShifted_HGVolatilityParam->print( file_calibrated_vol );


	{
		std::string common_result_file_name = "calib_result_gLocal.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, "<<lmmCalibrator.get_QuoteError_LInf() <<std::endl ;
		final_result<< lmmCalibrator.get_BaseGeneral_Result_Info();

		final_result.close();	
	}
}
예제 #16
0
GMatrixMapping_PTR marketData_LMM_CascadeExact_calibration( const LmmCalibrationConfig& config
														   , LmmSwaptionMarketData_PTR pLmmSwaptionMarketData 
														   , const QuantLib::Array& abcd_param 
														   , Correlation_PTR found_correlation_ptr 
														   )
{
	size_t nbYear = pLmmSwaptionMarketData->get_nbYear();
	std::string base_file_name = pLmmSwaptionMarketData->get_MarketDataBaseFileName();

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

	std::string base_name=base_file_name +"_gMatrixCascadeCalibration" ;

	std::ostringstream file_lmm_mkt_stream;file_lmm_mkt_stream<<base_name<<"_Quotation_"<<nbYear<<"YR_.csv";
	pLmmSwaptionMarketData->print(file_lmm_mkt_stream.str());

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

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

	//const double a=0.0438867,b=0.0179444,c=0.554972,d=0.121429;/// ATTENTION< TEMPORARY, TODELETE and uses abcd calibrator above

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

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

	LmmVanillaSwaptionApproxPricer_Rebonato_PTR pLmmVanillaSwaptionApproxPricer_Rebonato(new LmmVanillaSwaptionApproxPricer_Rebonato(lmm_ptr));	

	// create gMatrixMapping
	size_t        g_matrix_size = GMatrixMapping::get_gSizeFromNbYear(nbYear,fixedfloatRatio );
	size_t delegate_matrix_size = GMatrixMapping::get_gDelegateSizeFromHorizon(pLMMTenorStructure->get_horizon() ,fixedfloatRatio );
	UpperTriangularDoubleMatrix empty_delegate_matrix(delegate_matrix_size,delegate_matrix_size);

	GMatrixMapping_PTR pGMatrixMapping( new GMatrixMapping(g_matrix_size, empty_delegate_matrix, pLmmSwaptionMarketData->get_SwaptionQuotes_ATM()->get_UpperTriangularIndexPairMatrix())  );

	//initiate gMatrixMapping all gDelegate to 1
	QuantLib::Array g_delegate_vector =  pGMatrixMapping->get_DelegateArray();
	for(size_t i=0;i<g_delegate_vector.size();++i) g_delegate_vector[i] = 1.;
	pGMatrixMapping->reset_gDelegate(g_delegate_vector);

	pNoShifted_HGVolatilityParam->reset_g_matrix( pGMatrixMapping->get_g_Ref() );
	pLmmVanillaSwaptionApproxPricer_Rebonato->update_VolatilityParam(pNoShifted_HGVolatilityParam);

	LmmBaseCostFunction_PTR pLmmCascadeCostFunction (
		new LmmCascade_gCostFunction
		(
		pLmmVanillaSwaptionApproxPricer_Rebonato
		,pLmmSwaptionMarketData->get_LiborQuotes()
		,pLmmSwaptionMarketData->get_SwaptionQuotes_ATM()
		,pGMatrixMapping
		,pNoShifted_HGVolatilityParam
		)
		);

	UpperTriangularDoubleMatrix copy_weight_matrix = pLmmCascadeCostFunction->get_SwaptionWeightMatrix();

	//copy_weight_matrix(2,1)=1000;

	pLmmCascadeCostFunction->reset_SwaptionWeightMatrix(copy_weight_matrix);

	LmmCascade_gCalibrator lmmCalibrator
		(
		*pGMatrixMapping.get()
		, 100000 // config.maxIter
		, 1e-12  // config.x_epsilon
		, 1e-10  // config.f_epsilon    
		, pLmmCascadeCostFunction
		);

	if(config.use_positive_constraint_)
		lmmCalibrator.activate_PositiveConstraint();

	lmmCalibrator.solve();

	std::ostringstream file_vol_stream;file_vol_stream<<base_name<<"_vol.csv";
	std::string file_calibrated_vol(file_vol_stream.str() );
	pNoShifted_HGVolatilityParam->print( file_calibrated_vol );

	std::ostringstream file_result_stream;file_result_stream<<base_name<<"_result.csv";
	std::string file_calibration_result(file_result_stream.str());
	lmmCalibrator.printPlusPlus(file_calibration_result);

	std::ostringstream file_gDelegate_stream;file_gDelegate_stream<<base_name<<"_gDelegate.csv";
	std::string file_gDelegate_vol(file_gDelegate_stream.str() );
	pGMatrixMapping->print(file_gDelegate_vol);

	// print in a common file
	{
		std::string common_result_file_name = "calib_result_gCascade.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, "<<lmmCalibrator.get_QuoteError_LInf() <<std::endl ;
		final_result<< lmmCalibrator.get_BaseGeneral_Result_Info();

		final_result.close();	
	}

	return pGMatrixMapping;
}