Context Navigation

main.cpp @ 1365

Revision 1365, 20.4 kB (checked in by sindj, 13 years ago)
Cele rozkopano a znovu poskladano za ucelem spravne integrace a nic - jen se mi podarilo doplnit faktor 1/2^{n. Sakris. JS}

Rev	Line
[976]	1
	2	/*!
	3	\file
	4	\brief Robust
	5	\author Vasek Smidl
	6
	7	*/
	8
[1337]	9	#include "estim/arx.h"
[976]	10	#include "robustlib.h"
[1216]	11	#include <vector>
[1284]	12	#include <iostream>
[1282]	13	#include <fstream>
[1338]	14	#include <itpp/itsignal.h>
[1361]	15	#include "windows.h"
	16	#include "ddeml.h"
	17	#include "stdio.h"
[1282]	18
[1361]	19	//#include "DDEClient.h"
	20	//#include <conio.h>
[1358]	21
[1361]	22
[1208]	23	using namespace itpp;
[1337]	24	using namespace bdm;
[976]	25
[1361]	26	//const int emlig_size = 2;
	27	//const int utility_constant = 5;
[1268]	28
[1361]	29	const int max_model_order = 2;
[1272]	30
[1361]	31
	32
	33	HDDEDATA CALLBACK DdeCallback(
	34	UINT uType, // Transaction type.
	35	UINT uFmt, // Clipboard data format.
	36	HCONV hconv, // Handle to the conversation.
	37	HSZ hsz1, // Handle to a string.
	38	HSZ hsz2, // Handle to a string.
	39	HDDEDATA hdata, // Handle to a global memory object.
	40	DWORD dwData1, // Transaction-specific data.
	41	DWORD dwData2) // Transaction-specific data.
	42	{
	43	return 0;
	44	}
	45
	46	void DDERequest(DWORD idInst, HCONV hConv, char* szItem)
	47	{
	48	HSZ hszItem = DdeCreateStringHandle(idInst, szItem, 0);
	49	HDDEDATA hData = DdeClientTransaction(NULL,0,hConv,hszItem,CF_TEXT,
[1365]	50	XTYP_ADVSTART,TIMEOUT_ASYNC , NULL); //TIMEOUT_ASYNC
[1361]	51	if (hData==NULL)
	52	{
	53	printf("Request failed: %s\n", szItem);
	54	}
	55
	56	if (hData==0)
	57	{
	58	printf("Request failed: %s\n", szItem);
	59	}
	60	}
	61
	62	class model
	63	{
[976]	64
[1337]	65
[1361]	66	public:
	67	list<pair<int,int>> ar_components;
[1358]	68
[1361]	69	// Best thing would be to inherit the two models from a single souce, this is planned, but now structurally
	70	// problematic.
	71	RARX* my_rarx;
	72	ARXwin* my_arx;
	73
	74	bool has_constant;
	75	int window_size;
	76	int predicted_channel;
	77	mat* data_matrix;
	78
	79	model(list<pair<int,int>> ar_components,
	80	bool robust,
	81	bool has_constant,
	82	int window_size,
	83	int predicted_channel,
	84	mat* data_matrix)
[1358]	85	{
[1361]	86	this->ar_components.insert(this->ar_components.begin(),ar_components.begin(),ar_components.end());
	87	this->has_constant = has_constant;
	88	this->window_size = window_size;
	89	this->predicted_channel = predicted_channel;
	90	this->data_matrix = data_matrix;
	91
	92	if(robust)
	93	{
	94	if(has_constant)
	95	{
	96	my_rarx = new RARX(ar_components.size()+1,window_size,true);
	97	my_arx = NULL;
	98	}
	99	else
	100	{
	101	my_rarx = new RARX(ar_components.size(),window_size,false);
	102	my_arx = NULL;
	103	}
	104	}
	105	else
	106	{
	107	my_rarx = NULL;
	108	my_arx = new ARXwin();
	109	mat V0;
	110
	111	if(has_constant)
	112	{
[1362]	113	V0 = 0.01 * eye(ar_components.size()+2);
[1365]	114	V0(0,0) = 0;
[1361]	115	my_arx->set_constant(true);
	116
	117	}
	118	else
	119	{
	120
[1362]	121	V0 = 0.01 * eye(ar_components.size()+1);
[1365]	122	V0(0,0) = 0;
[1361]	123	my_arx->set_constant(false);
	124
	125	}
	126
	127	my_arx->set_statistics(1, V0);
	128	my_arx->set_parameters(window_size);
	129	my_arx->validate();
	130	}
[1358]	131	}
[1361]	132
	133	void data_update(int time)
[1358]	134	{
[1361]	135	vec data_vector;
	136	for(list<pair<int,int>>::iterator ar_iterator = ar_components.begin();ar_iterator!=ar_components.end();ar_iterator++)
	137	{
	138	data_vector.ins(data_vector.size(),(*data_matrix).get(ar_iterator->first,time-ar_iterator->second));
	139	}
[1358]	140
[1361]	141	if(my_rarx!=NULL)
[1358]	142	{
[1361]	143	data_vector.ins(0,(*data_matrix).get(predicted_channel,time));
	144	my_rarx->bayes(data_vector);
[1358]	145	}
	146	else
	147	{
[1361]	148	vec pred_vec;
	149	pred_vec.ins(0,(*data_matrix).get(predicted_channel,time));
	150	my_arx->bayes(pred_vec,data_vector);
	151	}
	152	}
	153
	154	static list<list<pair<int,int>>> possible_models_recurse(int max_order,int number_of_channels)
	155	{
	156	list<list<pair<int,int>>> created_model_types;
	157
	158	if(max_order == 1)
	159	{
	160	for(int channel = 0;channel<number_of_channels;channel++)
[1358]	161	{
[1361]	162	list<pair<int,int>> returned_type;
	163	returned_type.push_back(pair<int,int>(channel,1));
	164	created_model_types.push_back(returned_type);
[1358]	165	}
[1361]	166
	167	return created_model_types;
	168	}
	169	else
	170	{
	171	created_model_types = possible_models_recurse(max_order-1,number_of_channels);
	172	list<list<pair<int,int>>> returned_types;
	173
	174	for(list<list<pair<int,int>>>::iterator model_ref = created_model_types.begin();model_ref!=created_model_types.end();model_ref++)
	175	{
	176
	177	for(int order = 1; order<=max_order; order++)
[1358]	178	{
[1361]	179	for(int channel = 0;channel<number_of_channels;channel++)
	180	{
	181	list<pair<int,int>> returned_type;
	182	pair<int,int> new_pair = pair<int,int>(channel,order);
	183	if(find((model_ref).begin(),(model_ref).end(),new_pair)==(*model_ref).end())
	184	{
	185	returned_type.insert(returned_type.begin(),(model_ref).begin(),(model_ref).end());
	186	returned_type.push_back(new_pair);
	187	returned_types.push_back(returned_type);
	188	}
	189	}
[1358]	190	}
	191	}
[1361]	192
	193	created_model_types.insert(created_model_types.end(),returned_types.begin(),returned_types.end());
	194
	195	return created_model_types;
	196	}
[1358]	197	}
[1361]	198	};
	199
	200
	201
	202
	203	int main ( int argc, char* argv[] ) {
[1358]	204
[1361]	205	itpp::Laplace_RNG LapRNG = Laplace_RNG();
	206
[1300]	207	/*
[1361]	208	char szApp[] = "MT4";
[1365]	209	char szTopic[] = "BID";
	210	char szItem1[] = "EURJPY";
[1361]	211
	212	//DDE Initialization
	213	DWORD idInst=0;
	214	UINT iReturn;
	215	iReturn = DdeInitialize(&idInst, (PFNCALLBACK)DdeCallback,
	216	APPCLASS_STANDARD \| APPCMD_CLIENTONLY, 0 );
	217	if (iReturn!=DMLERR_NO_ERROR)
	218	{
	219	printf("DDE Initialization Failed: 0x%04x\n", iReturn);
	220	Sleep(1500);
	221	return 0;
	222	}
	223
	224	/*
	225	//Start DDE Server and wait for it to become idle.
	226	HINSTANCE hRet = ShellExecute(0, "open", szTopic, 0, 0, SW_SHOWNORMAL);
	227	if ((int)hRet < 33)
	228	{
	229	printf("Unable to Start DDE Server: 0x%04x\n", hRet);
	230	Sleep(1500); DdeUninitialize(idInst);
	231	return 0;
	232	}
	233	Sleep(1000);
	234	*/
	235
	236	/*
	237	//DDE Connect to Server using given AppName and topic.
	238	HSZ hszApp, hszTopic;
	239	HCONV hConv;
	240	hszApp = DdeCreateStringHandle(idInst, szApp, 0);
	241	hszTopic = DdeCreateStringHandle(idInst, szTopic, 0);
	242	hConv = DdeConnect(idInst, hszApp, hszTopic, NULL);
	243	DdeFreeStringHandle(idInst, hszApp);
	244	DdeFreeStringHandle(idInst, hszTopic);
	245	if (hConv == NULL)
	246	{
	247	printf("DDE Connection Failed.\n");
	248	Sleep(1500); DdeUninitialize(idInst);
	249	return 0;
	250	}
	251
	252	//Execute commands/requests specific to the DDE Server.
	253
	254	DDERequest(idInst, hConv, szItem1);
	255
	256	//DDE Disconnect and Uninitialize.
	257	//DdeDisconnect(hConv);
	258	//DdeUninitialize(idInst);
	259
	260	Sleep(300000);
	261	Sleep(3000);
[1365]	262
[1361]	263
	264	/*
[1301]	265	// EXPERIMENT: 100 AR model generated time series of length of 30 from y_t=0.95y_(t-1)+0.05y_(t-2)+0.2*e_t,
	266	// where e_t is normally, student(4) and cauchy distributed are tested using robust AR model, to obtain the
	267	// variance of location parameter estimators and compare it to the classical setup.
[1282]	268	vector<vector<vector<string>>> string_lists;
	269	string_lists.push_back(vector<vector<string>>());
	270	string_lists.push_back(vector<vector<string>>());
	271	string_lists.push_back(vector<vector<string>>());
[1186]	272
[1282]	273	char* file_strings[3] = {"c:\\ar_normal.txt", "c:\\ar_student.txt", "c:\\ar_cauchy.txt"};
[1268]	274
[1282]	275
	276	for(int i = 0;i<3;i++)
	277	{
	278	ifstream myfile(file_strings[i]);
	279	if (myfile.is_open())
	280	{
	281	while ( myfile.good() )
	282	{
	283	string line;
	284	getline(myfile,line);
	285
	286	vector<string> parsed_line;
	287	while(line.find(',') != string::npos)
	288	{
	289	int loc = line.find(',');
	290	parsed_line.push_back(line.substr(0,loc));
	291	line.erase(0,loc+1);
	292	}
	293
	294	string_lists[i].push_back(parsed_line);
	295	}
	296	myfile.close();
	297	}
	298	}
	299
	300	for(int j = 0;j<string_lists.size();j++)
	301	{
[1301]	302
[1284]	303	for(int i = 0;i<string_lists[j].size()-1;i++)
[1282]	304	{
	305	vector<vec> conditions;
[1301]	306	//emlig* emliga = new emlig(2);
	307	RARX* my_rarx = new RARX(2,30);
	308
[1282]	309	for(int k = 1;k<string_lists[j][i].size();k++)
	310	{
	311	vec condition;
	312	//condition.ins(0,1);
	313	condition.ins(0,string_lists[j][i][k]);
	314	conditions.push_back(condition);
	315
	316	//cout << "orig:" << condition << endl;
	317
	318	if(conditions.size()>1)
	319	{
	320	conditions[k-2].ins(0,string_lists[j][i][k]);
	321
	322	}
	323
	324	if(conditions.size()>2)
	325	{
	326	conditions[k-3].ins(0,string_lists[j][i][k]);
	327
	328	//cout << "modi:" << conditions[k-3] << endl;
	329
[1301]	330	my_rarx->bayes(conditions[k-3]);
[1282]	331
[1299]	332
	333	//if(k>5)
	334	//{
	335	// cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl;
	336	//}
	337
	338	}
	339
[1282]	340	}
	341
	342	//emliga->step_me(0);
[1301]	343	/*
[1284]	344	ofstream myfile;
	345	myfile.open("c:\\robust_ar1.txt",ios::app);
[1301]	346	myfile << my_rarx->minimal_vertex->get_coordinates()[0] << ";";
[1284]	347	myfile.close();
	348
	349	myfile.open("c:\\robust_ar2.txt",ios::app);
	350	myfile << emliga->minimal_vertex->get_coordinates()[1] << ";";
	351	myfile.close();
[1301]	352
[1284]	353
[1282]	354	cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl;
	355	cout << "Step: " << i << endl;
	356	}
	357
	358	cout << "One experiment finished." << endl;
[1284]	359
	360	ofstream myfile;
	361	myfile.open("c:\\robust_ar1.txt",ios::app);
	362	myfile << endl;
	363	myfile.close();
	364
	365	myfile.open("c:\\robust_ar2.txt",ios::app);
	366	myfile << endl;
	367	myfile.close();
[1301]	368	}*/
	369
[1361]	370
[1301]	371
	372	// EXPERIMENT: A moving window estimation and prediction of RARX is tested on data generated from
	373	// y_t=0.95y_(t-1)+0.05y_(t-2)+0.2*e_t, where e_t is normally, student(4) and cauchy distributed. It
	374	// can be compared to the classical setup.
	375
	376
[1365]	377
[1301]	378	vector<vector<string>> strings;
	379
[1361]	380	char* file_string = "c:\\data";
[1301]	381
[1361]	382	char dfstring[80];
	383	strcpy(dfstring,file_string);
	384	strcat(dfstring,".txt");
[1337]	385
[1361]	386
	387	mat data_matrix;
	388	ifstream myfile(dfstring);
	389	if (myfile.is_open())
	390	{
	391	string line;
	392	while(getline(myfile,line))
[1301]	393	{
[1361]	394	vec data_vector;
[1301]	395	while(line.find(',') != string::npos)
	396	{
[1361]	397	int loc2 = line.find('\n');
	398	int loc = line.find(',');
	399	data_vector.ins(data_vector.size(),atof(line.substr(0,loc).c_str()));
[1301]	400	line.erase(0,loc+1);
[1361]	401	}
[1301]	402
[1361]	403	data_matrix.ins_row(data_matrix.rows(),data_vector);
	404	}
	405
	406	myfile.close();
[1282]	407	}
[1361]	408	else
	409	{
	410	cout << "Can't open data file!" << endl;
	411	}
	412
[1365]	413
[1361]	414	list<list<pair<int,int>>> model_types = model::possible_models_recurse(max_model_order,data_matrix.rows());
[1365]	415
[1361]	416	list<model*> models;
	417	for(list<list<pair<int,int>>>::iterator model_type = model_types.begin();model_type!=model_types.end();model_type++)
	418	{
	419	models.push_back(new model((*model_type),true,false,30,0,&data_matrix));
	420	models.push_back(new model((*model_type),false,false,30,0,&data_matrix));
	421	}
[1282]	422
[1361]	423	mat result_lognc;
	424
	425	for(int time = max_model_order;20;time++) //time<data_matrix.cols()
	426	{
	427	vec cur_res_lognc;
	428
	429	for(list<model*>::iterator model_ref = models.begin();model_ref!=models.end();model_ref++)
	430	{
	431	(*model_ref)->data_update(time);
	432	if((*model_ref)->my_rarx!=NULL)
	433	{
	434	cur_res_lognc.ins(cur_res_lognc.size(),(*model_ref)->my_rarx->posterior->log_nc);
	435	}
	436	else
	437	{
	438	cur_res_lognc.ins(cur_res_lognc.size(),(*model_ref)->my_arx->posterior().lognc());
	439	}
	440	}
	441
	442	result_lognc.ins_col(result_lognc.cols(),cur_res_lognc);
	443
	444	cout << "Updated." << endl;
[1365]	445
[1361]	446	/*
[1301]	447	vector<vec> conditions;
	448	//emlig* emliga = new emlig(2);
[1358]	449	RARX* my_rarx = new RARX(2,10,false);
[1337]	450
[1338]	451
[1337]	452	mat V0 = 0.0001 * eye ( 3 );
[1349]	453	ARX* my_arx = new ARX(0.85);
[1337]	454	my_arx->set_statistics ( 1, V0 ); //nu is default (set to have finite moments)
	455	my_arx->set_constant ( false );
	456	my_arx->validate();
[1338]	457
[1301]	458
[1338]	459	for(int k = 1;k<strings[j].size();k++)
[1301]	460	{
	461	vec condition;
	462	//condition.ins(0,1);
	463	condition.ins(0,strings[j][k]);
	464	conditions.push_back(condition);
	465
	466	//cout << "orig:" << condition << endl;
	467
	468	if(conditions.size()>1)
	469	{
	470	conditions[k-2].ins(0,strings[j][k]);
	471
	472	}
	473
	474	if(conditions.size()>2)
	475	{
	476	conditions[k-3].ins(0,strings[j][k]);
	477
[1349]	478	// cout << "Condition:" << conditions[k-3] << endl;
[1301]	479
	480	my_rarx->bayes(conditions[k-3]);
[1338]	481	//my_rarx->posterior->step_me(1);
[1337]	482
	483	vec cond_vec;
	484	cond_vec.ins(0,conditions[k-3][0]);
	485
[1338]	486	my_arx->bayes(cond_vec,conditions[k-3].right(2));
[1301]	487
[1361]	488	/*
[1346]	489	if(k>8)
[1301]	490	{
[1324]	491	//my_rarx->posterior->step_me(0);
	492
[1346]	493	//mat samples = my_rarx->posterior->sample_mat(10);
[1343]	494
[1346]	495	pair<vec,mat> imp_samples = my_rarx->posterior->importance_sample(1000);
[1343]	496
[1346]	497	//cout << imp_samples.first << endl;
[1336]	498
[1337]	499	vec sample_prediction;
[1358]	500	vec averaged_params = zeros(imp_samples.second.rows());
[1346]	501	for(int t = 0;t<imp_samples.first.size();t++)
[1337]	502	{
	503	vec lap_sample = conditions[k-3].left(2);
[1346]	504	//lap_sample.ins(lap_sample.size(),1.0);
[1337]	505
	506	lap_sample.ins(0,LapRNG());
	507
[1346]	508	sample_prediction.ins(0,lap_sample*imp_samples.second.get_col(t));
[1358]	509
	510	averaged_params += imp_samples.first[t]*imp_samples.second.get_col(t);
[1337]	511	}
	512
[1358]	513	averaged_params = averaged_params(1/(imp_samples.firstones(imp_samples.first.size())));
	514
	515	// cout << "Averaged estimated parameters: " << averaged_params << endl;
[1338]	516
[1358]	517	vec sample_pow = sample_prediction;
[1343]	518
	519	// cout << sample_prediction << endl;
[1337]	520	vec poly_coefs;
[1346]	521	double prediction;
[1337]	522	bool stop_iteration = false;
[1343]	523	int en = 1;
[1337]	524	do
	525	{
[1346]	526	double poly_coef = imp_samples.firstsample_pow/(imp_samples.firstones(imp_samples.first.size()));
[1337]	527
[1346]	528	if(en==1)
	529	{
	530	prediction = poly_coef;
	531	}
	532
[1343]	533	poly_coef = poly_coefenfact(utility_constant-2+en)/fact(utility_constant-2);
	534
[1337]	535	if(abs(poly_coef)>numeric_limits<double>::epsilon())
	536	{
	537	sample_pow = elem_mult(sample_pow,sample_prediction);
[1343]	538	poly_coefs.ins(0,pow(-1.0,en+1)*poly_coef);
[1337]	539	}
	540	else
	541	{
	542	stop_iteration = true;
	543	}
	544
	545	en++;
[1343]	546
	547	if(en>20)
	548	{
	549	stop_iteration = true;
	550	}
[1337]	551	}
	552	while(!stop_iteration);
	553
[1343]	554	/*
	555	ofstream myfile_coef;
	556
	557	myfile_coef.open("c:\\coefs.txt",ios::app);
	558
	559	for(int t = 0;t<poly_coefs.size();t++)
	560	{
	561	myfile_coef << poly_coefs[t] << ",";
	562	}
	563
	564	myfile_coef << endl;
	565	myfile_coef.close();
	566	*/
	567
[1349]	568	//cout << "Coefficients: " << poly_coefs << endl;
[1338]	569
[1343]	570	/*
	571	vec bas_coef = vec("1.0 2.0 -8.0");
	572	cout << "Coefs: " << bas_coef << endl;
	573	cvec actions2 = roots(bas_coef);
	574	cout << "Roots: " << actions2 << endl;
	575	*/
	576
[1361]	577	/*
[1346]	578
[1338]	579	cvec actions = roots(poly_coefs);
[1343]	580
	581
[1338]	582	bool is_max = false;
	583	for(int t = 0;t<actions.size();t++)
	584	{
[1343]	585	if(actions[t].imag() == 0)
[1338]	586	{
[1343]	587	double second_derivative = 0;
	588	for(int q = 1;q<poly_coefs.size();q++)
	589	{
	590	second_derivative+=poly_coefs[q]pow(actions[t].real(),q-1)q;
	591	}
	592
	593	if(second_derivative<0)
	594	{
	595	cout << "Action:" << actions[t].real() << endl;
	596
	597	is_max = true;
	598	}
[1338]	599	}
	600	}
[1301]	601
[1338]	602	if(!is_max)
	603	{
	604	cout << "No maximum." << endl;
	605	}
	606
	607	// cout << "MaxLik coords:" << my_rarx->posterior->minimal_vertex->get_coordinates() << endl;
	608
[1346]	609	/*
[1337]	610	double prediction = 0;
	611	for(int s = 1;s<samples.rows();s++)
[1336]	612	{
	613
[1346]	614	double avg_parameter = imp_samples.get_row(s)*ones(samples.cols())/samples.cols();
[1337]	615
	616	prediction += avg_parameter*conditions[k-3][s-1];
	617
[1336]	618
[1337]	619
	620	/*
[1336]	621	ofstream myfile;
	622	char fstring[80];
	623	strcpy(fstring,file_strings[j]);
[1301]	624
[1336]	625	char es[5];
	626	strcat(fstring,itoa(s,es,10));
	627
	628	strcat(fstring,"_res.txt");
	629
	630
	631	myfile.open(fstring,ios::app);
	632
	633	//myfile << my_rarx->posterior->minimal_vertex->get_coordinates()[0];
	634	myfile << avg_parameter;
	635
	636	if(k!=strings[j].size()-1)
	637	{
	638	myfile << ",";
	639	}
	640	else
	641	{
	642	myfile << endl;
	643	}
	644	myfile.close();
[1337]	645	*/
	646
[1338]	647
[1346]	648	//}
	649
	650	// cout << "Prediction: "<< prediction << endl;
[1361]	651	/*
[1337]	652	enorm<ldmat>* pred_mat = my_arx->epredictor(conditions[k-3].left(2));
	653	double prediction2 = pred_mat->mean()[0];
[1361]	654	*/
[1337]	655
[1365]	656
[1337]	657	ofstream myfile;
[1361]	658	char fstring[80];
	659	strcpy(fstring,file_string);
[1337]	660
[1361]	661	strcat(fstring,"lognc.txt");
[1337]	662
	663	myfile.open(fstring,ios::app);
	664
[1338]	665	// myfile << my_rarx->posterior->minimal_vertex->get_coordinates()[0];
[1337]	666
[1361]	667	for(int i = 0;i<cur_res_lognc.size();i++)
[1337]	668	{
[1361]	669	myfile << cur_res_lognc[i] << ',';
[1337]	670	}
[1361]	671
	672	myfile << endl;
	673
[1337]	674	myfile.close();
[1365]	675	}
[1361]	676	/*
[1337]	677	myfile.open(f2string,ios::app);
	678	myfile << prediction2;
	679
	680	if(k!=strings[j].size()-1)
	681	{
	682	myfile << ",";
	683	}
	684	else
	685	{
	686	myfile << endl;
	687	}
	688	myfile.close();
[1361]	689	////
[1337]	690
[1319]	691	}
[1361]	692	} */
[1301]	693
	694	//emliga->step_me(0);
	695	/*
	696	ofstream myfile;
	697	myfile.open("c:\\robust_ar1.txt",ios::app);
	698	myfile << my_rarx->minimal_vertex->get_coordinates()[0] << ";";
	699	myfile.close();
	700
	701	myfile.open("c:\\robust_ar2.txt",ios::app);
	702	myfile << emliga->minimal_vertex->get_coordinates()[1] << ";";
	703	myfile.close();
	704
	705
	706	cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl;
	707	cout << "Step: " << i << endl;*/
[1361]	708	//}
[1337]	709
	710
[1365]	711	//}
[1337]	712
	713
	714	// EXPERIMENT: One step ahead price prediction. Comparison of classical and robust model using optimal trading
	715	// with maximization of logarithm of one-step ahead wealth.
	716
	717
[1301]	718
	719	/*
	720	cout << "One experiment finished." << endl;
	721
	722	ofstream myfile;
	723	myfile.open("c:\\robust_ar1.txt",ios::app);
	724	myfile << endl;
	725	myfile.close();
	726
	727	myfile.open("c:\\robust_ar2.txt",ios::app);
	728	myfile << endl;
	729	myfile.close();*/
[1300]	730
[1301]	731
	732	//emlig* emlig1 = new emlig(emlig_size);
	733
	734	//emlig1->step_me(0);
	735	//emlig* emlig2 = new emlig(emlig_size);
[1300]	736
[1267]	737	/*
	738	emlig1->set_correction_factors(4);
[1266]	739
[1267]	740	for(int j = 0;j<emlig1->correction_factors.size();j++)
	741	{
	742	for(set<my_ivec>::iterator vec_ref = emlig1->correction_factors[j].begin();vec_ref!=emlig1->correction_factors[j].end();vec_ref++)
	743	{
[1268]	744	cout << j << " ";
	745
[1267]	746	for(int i=0;i<(*vec_ref).size();i++)
	747	{
	748	cout << (*vec_ref)[i];
	749	}
	750
	751	cout << endl;
	752	}
[1268]	753	}*/
	754
[1301]	755	/*
[1300]	756	vec condition5 = "1.0 1.0 1.01";//"-0.3 1.7 1.5";
	757
[1299]	758	emlig1->add_condition(condition5);
[1301]	759	//emlig1->step_me(0);
	760
	761
	762	vec condition1a = "-1.0 1.02 0.5";
[1300]	763	//vec condition1b = "1.0 1.0 1.01";
[1301]	764	emlig1->add_condition(condition1a);
[1300]	765	//emlig2->add_condition(condition1b);
[1267]	766
[1301]	767	vec condition2a = "-0.3 1.7 1.5";
[1300]	768	//vec condition2b = "-1.0 1.0 1.0";
[1301]	769	emlig1->add_condition(condition2a);
[1300]	770	//emlig2->add_condition(condition2b);
[1234]	771
[1301]	772	vec condition3a = "0.5 -1.01 1.0";
[1300]	773	//vec condition3b = "0.5 -1.01 1.0";
[1280]	774
[1301]	775	emlig1->add_condition(condition3a);
[1300]	776	//emlig2->add_condition(condition3b);
[1280]	777
[1301]	778	vec condition4a = "-0.5 -1.0 1.0";
[1300]	779	//vec condition4b = "-0.5 -1.0 1.0";
	780
[1301]	781	emlig1->add_condition(condition4a);
[1300]	782	//cout << "************************************************" << endl;
	783	//emlig2->add_condition(condition4b);
	784	//cout << "************************************************" << endl;
	785
[1299]	786	//cout << emlig1->minimal_vertex->get_coordinates();
[1300]	787
[1301]	788	//emlig1->remove_condition(condition3a);
	789	//emlig1->step_me(0);
	790	//emlig1->remove_condition(condition2a);
	791	//emlig1->remove_condition(condition1a);
	792	//emlig1->remove_condition(condition5);
	793
[1275]	794
[1299]	795	//emlig1->step_me(0);
	796	//emlig2->step_me(0);
	797
[1282]	798
	799	// DA SE POUZIT PRO VYPIS DO SOUBORU
[1275]	800	// emlig1->step_me(0);
	801
	802	//emlig1->remove_condition(condition1);
	803
[1301]	804
[1275]	805
	806
[1301]	807
[1275]	808	/*
[1282]	809	for(int i = 0;i<100;i++)
[1219]	810	{
[1282]	811	cout << endl << "Step:" << i << endl;
[1208]	812
[1268]	813	double condition[emlig_size+1];
[1220]	814
[1268]	815	for(int k = 0;k<=emlig_size;k++)
	816	{
[1272]	817	condition[k] = (rand()-RAND_MAX/2)/1000.0;
[1268]	818	}
	819
[1216]	820
[1268]	821	vec* condition_vec = new vec(condition,emlig_size+1);
[1219]	822	emlig1->add_condition(*condition_vec);
[1271]	823
[1272]	824	/*
	825	for(polyhedron* toprow_ref = emlig1->statistic.rows[emlig_size]; toprow_ref != emlig1->statistic.end_poly; toprow_ref = toprow_ref->next_poly)
	826	{
	827	cout << ((toprow*)toprow_ref)->probability << endl;
	828	}
	829	*/
[1275]	830	/*
[1271]	831	cout << emlig1->statistic_rowsize(emlig_size) << endl << endl;
[1268]	832
[1272]	833	/*
[1271]	834	if(i-emlig1->number_of_parameters >= 0)
	835	{
	836	pause(30);
	837	}
[1272]	838	*/
[1219]	839
[1271]	840	// emlig1->step_me(i);
[1219]	841
[1272]	842	/*
[1219]	843	vector<int> sizevector;
	844	for(int s = 0;s<=emlig1->number_of_parameters;s++)
	845	{
	846	sizevector.push_back(emlig1->statistic_rowsize(s));
	847	}
[1272]	848	*/
[1275]	849	//}
	850
[1219]	851
	852
	853
	854	/*
	855	emlig1->step_me(1);
	856
	857	vec condition = "2.0 0.0 1.0";
	858
[1208]	859	emlig1->add_condition(condition);
	860
[1216]	861	vector<int> sizevector;
	862	for(int s = 0;s<=emlig1->number_of_parameters;s++)
	863	{
	864	sizevector.push_back(emlig1->statistic_rowsize(s));
	865	}
	866
[1219]	867	emlig1->step_me(2);
[1216]	868
[1219]	869	condition = "2.0 1.0 0.0";
[1216]	870
	871	emlig1->add_condition(condition);
	872
	873	sizevector.clear();
	874	for(int s = 0;s<=emlig1->number_of_parameters;s++)
	875	{
	876	sizevector.push_back(emlig1->statistic_rowsize(s));
	877	}
[1219]	878	*/
[1216]	879
[976]	880	return 0;
	881	}
	882
[1282]	883

Note: See TracBrowser for help on using the browser.

Context Navigation

root/applications/robust/main.cpp @ 1365

Download in other formats: