column.cc

#include<scil/column_entry.h>
#include<scil/column.h>

using namespace SCIL;

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

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

column::column (cons v)
{
  NZ.push_back (column_entry (v, 1));
}

column::column (std::list<column_entry> &L)
{
  NZ = L;
}

void
column::normalize ()
{
  NZ.sort();
  std::list<column_entry>::iterator ce;
  std::list<column_entry>::iterator next;
  foreach( ce, NZ ){
    next = ce;
    next++;
    while( (next!=NZ.end()) && (ce->Cons==next->Cons) ){
      ce->coeff += next->coeff;
      next = NZ.erase(next);
    } 
  }
}

column
column::operator * (double d)
{
  std::list<column_entry>::iterator ce;
  std::list < column_entry > NNZ;
  foreach( ce, NZ ){
    NNZ.push_back( column_entry( ce->Cons, d * ce->coeff ));
  };
  return column (NNZ);
}

column
column::operator + (column r)
{
  std::list < column_entry > NNZ;

  std::list<column_entry>::const_iterator rit = r.NZ.begin();
  std::list<column_entry>::const_iterator it;

  double d;
  foreach (it, NZ)
  {
    d = 0;
    while ((rit != r.NZ.end()) && (rit->Cons <= it->Cons))
      {
        if (rit->Cons != it->Cons)
          {
            NNZ.push_back (*rit);
          }
        else
          {
            d = rit->coeff;
          }
        rit++;
      }
    NNZ.push_back (column_entry (it->Cons, it->coeff + d));
  }
  return column (NNZ);
}

column & column::operator += (column r)
{
  std::list<column_entry>::const_iterator ce;

  foreach (ce, r.NZ)
  {
    NZ.push_back (*ce);
  }
  return *this;
}

column & column::operator -= (column r)
{
  std::list<column_entry>::const_iterator ce;
  foreach (ce, r.NZ)
  {
    NZ.push_back (column_entry (ce->Cons, -ce->coeff));
  };
  return *this;
}

column
column::operator + (cons v)
{
  return operator + (column (v));
};

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

column
column::operator - (column r)
{
  std::list<column_entry>::const_iterator it;
  std::list<column_entry>::const_iterator rit = r.NZ.begin();

  std::list < column_entry > NNZ;
  double d;
  foreach (it, NZ)
  {
    d = 0;
    while ((rit != r.NZ.end()) && (rit->Cons <= it->Cons))
      {
        if (rit->Cons != it->Cons)
          {
            NNZ.push_back (column_entry (rit->Cons, -rit->coeff));
          }
        else
          {
            d = -rit->coeff;
          }
        rit++;
      }
    NNZ.push_back (column_entry (it->Cons, it->coeff + d));
  }
  return column (NNZ);
}


column operator *(double d, cons i)
{
  return column (i) * d;
};

column operator *(double d, column c)
{
  return c * d;
};

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

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

std::list<column_entry>::iterator column::begin() {
  return NZ.begin();
};

std::list<column_entry>::iterator column::end() {
  return NZ.end();
};

---