// pat.C



#include <stdio.h>
#include <fstream.h>
#include <strstream.h>

#include "../Basics/pipeostream.h"
#include "../Basics/basic.h"
#include "../Basics/chrono.h"
#include "../Basics/exception.h"
#include "../Matrices/Matrix.h"
//#include "../Matrices/setCovering.h"
#include "main_def.h"
#include "multiDS.h"
#include "pattern.h"



int main () { try
{
   //-------------------------------------------
   //Collect general information for the batch
   //-------------------------------------------
   
   char inFile[80], outFile[80], choice[80]; 

   // Declaration of all parameters, with default values
   float percFrom=10.0; 
   float percTo=10.0; 
   float percInter=1.0; 
   int nbIter=1;
   int nbSizes=1; 
   int initSeed=0;
   int iteration=0;
   float percForPat=100;
   int maxDgr=3;
   int minCovPos=1;
   int minCovNeg=1;
   int satCov=20;
   int minDist=1;
   float except=0;
   boolean patching=true;
   int patReduce=-1;

#if _batch_mode
   trace=0;
#else
   cout<<"Trace level (1=normal, 2=debug): ";
   cin>>trace; 
#endif
   
   cout.setf(ios::fixed | ios::showpoint);

   cout<<"Prefix XXX of the files (.tra) containing the training data : "; 
   cin>>inFile;
   cout<<"Prefix XXX for the files (.pos, .neg) with the patterns : "; 
   cin>>outFile;
   sprintf(choice,"%s-pat.out",outFile);
   ofstream fout(choice);
   fout<<"Prefix XXX of the files (.tra) containing the training data : "
       <<inFile<<endl; 
   fout<<"Prefix XXX for the files (.pos, .neg) with the patterns : "
       <<outFile<<endl; 
   sprintf(choice,"%s-pat.log",outFile); flog.open(choice);

   cout<<(fout<<="Training set's size (in %) from: "); 
   cin>>percFrom; fout<<setprecision(2)<<setw(6)<<percFrom<<endl;

   percTo = percFrom;
   if ( percFrom < 100.0 )
   {
      cout<<(fout<<="Training set's size (in %) to  : "); 
      cin>>percTo; fout<<setprecision(2)<<setw(6)<<percTo<<endl;
   }
   if ( percTo != percFrom )
   {
      cout<<(fout<<="Interval in training set's size (in %): "); 
      cin>>percInter; fout<<setprecision(2)<<setw(6)<<percInter<<endl;
   }
   if ( percFrom < 100.0 )
   {
      cout<<(fout<<="#iterations of each experimentation: "); 
      cin>>nbIter; fout<<setw(4)<<nbIter<<endl;
   }
   nbSizes = 1 + int((percTo - percFrom)/percInter);
   const boolean singleExp = ((nbSizes * nbIter) == 1);
   if ( singleExp )
   {
      cout<<(fout<<="Iteration: ");
      cin>>iteration; fout<<iteration<<endl;
   }
   else if ( percFrom < 100.0 )
   {
      cout<<(fout<<="Seed: ");
      cin>>initSeed; fout<<setw(8)<<initSeed<<endl;
   }

   cout<<(fout<<="Percentage of training sample used for pattern generation: ");
   cin>>percForPat; fout<<percForPat<<endl;

   cout<<(fout<<="Generate patterns of degree up to: ");
   cin>>maxDgr; fout<<maxDgr<<endl;

   cout<<(fout<<=
   "Minimal coverage of each positive pattern (use negative number for %) : ");
   cin>>minCovPos; fout<<minCovPos<<endl;

   cout<<(fout<<=
   "Minimal coverage of each negative pattern (use negative number for %) : ");
   cin>>minCovNeg; fout<<minCovNeg<<endl;

   cout<<(fout<<="Satisfactory coverage of each point (50): ");
   cin>>satCov; fout<<satCov<<endl;

   cout<<(fout<<="Minimal distance from a pattern to an opposite point (1): ");
   cin>>minDist; fout<<minDist<<endl;

   cout<<(fout<<="Exception rate tolerated, i.e. fuzzy patterns (0.01 = 1%): ");
   cin>>except; fout<<except<<endl;

   cout<<(fout<<="Generate extra patterns to cover uncovered points (y/n): ");
   cin>>choice; patching=(choice[0]=='y'); fout<<choice<<endl;

   cout<<(fout<<="Extract a minimal set of patterns for a cover (y/n): ");
   cin>>choice; patReduce=(choice[0]=='y'); fout<<choice<<endl;

   if ( patReduce )
   {
      cout<<(fout<<="Minimal coverage number for each points: ");
      cin>>patReduce; fout<<patReduce<<endl;
   }
   else
   {
      cout<<(fout<<="Suppress patterns covering a subset of others (y/n): ");
      cin>>choice; patReduce = (choice[0]=='y' ? -1 : 0); fout<<choice<<endl;
   }

   //---------------
   // Set seed Table
   //---------------
   Matrix<int> seed(nbSizes,nbIter);
   fixSeed(initSeed);
   if(singleExp) seed(0,0)= initSeed;
   else
      for (int size=0; size<nbSizes; size++)
	 for (int iter=0; iter<nbIter; iter++)
	    seed(size,iter) = int(1E6 * randomR());

   // Loop on the size
   int cSize; float perc;
   for (perc=percFrom, cSize=0; perc<=percTo; perc+=percInter, cSize++)
   {
      Matrix<double> stat(1,9,0.0), statS(1,9,0.0), statSSQ(1,9,0.0),
	             statMin(1,9,1E10), statMax(1,9,-1E10);
    
      flog<<endl<<perc<<"% of data used for training\n"<<flush;
    
      // Loop on iterations
      for (int Iter=0; Iter<nbIter && (Iter<1 || perc<100.0); Iter++)
      {
	 // Print some heading titles
	 if ( nbIter>10 ? Iter%20==0 : (!Iter && (!cSize || 
						  (((cSize-1)*nbSizes)/20 !=
						  (cSize*nbSizes)/20))) )
	 {
	    cout<<(fout<<=
	    "Perc-  |sample-sz| |#pat-gene--#pat--kept| |#-uncover| |pat|\n");
	    cout<<(fout<<=
	    " -Iter |difP-difN| |-Pos--Neg---Pos---Neg| |-Pos--Neg| |tim|\n");
	 }

	 fixSeed(seed(cSize, Iter));
	 flog<<seed(cSize, Iter)<<" "<<flush;
	 int ii=0;

	 // Read the training file
	 multiDS<ST> training;
	 {
	    char fn[80]; ostrstream buff(fn,80);
	    buff<<inFile<<"-"<<setw(2)<<setfill('0')<<int(perc)
	       <<"%"<<setw(3)<< (singleExp ? iteration : Iter+1) <<".tra"<<ends;
	    dataSet<ST> whole; fn>>whole;
	    training.separate(whole);
	 }

	 // extract subset of training data used for pattern generation
	 multiDS<ST> trainFP(training,percForPat/100.0);
	 if ( trace>1 && percForPat<100.0 )
	    cout<< "\n*** data for pattern generation:\n" << trainFP;
	 stat(ii++) = trainFP.ds[1].distinct();
	 stat(ii++) = trainFP.ds[0].distinct();

	 // generate patterns
	 chrono patternGeneration;
	 patterns posPat(trainFP.ds[1].dim()); 
	 patterns negPat(trainFP.ds[0].dim()); 
	 int puc,nuc; Matrix<int> one(1,1,1); Matrix<int> zero(1,1,0);
	 if ( trace>2 )
	    cout<< "\n*** generation of small patterns:\n";
	 trainFP.smallPatterns(posPat,puc,one,zero,true,
			       maxDgr,minCovPos,satCov,minDist,except);
	 trainFP.smallPatterns(negPat,nuc,zero,one,false,
			       maxDgr,minCovNeg,satCov,minDist,except);
	 if ( patching )
	 {
	    trainFP.patchPatterns(negPat,zero,one,false,nuc);
	    trainFP.patchPatterns(posPat,one,zero,true,puc);
	 }
	 if ( trace>2 )
	    cout<< "\n*** positive patterns generated:\n" << posPat
		<< "\n*** negative patterns generated:\n" << negPat;
	 stat(ii++) = posPat.nbPatterns();
	 stat(ii++) = negPat.nbPatterns();

	 // Reduction of patterns
	 if ( patReduce==-1 || patReduce==1 )
	 {
	    trainFP.cleanPatterns(posPat,one);
	    trainFP.cleanPatterns(negPat,zero);
	    if ( trace>2 )
	       cout<< "\n*** positive patterns (after cleaning):\n" 
		   << posPat
		   << "\n*** negative patterns (after cleaning):\n" 
		   << negPat;
	 }
	 if ( patReduce>0 )
	 {
	    trainFP.reducePatterns(posPat,one, patReduce);
	    trainFP.reducePatterns(negPat,zero,patReduce);
	    if ( trace>2 )
	       cout<< "\n*** positive patterns (after reduction):\n" 
		   << posPat
		   << "\n*** negative patterns (after reduction):\n" 
		   << negPat;
	 }
	 stat(ii++) = posPat.nbPatterns();
	 stat(ii++) = negPat.nbPatterns();
	 stat(ii++) = puc;
	 stat(ii++) = nuc;
	 stat(ii++) = patternGeneration.time();

	 // Save patterns on file
	 {
	    char pref[80]; ostrstream buff(pref,80);
	    buff<<outFile<<"-"<<setw(2)<<setfill('0')<<int(perc)
	       <<"%"<<setw(3)<<(singleExp ? iteration : Iter+1)<<ends;
	    char fn[80];
	    sprintf(fn,"%s.pos",pref); fn<<posPat;
	    sprintf(fn,"%s.neg",pref); fn<<negPat;
	 }

	 // Print the results
	 cout<<setfill('0')<<setw(2)<<int(perc)<<"%"
	     <<setw(3)<<(singleExp ? iteration : Iter+1)<<setfill(' ')
	     <<coefWidth(6)<<coefPrecision(-1)<<stat<<flush;
	 fout<<setfill('0')<<setw(2)<<int(perc)<<"%"
	     <<setw(3)<<(singleExp ? iteration : Iter+1)<<setfill(' ')
	     <<coefWidth(6)<<coefPrecision(-1)<<stat<<flush;

	 // Update the stat
	 statS   += stat;
	 statSSQ += stat.map(&Sqr);
	 statMin  = (stat ^ statMin).minC();
	 statMax  = (stat ^ statMax).maxC();
      }

      // Print the statistics
      if ( nbIter>1 )
      {
	 cout<<"  mean"<<coefWidth(6)<<coefPrecision(1)<<statS/(nbIter)
	     <<"   std"<<((statSSQ-(statS.map(&Sqr))/(double(nbIter)))/
			 (double(nbIter-1))).map(&SQRT)
	     <<"   min"<<coefPrecision(-1)<<statMin<<"   Max"<<statMax<<endl;
	 fout<<"  mean"<<coefWidth(6)<<coefPrecision(1)<<statS/(nbIter)
	     <<"   std"<<((statSSQ-(statS.map(&Sqr))/(double(nbIter)))/
			 (double(nbIter-1))).map(&SQRT)
	     <<"   min"<<coefPrecision(-1)<<statMin<<"   Max"<<statMax<<endl;
      }
   }

   return 0;
}
catch (whereWhich e){ cout<<e; flog<<e; }
catch (whereOutOfRange e){ cout<<e; flog<<e; }
catch (whereDimMismatch e){ cout<<e; flog<<e; }
catch (nullArray e){ cout<<e; flog<<e; }
catch (whereException& e){ cout<<e; flog<<e; }
}