/*!
\file
\brief Robust
\author Vasek Smidl 

 */

#include "estim/arx.h"
#include "robustlib.h"
#include <vector>
#include <iostream>
#include <fstream>
#include <itpp/itsignal.h>
#include "windows.h"
#include "ddeml.h"
#include "stdio.h"
#include <time.h>

//#include "DDEClient.h"
//#include <conio.h>


using namespace itpp;
using namespace bdm;

//const int emlig_size = 2;
//const int utility_constant = 5;

const int max_model_order = 2;
const int data_count      = 5;

static vec avg_vec;

HDDEDATA CALLBACK DdeCallback(
UINT uType,     // Transaction type.
UINT uFmt,      // Clipboard data format.
HCONV hconv,    // Handle to the conversation.
HSZ hsz1,       // Handle to a string.
HSZ hsz2,       // Handle to a string.
HDDEDATA hdata, // Handle to a global memory object.
DWORD dwData1,  // Transaction-specific data.
DWORD dwData2)  // Transaction-specific data.
{
	char  * pData;
	DWORD   data_len;
	
	switch (uType)
	{     
	case XTYP_ADVDATA: 

		if ( hdata == NULL )
			cout << "No data in the message." << endl;
		else
		{
			pData = (char*)DdeAccessData( hdata, &data_len );
						
			avg_vec.ins(0,atof(pData));
			
			cout << pData << endl;

			DdeUnaccessData( hdata );
		}
	}		
	return (HDDEDATA) NULL; 

}



void DDERequest(DWORD idInst, HCONV hConv, char* szItem)
{
	HSZ hszItem = DdeCreateStringHandle(idInst, szItem, 0);
	HDDEDATA hData = DdeClientTransaction(NULL,0,hConv,hszItem,CF_TEXT, 
									XTYP_ADVSTART,TIMEOUT_ASYNC , NULL); //TIMEOUT_ASYNC
	if (hData==NULL)
	{
		printf("Request failed: %s\n", szItem);
	}

	if (hData==0)
	{
		printf("Request failed: %s\n", szItem);
	}
}

DWORD WINAPI ThrdFunc( LPVOID n )
{    
    return 0;
}


class model
{
public:
	list<pair<int,int>> ar_components;

	// Best thing would be to inherit the two models from a single souce, this is planned, but now structurally
	// problematic.
	RARX* my_rarx;
	ARXwin* my_arx;

	bool has_constant;
	int  order;
	int  window_size;
	int  predicted_channel;
	int  number_of_updates;
	double prior_lognc;
	vec  lognc_history;
	mat* data_matrix;
	
	model(list<pair<int,int>> ar_components, 
		  bool robust, 
		  bool has_constant, 
		  int window_size, 
		  int predicted_channel,		  
		  mat* data_matrix)
	{
		this->ar_components.insert(this->ar_components.begin(),ar_components.begin(),ar_components.end());
		this->has_constant        = has_constant;
		this->window_size         = window_size;
		this->predicted_channel   = predicted_channel;		
		this->data_matrix         = data_matrix;
		number_of_updates = 0;

		order = 0;
		for(list<pair<int,int>>::iterator ar_ref = ar_components.begin();ar_ref!=ar_components.end();ar_ref++)
		{
			if((*ar_ref).second > order)
			{
				order = (*ar_ref).second;
			}
		}

		if(robust)
		{
			if(has_constant)
			{
				my_rarx = new RARX(ar_components.size()+1,window_size,true);
				my_arx  = NULL;
			}
			else
			{
				my_rarx = new RARX(ar_components.size(),window_size,false);
				my_arx  = NULL;
			}

			prior_lognc = my_rarx->posterior->log_nc;
		}
		else
		{
			my_rarx = NULL;
			my_arx  = new ARXwin();
			mat V0;

			if(has_constant)
			{				
				V0  = 0.001 * eye(ar_components.size()+2);
				V0(0,0) = 1;
				my_arx->set_constant(true);	
				
			}
			else
			{
				
				V0  = 0.001 * eye(ar_components.size()+1);
				V0(0,0) = 1;
				my_arx->set_constant(false);				
				
			}

			my_arx->set_statistics(1, V0); 
			my_arx->set_parameters(window_size);
			my_arx->validate();

			prior_lognc = my_arx->posterior().lognc();
		}
	}

