예제 #1
0
PyObject *
Filter_SubFileDecode(PyObject * self, PyObject * args)
{
    PyObject * target;
    PyObject * delim_object;
    SubFileDecodeState * state;
    int length;

    if (!PyArg_ParseTuple(args, "OS", &target, &delim_object))
	return NULL;

    length = PyString_Size(delim_object);
    if (length < 1)
	return PyErr_Format(PyExc_ValueError, "empty delimiter");
    state = PyMem_Malloc(sizeof (SubFileDecodeState) + length * sizeof(int));
    if (!state)
	return PyErr_NoMemory();
    state->delim_object = delim_object;
    Py_INCREF(state->delim_object);
    state->delim = PyString_AsString(delim_object);
    state->chars_matched = 0;
    state->length = length;
    init_shift(state);
    
    return Filter_NewDecoder(target, "SubFileDecode", 0, read_subfile,
			     NULL, dealloc_subfile, state);
}
예제 #2
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;
}
예제 #3
0
//---------------------------------------------------------------------------
// mpi_slaving:
//---------------------------------------------------------------------------
int mpi_slaving()
{
    // Declare local variables
    MPI_Datatype MPI_SLAVEINF;	/* Dataype for MPI communications       */
    slaveinfo sl_info;		/* Information structure for slaves     */
    MPI_Status *status;		/* Recv status handler                  */
    int used_size;		/* # of processors used                 */

    long sfN;			/* # of pixels in subfield              */
    float *data = NULL;		/* subfield data burst                  */
    float *winH = NULL;		/* apodisation window for SR calc.      */
    float *winF = NULL;		/* apodisation window for phase rec.    */
    float *mask = NULL;		/* DiffLim Mask                         */
    float *pc = NULL;		/* Phase Consistency                    */

    /* for reallocation: needs to be NULL   */
    int *shifts = NULL;		/* shifts for KT Cross Spectra          */
    /* for reallocation: needs to be NULL   */
    int maxk;			/* number of shifts                     */

    // Triple correlation part
    long *index = NULL;		/* index list for bispectrum vectors    */
    long bs_cnt;		/* # of vectors used                    */
    float *bsc = NULL;		/* complex non-red/red bispectrum       */
    float *wc = NULL;		/* complex non-red/red bs weights       */
    float *p1 = NULL;		/* phase matrix for iterativ reconstr.  */
    float *aphs = NULL;		/* average of low frequencies           */

    // General part
    float *phs = NULL;		/* Phase of reconstructed image         */
    float *amp = NULL;		/* Amplitude of reconstructed image     */
    int c = GO;			/* helpers                              */
    long i;



    // set up status variable for sends and receives
    status = (MPI_Status *) malloc(sizeof(MPI_Status));

    // Set Slaveinfo datatype for MPI sends and receives
    mpi_setslavetype(&MPI_SLAVEINF);

    // Receive number of jobs ...
    MPI_Bcast(&used_size, 1, MPI_INT, 0, MPI_COMM_WORLD);

    // ...and if used_size = NOGO, we are quitting the slave!
    if (used_size == NOGO) {
		// free memory
		MPI_Type_free(&MPI_SLAVEINF);
		free(status);
		// returning NOGO quits the slaves in entry.c
		return NOGO;
    }
    // ...and decide if I am needed
    if (used_size > proc_id) {
	// work until TAG says NOGO
		while (GO) {
			// Receive the data information
			MPI_Recv(&sl_info, 1, MPI_SLAVEINF, 0, MPI_ANY_TAG, MPI_COMM_WORLD, status);

			// Break if shutdown signal was sent
			if (status->MPI_TAG == NOGO)
				break;

			if (status->MPI_TAG == TC) {
			/* First time allocation of memory */
				if (c) {
					// find number of pixels in subfield
					sfN = sl_info.sfsizex * sl_info.sfsizey;
					// allocate memory for data
					data = (float *) malloc(sfN * sl_info.nrofframes * sizeof(float));
					winH = (float *) malloc(sfN * sizeof(float));
					winF = (float *) malloc(sfN * sizeof(float));
					pc = (float *) malloc(sfN * sizeof(float));

					/* Initialise hamming window, fractional hamming & mask */
					hanming(winH, sl_info.sfsizex, sl_info.sfsizey, 0.5);
					frachamming(winF, sl_info.sfsizex, sl_info.sfsizey, sl_info.limApod, 0, NULL);
					// mask is no longer used...
					mask = ellmask(sl_info.sfsizex, sl_info.sfsizey, NULL, sl_info.rad_x, sl_info.rad_y);

					// allocate appropriate memory
					index = bs_init(&bs_cnt, sl_info);

					bsc = (float *) malloc(2 * bs_cnt * sizeof(float));
					wc = (float *) malloc(bs_cnt * sizeof(float));

					// Allocate memory for reconstructed amplitudes & phases
					amp = (float *) malloc(sfN * sizeof(float));
					phs = (float *) malloc(2 * sfN * sizeof(float));
					p1 = (float *) malloc(2 * sfN * sizeof(float));

					// set flag so as to not allocate new memory later
					c = NOGO;
				}
			// initialise amps, phases & phase consistency to zero
				memset(bsc, 0.0, 2 * bs_cnt * sizeof(float));
				memset(wc, 0.0, bs_cnt * sizeof(float));
				memset(amp, 0.0, sfN * sizeof(float));
				memset(phs, 0.0, 2 * sfN * sizeof(float));
				memset(p1, 0.0, 2 * sfN * sizeof(float));
				memset(pc, 0.0, sfN * sizeof(float));

				// finally receive the data
				MPI_Recv(data, sfN * sl_info.nrofframes, MPI_FLOAT, 0, MPI_ANY_TAG, MPI_COMM_WORLD, status);

				// compute mean of burst
				//mean(data, sl_info.sfsizex, sl_info.sfsizey, sl_info.nrofframes, temp);

				/* compute the position of the 'good' average phase parts
				 	 3 is an argument here because we deleted:
				   ((int) (alpha[0] * i_rad) > 3 ?
					(int) (alpha[0] * i_rad) : 3),  	*/
				init_shift(sl_info.sfsizex / 2, sl_info.sfsizey / 2, 3, &maxk, &shifts);

				// create bi-spectrum/weights in non-redundant matrix
				aphs = bs_ave(data, winF, sl_info, index, bs_cnt, bsc, wc, amp, maxk, shifts);

				// set snr-threshold
				bs_snrt(wc, bs_cnt, &sl_info);

				// phase reconstruction
				//   init phase matrices
				phs_init(phs, p1, pc, sl_info, maxk, shifts, aphs);

				//   recursive approach
				rpr(phs, p1, pc, index, bs_cnt, bsc, wc, sl_info);

				//   iterative approach
				for (i = 0; i < sl_info.max_it; i++) {
					iwlspr(phs, p1, pc, bsc, wc, index, bs_cnt, sl_info, maxk);
					if (chkphase(sl_info, phs) < 1.0e-5)
						break;
				}

				// Send back info, so master knows, which subfield burst this was
				// MPI_TAG will indicate whether we are at the end of the process
				MPI_Send(&sl_info, 1, MPI_SLAVEINF, 0, NOGO, MPI_COMM_WORLD);

				// Send back processed data
				MPI_Send(amp, sfN, MPI_FLOAT, 0, NOGO, MPI_COMM_WORLD);
				// send back phase
				MPI_Send(phs, 2 * sfN, MPI_FLOAT, 0, NOGO, MPI_COMM_WORLD);

				// free some memory
				free(shifts);
				shifts = NULL;
				free(aphs);
				aphs = NULL;
			}
		}

		// free memory
		if (data != NULL)
			free(data);
		if (winH != NULL)
			free(winH);
		if (winF != NULL)
			free(winF);
		if (mask != NULL)
			free(mask);
		if (pc != NULL)
			free(pc);
		if (shifts != NULL)
			free(shifts);
		if (amp != NULL)
			free(amp);
		if (phs != NULL)
			free(phs);
		if (index != NULL)
			free(index);
		if (p1 != NULL)
			free(p1);
		if (bsc != NULL)
			free(bsc);
		if (wc != NULL)
			free(wc);
		
		free(status);
		MPI_Type_free(&MPI_SLAVEINF);
		// idle until new data or shutdown Broadcast is sent
		return GO;
    }
    else {
		// free memory
		free(status);
		MPI_Type_free(&MPI_SLAVEINF);
		// idle until new data or shutdown Broadcast is sent
		return GO;
    }
}