row.cc

#include<LEDA/list.h>
#include<scil/global.h>
#include<scil/row.h>
#include<scil/row_constraint.h>

using namespace SCIL;
using namespace LEDA;

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

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

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

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

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

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

row row::operator* (double d) {
  row_entry st;
  list<row_entry> NNZ;
  forall(st, NZ) {
    NNZ.append(row_entry(st.Var, d*st.Coeff));
  };
  return row(NNZ);
}

row row::operator+ (const row& r) {
 list<row_entry> NNZ;
  list_item l1=r.NZ.first();
  row_entry st;
  double d;
  forall(st, NZ) {
    d=0;
    while((l1!=nil) && (r.NZ[l1].Var<=st.Var)) {
      if(r.NZ[l1].Var!=st.Var) {
        NNZ.append(r.NZ[l1]);
      } else {
        d=r.NZ[l1].Coeff;
      }
      l1=r.NZ.succ(l1);
    }
    NNZ.append(row_entry(st.Var, st.Coeff+d));
  }

  while(l1!=nil) {
    NNZ.append(r.NZ[l1]);
    l1=r.NZ.succ(l1);
  }
  return row(NNZ);
}

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

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

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

row& row::operator+= (const row& r) {
  row_entry st;
  forall(st, r.NZ) {
    NZ.append(st);
  }
  return *this;
}

row& row::operator-= (const row& r) {
  row_entry st;
  forall(st, r.NZ) {
    NZ.append(row_entry(st.Var, -st.Coeff));
  }
  return *this;
}

void row::normalize() {
  NZ.sort();
  list_item li=NZ.first_item();
  int i=1;
  while(li!=nil) {
    while((i<NZ.length()) && (NZ[li].Var==NZ[NZ.succ(li)].Var)) {
      NZ[li].Coeff+=NZ[NZ.succ(li)].Coeff;
      NZ.del_item(NZ.succ(li));
    }
    i++;
    li=NZ.succ(li);
  }
}

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) {
  list<row_entry> NNZ;
  list_item l1=r.NZ.first();
  row_entry st;
  double d;
  forall(st, NZ) {
    d=0;
    while((l1!=nil) && (r.NZ[l1].Var<=st.Var)) {
      if(r.NZ[l1].Var!=st.Var) {
        NNZ.append(row_entry(r.NZ[l1].Var, -r.NZ[l1].Coeff));
      } else {
        d=-r.NZ[l1].Coeff;
      }
      l1=r.NZ.succ(l1);
    }
    NNZ.append(row_entry(st.Var, st.Coeff+d));
  }
  while(l1!=nil) {
    NNZ.append(row_entry(r.NZ[l1].Var, -r.NZ[l1].Coeff));
    l1=r.NZ.succ(l1);
  }
  return row(NNZ);
}

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

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


row::item row::first_item() const {
  return NZ.first_item();
};

row::item row::next_item(item i) const {
  return NZ.next_item(i);
}

row_entry row::inf(const item i) const {
  return NZ.inf(i);
}

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

ostream& SCIL::operator<<(ostream& o,const row& r) {
  row_entry re;
  forall(re, r) { o<<re<<"+"; }
  return o;
};

---