#include "pattern.h"



#include <iostream.h>



#define _CHECK_INDEX



#define _NBPAT 200


/*inline*/ patterns::patterns() : 
   nbVar(0), nbPat(0), patCur(0), index(0,0), 
   sizePat(1,0), coverPat(1,0), weightPat(1,0), order(1,0) 
{}

/*inline*/ patterns::patterns(int maxDgr) : 
   nbVar(0), nbPat(0), patCur(0), index(_NBPAT,maxDgr), 
   sizePat(1,_NBPAT), coverPat(1,_NBPAT), weightPat(1,_NBPAT), order(1,_NBPAT) 
{}

/*inline*/ patterns::~patterns() {}

/*inline*/ int patterns::nbPatterns() const { return nbPat; }

/*inline*/ void patterns::first() { patCur=0; }

/*inline*/ void patterns::next() { patCur++; }

/*inline*/ boolean patterns::eol() { return (patCur>=nbPat); }

patterns& patterns::add(const int n, const Matrix<int>& dblIndices, 
	                const int cover, const float weight)
{
   //int i; ??
   if ( !nbPat ) nbVar=n;
   if ( n!=nbVar ) 
   {	
      flog<< "### patterns based on different sets of variables!\n" << flush;
      return *this;
   }
   if ( nbPat == index.m() )
   {	
      index.resize_(index.m()+_NBPAT,index.n());
      sizePat.resize_(1,index.m());
      coverPat.resize_(1,index.m());
      weightPat.resize_(1,index.m());
      order.resize_(1,index.m());
   }
   if ( dblIndices.n() > index.n() )
   {	
      flog<< "### pattern is longer than expected!\n" << flush;
      return *this;
   }
   if ( dblIndices.n() ) index.s(nbPat,1,0,dblIndices.n()) = dblIndices;
   sizePat(nbPat) = dblIndices.n();
   coverPat(nbPat) = cover;
   weightPat(nbPat) = weight;
   order(nbPat) = nbPat;
   nbPat++;
   return *this;
}

/*inline*/ patterns& patterns::empty() 
{	
   nbPat=0; return *this; 
}

/*inline*/ int patterns::size() const 
{	
   return sizePat(order(patCur)); 
}

int patterns::var(const int literalIndex) const 
{	
   int res = index(order(patCur),literalIndex); 
   return ( res < nbVar ) ? res : res-nbVar; 
}

/*inline*/ boolean patterns::bar(const int literalIndex) const 
{ return ( index(order(patCur),literalIndex) >= nbVar ); }

/*inline*/ int patterns::coverage() const { return coverPat(order(patCur)); }

/*inline*/ float& patterns::weight() { return weightPat(order(patCur)); }

boolean	patterns::fire (const Array<ST>& data) const
{	
   for (int varInd=0; varInd<sizePat(order(patCur)); varInd++ )
   {
      int i=index(order(patCur),varInd);
      if ( i < nbVar )
      { if (!data(i) || unknown(data(i))) return false; }
      else
      { if (data(i-nbVar) || unknown(data(i-nbVar))) return false; }
   }
   return true;
}

void patterns::delPattern()
{	
   if ( patCur < --nbPat )
   { order(patCur)=order(nbPat); }
}

void patterns::delPattern(int patIndex)
{
#ifdef _CHECK_INDEX
   if ( patIndex<0 || patIndex>=nbPat )
      throw whereOutOfRange(	"void patterns::delPatterns(int patIndex)",
				"patIndex",patIndex,0,nbPat-1);
#endif
   if ( patIndex < --nbPat )
   { order(patIndex)=order(nbPat); }
}

void patterns::printPattern(ostream& s)
{	for (int j=0; j<sizePat(order(patCur)); j++)
   if ( index(order(patCur),j)<nbVar ) 
      s << setw(4) <<   index(order(patCur),j)+1;
   else	
      s << setw(4) << -(index(order(patCur),j)-nbVar+1);
}

