row.cc

#include<scil/global.h>
#include<scil/row.h>
#include<scil/row_constraint.h>
#include<scil/core/polynomial.h>

using namespace SCIL;

row::row(double d) {
  /*{\Mcreate Creates the row $d$.}*/
  NZ.push_back(row_entry(nil, d));
}

cons_obj* row::operator== (row r1) {
  row r2=(*this)-r1;
  r2.normalize();
  return new row_constraint(r2, Equal);
}

cons_obj* row::operator<= (row r1) {
  row r2=(*this)-r1;
  r2.normalize();
  return new row_constraint(r2, Less);
}

cons_obj* row::operator>= (row r1) {
  row r2=(*this)-r1;
  r2.normalize();
  return new row_constraint(r2, Greater);
}

row::row(var v) {
  NZ.push_back(row_entry(v,1));
}

row::row(std::list<row_entry>& L) {
  NZ=L;
}

row row::operator* (double d) {
  std::list<row_entry> NNZ;
  std::list<row_entry>::const_iterator it;
  for( it = NZ.begin (); it!=NZ.end (); it++ ){
    NNZ.push_back ( row_entry(it->Var, d*it->coeff));
  }
  return row(NNZ);
}

polynomial row::operator*(const polynomial& p) {
   return polynomial(*this) * p;
}

polynomial row::operator*(const var& v) {
   return *this * monomial(v);
}

polynomial row::operator* (const monomial& m) {
  polynomial p;  
  std::list<row_entry>::const_iterator re;
  for( re = NZ.begin(); re!=NZ.end(); re++ ){
    if(re->Var != NULL)
      p += (monomial(re->coeff, re->Var) *m);
    else if(re->coeff != 0)
      p += re->coeff * m; 
  };
  return p;
}

polynomial row::operator+ (const polynomial& p) {
  return polynomial(*this) + p;
}

row row::operator+(const row& r) {
  std::list<row_entry> NNZ;
  double d;
  std::list<row_entry>::const_iterator it;
  std::list<row_entry>::const_iterator rit = r.NZ.begin();
  for (it = NZ.begin(); it != NZ.end(); it++) {
    d = 0;
    while ((rit != r.NZ.end()) && (rit->Var <= it->Var)) {
      if (rit->Var != it->Var) {
        NNZ.push_back(*rit);
      } else {
        d = rit->coeff;
      }
      rit++;
    }
    NNZ.push_back(row_entry(it->Var, it->coeff + d));
  }
  while( rit!=r.NZ.end() ){
    NNZ.push_back( *rit );
    rit++;
  }
  return row( NNZ );
}

row& row::operator+=(const var& v) {
  NZ.push_back(row_entry(v,1));
  return *this;
};

row& row::operator-=(const var& v) {
  NZ.push_back(row_entry(v,-1));
  return *this;
};

row& row::operator+=(const row_entry& r) {
  NZ.push_back(r);
  return *this;
};

row& row::operator+= (const row& r) {
  std::list<row_entry>::const_iterator rit;
  for( rit=r.NZ.begin(); rit!=r.NZ.end(); rit++ ) {
    NZ.push_back( *rit );
  }
  return *this;
}

row& row::operator-=(const row& r) {
  std::list<row_entry>::const_iterator rit;
  for (rit = r.NZ.begin(); rit != r.NZ.end(); rit++) {
    NZ.push_back(row_entry(rit->Var, -rit->coeff));
  }
  return *this;
}

row row::operator- (const var& v) {
   return *this - row(v);
}

void row::normalize(bool clean) {
  NZ.sort();
  
  std::list<row_entry>::iterator it = NZ.begin();
  std::list<row_entry>::iterator i;
  while(it!=NZ.end()) {
    i = it;
    i++;
    while( i!=NZ.end() && (it->Var==i->Var) ){
      it->coeff += i->coeff;
      i = NZ.erase(i);
    }
    it++;
  }

  if( clean ) {
     it = NZ.begin();
     while( it!=NZ.end() ){
       if( (it->coeff * it->coeff) < .000001 ){
         it = NZ.erase(it);
       } else{
         it++;
       }
     }
  }
}

row row::operator+ (const var& v) {
  return operator+(row(v));
};

row row::operator+ (double d) {
  return operator+(row(d));
};

row row::operator- (const row& r) {
  std::list<row_entry> NNZ;
  std::list<row_entry>::const_iterator rit = r.NZ.begin();
  std::list<row_entry>::const_iterator it;
  double d;
  for( it=NZ.begin(); it!=NZ.end(); it++ ){
    d=0;
    while((rit!=r.NZ.end()) && (rit->Var<=it->Var)) {
      if(rit->Var!=it->Var) {
        NNZ.push_back (row_entry(rit->Var, -rit->coeff));
      } else {
        d=-rit->coeff;
      }
      rit++;
    }
    NNZ.push_back(row_entry(it->Var, it->coeff+d));
  }
  while(rit!=r.NZ.end()) {
    NNZ.push_back(row_entry(rit->Var, -rit->coeff));
    rit++;
  }
  return row(NNZ);
}

polynomial row::operator-(const polynomial& p) {
   return polynomial(*this) - p;
}

row SCIL::operator*(double d, var v) {
  return row(v)*d;
};

row SCIL::operator*(double d, row r) {
  return r*d;
};

std::list<row_entry>::const_iterator row::begin() const {
  return NZ.begin();
}

std::list<row_entry>::const_iterator row::end() const {
  return NZ.end();
}

std::list<row_entry>::iterator row::begin() {
  return NZ.begin();
}

std::list<row_entry>::iterator row::end() {
  return NZ.end();
}

int row::size() const {
  /*{\Mop returns the number of entries in the column.}*/
  return NZ.size();
}

std::ostream& SCIL::operator<<(std::ostream& o,const row& r) {
  std::list<row_entry>::const_iterator it;
  for( it = r.begin (); it!=r.end (); it++ ){ o<<*it<<"+"; }
  return o;
};


namespace SCIL {
int compare(const row& r1, const row& r2) {
   //cerr << "row compare  ";
   int l = r1.size() - r2.size();
   //cerr << r1 << endl;
   //cerr << r2 << endl;
   //cerr << "size diff: " << l << endl;
   if( l != 0 )
      return l;

   // case r1.size == r2.size
   int st = 0;
   std::list<row_entry>::const_iterator it1, it2;
   it2 = r2.begin();
   for( it1=r1.begin(); it1!=r1.end(); it1++, it2++){
     st = compare( *it1, *it2 );
     //cerr << st << " ";
     if( st != 0 )
       return st;
   }
   //cerr << "\nend: equal" << endl;
   return 0;
}
}

---