Context Navigation

main.cpp @ 1367

Revision 1367, 22.5 kB (checked in by sindj, 13 years ago)
Nova verze main s predikcemi i lognorm faktory. Pristup na DDE data. JS

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

Note: See TracBrowser for help on using the browser.

Context Navigation

root/applications/robust/main.cpp @ 1367

Download in other formats: