column.cc

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

column_entry column::inf(const item i) const 
{
  return NZ.inf(i);
}

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


column::item column::first_item() const 
{
  /*{\Mop Returns the first non-zero entry of the column.}*/
  return NZ.first_item();
};


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

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

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

void
column::normalize ()
{
  NZ.sort ();
  list_item
    li;
  forall_items (li, NZ)
  {
    while ((NZ.succ (li) != nil) && (NZ[li].Cons == NZ[NZ.succ (li)].Cons))
      {
        NZ[li].coeff += NZ[NZ.succ (li)].coeff;
        NZ.del_item (NZ.succ (li));
      }
  }
}

column
column::operator * (double d)
{
  column_entry
    st;
  list < column_entry > NNZ;
  forall (st, NZ)
  {
    NNZ.append (column_entry (st.Cons, d * st.coeff));
  };
  return column (NNZ);
}

column
column::operator + (column r)
{
  list < column_entry > NNZ;
  list_item
    l1 = r.NZ.first ();
  column_entry
    st;
  double
    d;
  forall (st, NZ)
  {
    d = 0;
    while ((l1 != nil) && (r.NZ[l1].Cons <= st.Cons))
      {
        if (r.NZ[l1].Cons != st.Cons)
          {
            NNZ.append (r.NZ[l1]);
          }
        else
          {
            d = r.NZ[l1].coeff;
          }
        l1 = r.NZ.succ (l1);
      }
    NNZ.append (column_entry (st.Cons, st.coeff + d));
  }
  return column (NNZ);
}

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

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


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


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

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

---