www.pudn.com > Genecircus20070919.rar > Monte_carlo.cpp

// Monte_carlo.cpp: implementation of the Monte_carlo class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "Monte_carlo.h" 
#define  M_SQRT2   1.41421356237309504880  
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
Monte_carlo::Monte_carlo() 
{ 
     max = 0.0; 
} 
 
Monte_carlo::~Monte_carlo() 
{ 
 
} 
 
void Monte_carlo::Find_appropriate_width_tolerance() 
{ 
	 gene g_temp; 
	 conn c_temp; 
     if(gene_matrix->micro_set.size() == 0) 
        return; 
	 if(shuffle->obj_index == -1) 
		return; 
	 if(read_object()){ 
		 for(double wid = 0.50;wid > 0.40;wid = wid-0.001){ 
			 getmi->sigma = wid; 
			 for(double tor = 0.85;tor<0.9;tor = tor-0.001){ 
				 getnetwork->tolerance = tor; 
				 clear_eniverment(); 
				 comput_mi(shuffle->obj_index,gene_matrix->micro_set.size()); 
				 getnetwork->Get(); 
				 g_temp = net->g; 
				 c_temp = net->c; 
				 clear_eniverment(); 
				 comput_mi(shuffle->obj_index1,gene_matrix->micro_set.size()); 
				 getnetwork->Get(); 
				 double max_temp = check(g_temp,net->g); 
				 compare_save(max_temp); 
			 } 
		 } 
	 } 
} 
 
void Monte_carlo::compare_save(double max_temp) 
{ 
	 if(max < max_temp) 
		max = max_temp; 
	 string result = ""; 
	 result = "Max = " + boost::lexical_cast(max) + '\r'+'\n'; 
	 result += "Width = " + boost::lexical_cast(getmi->sigma) + '\r' + '\n'; 
	 result += "Tolerance = " + boost::lexical_cast(getnetwork->tolerance) + '\r' + '\n'; 
	 int count = result.length(); 
	 const char * t = result.c_str(); 
	 wxString dirname = dirname + gene_matrix->micro_set[shuffle->obj_index].name+".tmp"; 
	 wxFile file; 
	 file.Create(dirname,true); 
	 file.Open(dirname,wxFile::read_write); 
	 file.Write(t,count); 
	 file.Close(); 
} 
 
bool Monte_carlo::read_object() 
{ 
	 bool ok = false; 
	 unsigned char * t; 
     wxString dirname ; 
	 dirname = getmi->dirname + gene_matrix->micro_set[shuffle->obj_index].name+"_object"+".txt"; 
	 wxFile file; 
	 if(file.Open(dirname)){ 
		int nSize = file.Length(); 
        t = new unsigned char[nSize]; 
	    file.Read(t,nSize); 
        wxString temp_data = (wxString)t; 
		while(1){ 
			 int index = temp_data.Find('\n'); 
			 if(index == -1) 
				break; 
			 wxString sub = temp_data.SubString(0,index); 
			 name_temp.push_back(sub); 
			 temp_data.Remove(0,index+1); 
		} 
	    file.Close(); 
		delete [] t; 
	    return ok; 
	 } 
     else 
	   return false; 
} 
 
void Monte_carlo::comput_mi(int index,int size) 
{ 
	 int i = index; 
     int j = 0; 
	 while( j < size ){ 
		    getmi->get_GenePairs_Mi(i,j); 
			j++; 
	 } 
} 
 
double Monte_carlo::check(gene g1,gene g2) 
{ 
       double a = 0.0; 
	   int total = name_temp.size(); 
	   int number = 0; 
	   for(int i = 0;i < total;i++){ 
		   for(int a = 0;a < g1.size();a++){ 
			   if(name_temp[i] == g1[a].name){ 
				  number++; 
				  break; 
			   } 
		   } 
		   if(a == g1.size()){ 
			  for(int a1 = 0;a1 < g2.size();a1++){ 
                  if(name_temp[i] == g2[a1].name){ 
				     number++; 
					 break; 
				  } 
			  } 
		   } 
	   } 
	   a = number/total; 
	   return a; 
} 
 
void Monte_carlo::clear_eniverment() 
{ 
     if(net->c.size() != 0) 
	    net->c.clear(); 
	 if(net->g.size() != 0) 
	    net->g.clear(); 
	 gene_matrix->index_temp.clear(); 
     gene_matrix->delete_maxtri(); 
	 if(getmi->prob_table != NULL){		 
	    for ( int i = 0; i < getmi->number; i++ ) 
		{ 
		   delete[] getmi->prob_table[i]; 
		   delete[] getmi->norm_2D_table[i]; 
		}	    
	    delete[] getmi->prob_table; 
	    delete[] getmi->norm_2D_table; 
	    delete[] getmi->norm_1D_table; 
	 } 
	  int number = getmi->number; 
      getmi->prob_table = new double * [number]; 
      for ( int i = 0; i < number; i++ ) 
      { 
        getmi->prob_table[i] = new double[number]; 
        for ( int j = 0; j < number; j++ ) 
        { 
          getmi->prob_table[i][j] = -1.0; 
        } 
      } 
 
      getmi->norm_1D_table = new double[number]; 
 
      getmi->norm_2D_table = new double * [number]; 
      for ( int p = 0; p < number; p++ ) 
      { 
        getmi->norm_2D_table[p] = new double[number]; 
      }	  
	  double sigma = getmi->sigma; 
	  for (int i=0; inorm_1D_table[i] = 0.5*( getmi->erf( (1-x)/(sigma*M_SQRT2),0 ) - getmi->erf( (0-x)/(sigma*M_SQRT2),0 ) ); 
	  } 
 
	  for (int j=0; jnorm_2D_table[j][k] = getmi->norm_1D_table[j]*getmi->norm_1D_table[k]; 
		  getmi->norm_2D_table[k][j] = getmi->norm_2D_table[j][k]; 
		} 
	  } 
}