	void data_update(int time)
	{
		if(time > order)
		{
			vec data_vector;
			for(list<pair<int,int>>::iterator ar_iterator = ar_components.begin();ar_iterator!=ar_components.end();ar_iterator++)
			{
				data_vector.ins(data_vector.size(),(*data_matrix).get(ar_iterator->first,time-ar_iterator->second));
			}

			// cout << "Update cond: " << data_vector << endl;

			double cur_lognc;
			if(my_rarx!=NULL)
			{
				data_vector.ins(0,(*data_matrix).get(predicted_channel,time));
				my_rarx->bayes(data_vector);
				cur_lognc = my_rarx->posterior->log_nc;
			}
			else
			{
				vec pred_vec;
				pred_vec.ins(0,(*data_matrix).get(predicted_channel,time));
				my_arx->bayes(pred_vec,data_vector);
				cur_lognc = my_arx->posterior().lognc();
			}

			number_of_updates++;

			if(number_of_updates>window_size)
			{
				lognc_history.ins(lognc_history.size(),cur_lognc-prior_lognc);
			}
		}
		else
		{
			lognc_history.ins(lognc_history.size(),0);
		}
	}

	pair<vec,vec> predict(int sample_size, int time, itpp::Laplace_RNG* LapRNG)
	{
		if(time > order)
		{
			vec condition_vector;
			for(list<pair<int,int>>::iterator ar_iterator = ar_components.begin();ar_iterator!=ar_components.end();ar_iterator++)
			{
				condition_vector.ins(condition_vector.size(),(*data_matrix).get(ar_iterator->first,time-ar_iterator->second+1));
			}

			// cout << "Prediction cond: " << condition_vector << endl;

			if(my_rarx!=NULL)
			{
				pair<vec,mat> imp_samples = my_rarx->posterior->importance_sample(sample_size);

				//cout << "Point estimate: " << (imp_samples.second*imp_samples.first)/(imp_samples.first*ones(imp_samples.first.size())) << endl;
				
				vec sample_prediction;			
				for(int t = 0;t<sample_size;t++)
				{
					vec lap_sample = condition_vector;
					
					if(has_constant)
					{
						lap_sample.ins(lap_sample.size(),1.0);
					}
					
					lap_sample.ins(0,(*LapRNG)());

					sample_prediction.ins(0,lap_sample*imp_samples.second.get_col(t));				
				}

				return pair<vec,vec>(imp_samples.first,sample_prediction);
			}
			else
			{
				mat samples = my_arx->posterior().sample_mat(sample_size);

				//cout << "Point estimate: " << (samples*ones(samples.cols()))/samples.cols() << endl;

				// cout << samples.get_col(1) << endl;
				
				vec sample_prediction;
				for(int t = 0;t<sample_size;t++)
				{
					vec gau_sample = condition_vector;
					
					if(has_constant)
					{
						gau_sample.ins(gau_sample.size(),1.0);
					}
					
					gau_sample.ins(gau_sample.size(),randn());

					sample_prediction.ins(0,gau_sample*samples.get_col(t));				
				}

				return pair<vec,vec>(ones(sample_prediction.size()),sample_prediction);
			}
		}
		else
		{
			
			return pair<vec,vec>(zeros(1),ones(1));
		}
	
	}