// new function to sort the patterns. Untested  Mario
void patterns::sort(int l, int r)
{
   int i,j,v,aux;
   if(r>l)
   {
      //int k; ??
      v=sizePat(order(r)); i=l-1; j=r;
      for(;;)
      {
	 ++i; --j; if(i<0) i=0;
	 while(((sizePat(order(i)) < v)  || (sizePat(order(i)) == v && weightPat(order(i)) > weightPat(order(r))) || (sizePat(order(i)) == v && weightPat(order(i)) == weightPat(order(r)) && coverPat(order(i)) > coverPat(order(r)))) && i<r)  i++;
	 while(((sizePat(order(j)) > v)  || (sizePat(order(j)) == v && weightPat(order(j)) < weightPat(order(r))) || (sizePat(order(j)) == v && weightPat(order(j)) == weightPat(order(r)) && coverPat(order(j)) < coverPat(order(r)))) && l<j)  j--;
	 if (i>=j) break;
	 aux=order(i); order(i)=order(j); order(j)=aux;
      }
      aux=order(i); order(i)=order(r); order(r)=aux;
      sort(l,i-1);
      sort(i+1,r);
   }
}

// new function that implements a quicksort routine to sort the patterns
// by degree, then weight, then coverage.

void patterns::do_sort()
{
   sort(0,nbPat-1);
/*  printf("\n correct pattern order is:\n"); 
    for(int i=0;i<=nbPat-1;i++) printf("%d with pattern size %d\n", order(i), sizePat(order(i))); */
}
 

ostream& operator << (ostream& s, patterns& ps)
{ 
   Matrix<int> cardinal(1,ps.index.n()+1,0);
   //    ps.do_sort();  //new Mario
   for (int i=0; i<ps.nbPatterns(); i++)
   {
      for (int j=0; j<ps.index.n(); j++)
	 if ( j<ps.sizePat(ps.order(i)) )
	    if ( ps.index(ps.order(i),j)<ps.nbVar ) 
	       s << setw(4) <<   ps.index(ps.order(i),j)+1;
	    else	
	       s << setw(4) << -(ps.index(ps.order(i),j)-ps.nbVar+1);
	 else
	    s << "    ";
      s	<< "[" << setw(3) << ps.coverPat(ps.order(i)) <<"] w:" 
	<< setw(5) << setprecision(3) << ps.weightPat(ps.order(i)) << endl;
      cardinal(ps.sizePat(ps.order(i)))++;
   }
   s << setw(5) << ps.nbPatterns() << " patterns distributed by degree as: ";
   for (i=0; i<cardinal.n(); i++)
      if ( cardinal.s(0,1,i)==0 )
	 break;
      else 
	 s << setw(8) << cardinal(i);
   s << endl;
   return s;
}


void operator << (const char* fileName, const patterns& myself)
{
   ofstream out(fileName); 
   if ( !out )
      throw whereWhich("void operator << (char* fileName, patterns&)",
		       "File open error");
   const char sep = ' ';
   int maxDgr = 0;
   for (int i=0; i<myself.nbPat; i++)
      maximize(maxDgr,myself.sizePat(myself.order(i)));
   out << myself.nbVar << sep << myself.nbPat << sep << maxDgr <<endl;
   for (i=0; i<myself.nbPat; i++)
      out<< myself.index.s(myself.order(i),1,0,maxDgr) 
	 << myself.sizePat(myself.order(i)) << sep
	 << myself.coverPat(myself.order(i)) << sep
	 << myself.weightPat(myself.order(i)) << endl;
   out.close();
}


void operator >> (const char* fileName, patterns& myself)
{
   ifstream in(fileName); 
   if ( !in )
      throw whereWhich("void operator >> (char* fileName, patterns&)",
		       "File open error");
   int maxDgr;
   in >> myself.nbVar >> myself.nbPat >> maxDgr;
   myself.patCur=0;
   myself.index.resize(myself.nbPat,maxDgr);
   myself.order.resize(1,myself.nbPat);
   myself.sizePat.resize(1,myself.nbPat);
   myself.coverPat.resize(1,myself.nbPat);
   myself.weightPat.resize(1,myself.nbPat);
   for (int i=0; i<myself.nbPat; i++)
   {
      myself.order(i)=i;
      in >> myself.index.s(i) 
	 >> myself.sizePat.s(0,1,i,1) 
	 >> myself.coverPat.s(0,1,i,1)
	 >> myself.weightPat.s(0,1,i,1);
   }
   in.close();
}