	static list<list<pair<int,int>>> possible_models_recurse(int max_order,int number_of_channels)
	{
		list<list<pair<int,int>>> created_model_types;		

		if(max_order == 1)
		{			
			for(int channel = 0;channel<number_of_channels;channel++)
			{
				list<pair<int,int>> returned_type;
				returned_type.push_back(pair<int,int>(channel,1));
				created_model_types.push_back(returned_type);
			}

			return created_model_types;
		}
		else
		{
			created_model_types = possible_models_recurse(max_order-1,number_of_channels);
			list<list<pair<int,int>>> returned_types;
			
			for(list<list<pair<int,int>>>::iterator model_ref = created_model_types.begin();model_ref!=created_model_types.end();model_ref++)
			{				
				
				for(int order = 1; order<=max_order; order++)
				{
					for(int channel = 0;channel<number_of_channels;channel++)
					{
						list<pair<int,int>> returned_type;
						pair<int,int> new_pair = pair<int,int>(channel,order);
						if(find((*model_ref).begin(),(*model_ref).end(),new_pair)==(*model_ref).end())
						{
							returned_type.insert(returned_type.begin(),(*model_ref).begin(),(*model_ref).end());
							returned_type.push_back(new_pair);
							returned_types.push_back(returned_type);							
						}
					}
				}
			}

			created_model_types.insert(created_model_types.end(),returned_types.begin(),returned_types.end());

			return created_model_types;
		}		
	}
};







int main ( int argc, char* argv[] ) {	
	
	vec data_vec;
	mat data_matrix;
	DWORD Id;

	char  szApp[]   = "MT4";
	char  szTopic[] = "BID";	
	char  szItem[]  = "EURUSD";
	char* itRef     = &szItem[0];

	char* file_string = "c:\\rtdata";

	ofstream myfile;
	char fstring[80];					
	strcpy(fstring,file_string);
	strcat(fstring,itRef);
	strcat(fstring,"lognc.txt");

	list<list<pair<int,int>>> model_types = model::possible_models_recurse(max_model_order,1);
	
	int max_window = 50;
	int min_window = 1;

	list<model*> models;
	for(list<list<pair<int,int>>>::iterator model_type = model_types.begin();model_type!=model_types.end();model_type++)
	{
		for(int window_size = min_window;window_size < max_window;window_size++)
		{			
			//models.push_back(new model((*model_type),true,true,window_size,0,&data_matrix));
			models.push_back(new model((*model_type),false,true,window_size,0,&data_matrix));			
			//models.push_back(new model((*model_type),true,false,window_size,0,&data_matrix));
			//models.push_back(new model((*model_type),false,false,window_size,0,&data_matrix));			
		}
	}
	
	mat result_lognc;
	mat result_preds;
	
	/*
	HANDLE hThrd = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)ThrdFunc, (LPVOID)1, 0, &Id);
  	if ( !hThrd )
    {
        cout<<"Error Creating Threads,,,,.exiting"<<endl;
        return -1;
    }
    Sleep ( 100 );
	*/
	
	 	

	//DDE Initialization
	DWORD idInst = 0;
	UINT iReturn;
	iReturn = DdeInitialize(&idInst, (PFNCALLBACK)DdeCallback, 
							APPCLASS_STANDARD | APPCMD_CLIENTONLY, 0 );
	if (iReturn!=DMLERR_NO_ERROR)
	{
		printf("DDE Initialization Failed: 0x%04x\n", iReturn);
		Sleep(1500);
		return 0;
	}

	//DDE Connect to Server using given AppName and topic.
	HSZ hszApp, hszTopic;
	HCONV hConv;
	hszApp = DdeCreateStringHandle(idInst, szApp, 0);
	hszTopic = DdeCreateStringHandle(idInst, szTopic, 0);
	hConv = DdeConnect(idInst, hszApp, hszTopic, NULL);
	//DdeFreeStringHandle(idInst, hszApp);
	//DdeFreeStringHandle(idInst, hszTopic);
	if (hConv == NULL)
	{
		printf("DDE Connection Failed.\n");
		Sleep(1500); DdeUninitialize(idInst);
		return 0;
	}

	//Execute commands/requests specific to the DDE Server.
	
	DDERequest(idInst, hConv, szItem); 		
	
	itpp::Laplace_RNG LapRNG = Laplace_RNG();

	// time_t current_time = time(0);	

	while(1)
	{
		while(avg_vec.size() < data_count)
		{
			MSG    msg;
			BOOL   MsgReturn = GetMessage ( &msg , NULL , 0 , 0 );
	            
			if(MsgReturn)
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);			
			}
			Sleep(500);
		}


		data_vec.ins(data_vec.size(),avg_vec*ones(avg_vec.size())/avg_vec.size());
		data_matrix = mat(data_vec).T();
		avg_vec.del(0,avg_vec.size()-1);				
					
		vector<double> test_lognc;
		vec preds;

		for(list<model*>::iterator model_ref = models.begin();model_ref!=models.end();model_ref++)
		{
			(*model_ref)->data_update(data_vec.size()-1);			

			if((*model_ref)->lognc_history.size()==0)
			{
				test_lognc.push_back(0);
			}
			else
			{
				test_lognc.push_back((ones((*model_ref)->lognc_history.size())*(*model_ref)->lognc_history)/(*model_ref)->lognc_history.size()*(max_window/(*model_ref)->window_size));	
			}

			pair<vec,vec> predictions = (*model_ref)->predict(500,data_vec.size()-1,&LapRNG);

			preds.ins(preds.size(),(predictions.first*predictions.second)/(predictions.first*ones(predictions.first.size())));
			
		}

		//preds.ins(0,data_matrix.get(0,data_vec.size()));	
		
		result_preds.ins_col(result_preds.cols(),preds);							

		myfile.open(fstring,ios::app);
		
		// myfile << my_rarx->posterior->minimal_vertex->get_coordinates()[0];
		
		for(int i = 0;i<test_lognc.size();i++)
		{
			myfile << test_lognc[i] << ',';
		}

		myfile << endl;				
		
		myfile.close();
		
	}
	
	//DDE Disconnect and Uninitialize.
	DdeDisconnect(hConv);
	DdeUninitialize(idInst);

	return 0;
}

		/*
		// EXPERIMENT: A moving window estimation and prediction of RARX is tested on data generated from 
		// y_t=0.95*y_(t-1)+0.05*y_(t-2)+0.2*e_t, where e_t is normally, student(4) and cauchy distributed. It
		// can be compared to the classical setup.
		
		vector<vector<string>> strings;

		char* file_string = "c:\\dataGCClosePercDiff"; 

		char dfstring[80];
		strcpy(dfstring,file_string);
		strcat(dfstring,".txt");
			
		
		mat data_matrix;
		ifstream myfile(dfstring);
		if (myfile.is_open())
		{		
			string line;
			while(getline(myfile,line))
			{			
				vec data_vector;
				while(line.find(',') != string::npos)
				{
					int loc2 = line.find('\n');
					int loc  = line.find(',');
					data_vector.ins(data_vector.size(),atof(line.substr(0,loc).c_str()));				
					line.erase(0,loc+1);					
				}

				data_matrix.ins_row(data_matrix.rows(),data_vector);
			}		

			myfile.close();	
		}
		else
		{
			cout << "Can't open data file!" << endl;
		}
		*/
		
		
		// cout << "Updated." << endl;
	
		/*
		// EXPERIMENT: 100 AR model generated time series of length of 30 from y_t=0.95*y_(t-1)+0.05*y_(t-2)+0.2*e_t, 
		// where e_t is normally, student(4) and cauchy distributed are tested using robust AR model, to obtain the 
		// variance of location parameter estimators and compare it to the classical setup.
		vector<vector<vector<string>>> string_lists;
		string_lists.push_back(vector<vector<string>>());
		string_lists.push_back(vector<vector<string>>());
		string_lists.push_back(vector<vector<string>>());

		char* file_strings[3] = {"c:\\ar_normal.txt", "c:\\ar_student.txt", "c:\\ar_cauchy.txt"};
		

		for(int i = 0;i<3;i++)
		{	
			ifstream myfile(file_strings[i]);
			if (myfile.is_open())
			{
				while ( myfile.good() )
				{
					string line;
					getline(myfile,line);
					
					vector<string> parsed_line;
					while(line.find(',') != string::npos)
					{
						int loc = line.find(',');
						parsed_line.push_back(line.substr(0,loc));
						line.erase(0,loc+1);					
					}				

					string_lists[i].push_back(parsed_line);
				}
				myfile.close();
			}
		}

		for(int j = 0;j<string_lists.size();j++)
		{ 
			
			for(int i = 0;i<string_lists[j].size()-1;i++)
			{
				vector<vec> conditions;
				//emlig* emliga = new emlig(2);
				RARX* my_rarx = new RARX(2,30);

				for(int k = 1;k<string_lists[j][i].size();k++)
				{
					vec condition;
					//condition.ins(0,1);				
					condition.ins(0,string_lists[j][i][k]);				
					conditions.push_back(condition);

					//cout << "orig:" << condition << endl;

					if(conditions.size()>1)
					{		
						conditions[k-2].ins(0,string_lists[j][i][k]);
						
					}

					if(conditions.size()>2)
					{
						conditions[k-3].ins(0,string_lists[j][i][k]);

						//cout << "modi:" << conditions[k-3] << endl;

						my_rarx->bayes(conditions[k-3]);

						
						//if(k>5)
						//{
						//	cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl;
						//}
						
					}				
					
				}

				//emliga->step_me(0);
				/*
				ofstream myfile;
				myfile.open("c:\\robust_ar1.txt",ios::app);
				myfile << my_rarx->minimal_vertex->get_coordinates()[0] << ";";
				myfile.close();

				myfile.open("c:\\robust_ar2.txt",ios::app);
				myfile << emliga->minimal_vertex->get_coordinates()[1] << ";";
				myfile.close();
				

				cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl;
				cout << "Step: " << i << endl;
			}

			cout << "One experiment finished." << endl;

			ofstream myfile;
			myfile.open("c:\\robust_ar1.txt",ios::app);
			myfile << endl;
			myfile.close();

			myfile.open("c:\\robust_ar2.txt",ios::app);
			myfile << endl;
			myfile.close();
		}*/    

		/*
		vector<vec> conditions;
		//emlig* emliga = new emlig(2);
		RARX* my_rarx = new RARX(2,10,false);
		
		
		mat V0 = 0.0001 * eye ( 3 );
		ARX* my_arx = new ARX(0.85);
		my_arx->set_statistics ( 1, V0 ); //nu is default (set to have finite moments)
		my_arx->set_constant ( false );
		my_arx->validate();
		

		for(int k = 1;k<strings[j].size();k++)
		{
			vec condition;
			//condition.ins(0,1);				
			condition.ins(0,strings[j][k]);				
			conditions.push_back(condition);

			//cout << "orig:" << condition << endl;

			if(conditions.size()>1)
			{		
				conditions[k-2].ins(0,strings[j][k]);
					
			}

			if(conditions.size()>2)
			{
				conditions[k-3].ins(0,strings[j][k]);

				// cout << "Condition:" << conditions[k-3] << endl;

				my_rarx->bayes(conditions[k-3]);
				//my_rarx->posterior->step_me(1);
				
				vec cond_vec;
				cond_vec.ins(0,conditions[k-3][0]);
				
				my_arx->bayes(cond_vec,conditions[k-3].right(2));
					
				/*
				if(k>8)
				{
					//my_rarx->posterior->step_me(0);

					//mat samples = my_rarx->posterior->sample_mat(10);

					pair<vec,mat> imp_samples = my_rarx->posterior->importance_sample(1000);

					//cout << imp_samples.first << endl;
					
					vec sample_prediction;
					vec averaged_params = zeros(imp_samples.second.rows());
					for(int t = 0;t<imp_samples.first.size();t++)
					{
						vec lap_sample = conditions[k-3].left(2);
						//lap_sample.ins(lap_sample.size(),1.0);
						
						lap_sample.ins(0,LapRNG());

						sample_prediction.ins(0,lap_sample*imp_samples.second.get_col(t));

						averaged_params += imp_samples.first[t]*imp_samples.second.get_col(t);
					}

					averaged_params = averaged_params*(1/(imp_samples.first*ones(imp_samples.first.size())));

					// cout << "Averaged estimated parameters: " << averaged_params << endl;
					
					vec sample_pow = sample_prediction;					
					
					// cout << sample_prediction << endl;
					vec poly_coefs;
					double prediction;
					bool stop_iteration = false;
					int en = 1;
					do
					{
						double poly_coef = imp_samples.first*sample_pow/(imp_samples.first*ones(imp_samples.first.size()));

						if(en==1)
						{
							prediction = poly_coef;
						}

						poly_coef = poly_coef*en*fact(utility_constant-2+en)/fact(utility_constant-2);

						if(abs(poly_coef)>numeric_limits<double>::epsilon())
						{
							sample_pow = elem_mult(sample_pow,sample_prediction);
							poly_coefs.ins(0,pow(-1.0,en+1)*poly_coef);
						}
						else
						{
							stop_iteration = true;
						}
						
						en++;

						if(en>20)
						{
							stop_iteration = true;
						}
					}
					while(!stop_iteration);

					/*
					ofstream myfile_coef;						

					myfile_coef.open("c:\\coefs.txt",ios::app);
					
					for(int t = 0;t<poly_coefs.size();t++)
					{
						myfile_coef << poly_coefs[t] << ",";					
					}

					myfile_coef << endl;
					myfile_coef.close();
					*/

					//cout << "Coefficients: " << poly_coefs << endl;
										
					/*
					vec bas_coef = vec("1.0 2.0 -8.0");
					cout << "Coefs: " << bas_coef << endl;
					cvec actions2 = roots(bas_coef);
					cout << "Roots: " << actions2 << endl;
					*/
					
				    /*

					cvec actions = roots(poly_coefs);
					

					bool is_max = false;
					for(int t = 0;t<actions.size();t++)
					{
						if(actions[t].imag() == 0)
						{
							double second_derivative = 0;
							for(int q = 1;q<poly_coefs.size();q++)
							{
								second_derivative+=poly_coefs[q]*pow(actions[t].real(),q-1)*q;
							}

							if(second_derivative<0)
							{
								cout << "Action:" << actions[t].real() << endl;

								is_max = true;
							}
						}
					}

					if(!is_max)
					{
						cout << "No maximum." << endl;
					}

					// cout << "MaxLik coords:" << my_rarx->posterior->minimal_vertex->get_coordinates() << endl;

					/*
					double prediction = 0;
					for(int s = 1;s<samples.rows();s++)
					{
						
						double avg_parameter = imp_samples.get_row(s)*ones(samples.cols())/samples.cols();

						prediction += avg_parameter*conditions[k-3][s-1];

						
						
						/*
						ofstream myfile;
						char fstring[80];
						strcpy(fstring,file_strings[j]);

						char es[5];
						strcat(fstring,itoa(s,es,10));

						strcat(fstring,"_res.txt");
						

						myfile.open(fstring,ios::app);
						
						//myfile << my_rarx->posterior->minimal_vertex->get_coordinates()[0];
						myfile << avg_parameter;
						
						if(k!=strings[j].size()-1)
						{
							myfile << ",";
						}
						else
						{
							myfile << endl;
						}
						myfile.close();
						*/

					
					//}

					// cout << "Prediction: "<< prediction << endl;
					/*
					enorm<ldmat>* pred_mat = my_arx->epredictor(conditions[k-3].left(2));
					double prediction2 = pred_mat->mean()[0];
					*/

					
					
					/*
					myfile.open(f2string,ios::app);
					myfile << prediction2;
					
					if(k!=strings[j].size()-1)
					{
						myfile << ",";
					}
					else
					{
						myfile << endl;
					}
					myfile.close();
					//*//*

				}					
			}	*/
			
			//emliga->step_me(0);
			/*
			ofstream myfile;
			myfile.open("c:\\robust_ar1.txt",ios::app);
			myfile << my_rarx->minimal_vertex->get_coordinates()[0] << ";";
			myfile.close();

			myfile.open("c:\\robust_ar2.txt",ios::app);
			myfile << emliga->minimal_vertex->get_coordinates()[1] << ";";
			myfile.close();
			

			cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl;
			cout << "Step: " << i << endl;*/
		//}


	//}


	// EXPERIMENT: One step ahead price prediction. Comparison of classical and robust model using optimal trading
    //             with maximization of logarithm of one-step ahead wealth.

	
		
		/*
		cout << "One experiment finished." << endl;

		ofstream myfile;
		myfile.open("c:\\robust_ar1.txt",ios::app);
		myfile << endl;
		myfile.close();

		myfile.open("c:\\robust_ar2.txt",ios::app);
		myfile << endl;
		myfile.close();*/
	

	//emlig* emlig1 = new emlig(emlig_size);

	//emlig1->step_me(0);
	//emlig* emlig2 = new emlig(emlig_size);
	
	/*
	emlig1->set_correction_factors(4);

	for(int j = 0;j<emlig1->correction_factors.size();j++)
	{
		for(set<my_ivec>::iterator vec_ref = emlig1->correction_factors[j].begin();vec_ref!=emlig1->correction_factors[j].end();vec_ref++)
		{
			cout << j << "    ";
			
			for(int i=0;i<(*vec_ref).size();i++)
			{
				cout << (*vec_ref)[i];
			}

			cout << endl;
		}
	}*/
	
	/*
    vec condition5 = "1.0 1.0 1.01";//"-0.3 1.7 1.5";

	emlig1->add_condition(condition5);
	//emlig1->step_me(0);


	vec condition1a = "-1.0 1.02 0.5";
	//vec condition1b = "1.0 1.0 1.01";
	emlig1->add_condition(condition1a);
	//emlig2->add_condition(condition1b);

	vec condition2a = "-0.3 1.7 1.5";
	//vec condition2b = "-1.0 1.0 1.0";
	emlig1->add_condition(condition2a);
	//emlig2->add_condition(condition2b);

	vec condition3a = "0.5 -1.01 1.0";
	//vec condition3b = "0.5 -1.01 1.0";

	emlig1->add_condition(condition3a);
	//emlig2->add_condition(condition3b);	

	vec condition4a = "-0.5 -1.0 1.0";
	//vec condition4b = "-0.5 -1.0 1.0";	

	emlig1->add_condition(condition4a);
	//cout << "************************************************" << endl;
	//emlig2->add_condition(condition4b);
	//cout << "************************************************" << endl;
	
	//cout << emlig1->minimal_vertex->get_coordinates();
	
	//emlig1->remove_condition(condition3a);
	//emlig1->step_me(0);
	//emlig1->remove_condition(condition2a);
	//emlig1->remove_condition(condition1a);
	//emlig1->remove_condition(condition5);
	

	//emlig1->step_me(0);
	//emlig2->step_me(0);
	

	// DA SE POUZIT PRO VYPIS DO SOUBORU
	// emlig1->step_me(0);

	//emlig1->remove_condition(condition1);
	
	

	
	
	/*
	for(int i = 0;i<100;i++)
	{
		cout << endl << "Step:" << i << endl;		

		double condition[emlig_size+1];		

		for(int k = 0;k<=emlig_size;k++)
		{
			condition[k] = (rand()-RAND_MAX/2)/1000.0;		
		}
			

		vec* condition_vec = new vec(condition,emlig_size+1);
		emlig1->add_condition(*condition_vec);

		/*
		for(polyhedron* toprow_ref = emlig1->statistic.rows[emlig_size]; toprow_ref != emlig1->statistic.end_poly; toprow_ref = toprow_ref->next_poly)
		{
			cout << ((toprow*)toprow_ref)->probability << endl;
		}
		*/
		/*
		cout << emlig1->statistic_rowsize(emlig_size) << endl << endl;
	
		/*
		if(i-emlig1->number_of_parameters >= 0)
		{
			pause(30);
		}
		*/

		// emlig1->step_me(i);
		
		/*
		vector<int> sizevector;
		for(int s = 0;s<=emlig1->number_of_parameters;s++)
		{
			sizevector.push_back(emlig1->statistic_rowsize(s));
		}
		*/
	//}
    


	
	/*
	emlig1->step_me(1);

	vec condition = "2.0 0.0 1.0";	

	emlig1->add_condition(condition);

	vector<int> sizevector;
	for(int s = 0;s<=emlig1->number_of_parameters;s++)
	{
		sizevector.push_back(emlig1->statistic_rowsize(s));
	}

	emlig1->step_me(2);

	condition = "2.0 1.0 0.0";

	emlig1->add_condition(condition);

	sizevector.clear();
	for(int s = 0;s<=emlig1->number_of_parameters;s++)
	{
		sizevector.push_back(emlig1->statistic_rowsize(s));
	}
	*/