cons_obj.cc

#include<scil/cons_obj.h>
#include<scil/var_obj.h>
#include<scil/row.h>
#include<scil/subproblem.h>
#include<scil/aba_constraint.h>
#include<abacus/row.h>

using namespace SCIL;

cons_obj::cons_obj (cons_sense s, double rhs__)
{
  sense_ = s;
  rhs_ = rhs__;
  Ref_Acons=0;
  qrStatus = CHECK;
};

cons_obj::cons_obj ()
{
  sense_ = Equal;
  rhs_ = 0;
  Ref_Acons=0;
  qrStatus = CHECK;
}

int
cons_obj::genRow (Active_Variables * vars, Row & ro)
{
  row R;
  non_zero_entries(R);

  tr1::unordered_map<var_obj*,double>::const_iterator v;
  foreach( v, CM ){
    R+=var(v->first) * v->second;
  }

  //R.normalize();

  //if(R.undefined()) {
  //  cout<<"Have to implement nonzero\n";
    //return (*Ref_Acons)::ABA_CONSTRAINT->genRow(vars, ro); 
  //}
  int j;
  double rhs1=0;
  ro.realloc(R.size());
  row_entry::list_iterator it;
 
  foreach( it, R ){
    if( it->Var==nil ) {
      j=-1; rhs1+=it->coeff;
    }
    else {
      j=it->Var.var_pointer()->index();
    }
    if( j!=-1 ) {
      ro.insert(j,it->coeff);
    }
  }

  ro.rhs(rhs()+rhs1);
  if(sense_==Equal) ro.sense(ABA_CSENSE::Equal);
  if(sense_==Greater) ro.sense(ABA_CSENSE::Greater);
  if(sense_==Less) ro.sense(ABA_CSENSE::Less);

  return(R.size());

};

double
cons_obj::slack (subproblem & S)
{

  row
    r;
  row_entry::list_constiterator
    it;
  double
    x = 0;
  non_zero_entries (r);
  foreach(it, r)
  {
    x += it->coeff * S.value (it->Var);
  };

  return x - rhs ();
}

bool
cons_obj::violated (subproblem & S)
{
  row
    r;
  row_entry::list_constiterator
    it;
  double
    x = 0;
  non_zero_entries (r);
  foreach (it, r)
  {
    x += it->coeff * S.value (it->Var);
  };

  if (sense () == Equal)
    return fabs (x - rhs ()) > 0.001;
  if (sense () == Less)
    return x - rhs () > 0.001;
  return x - rhs () < -0.001;
}


double
cons_obj::violation (subproblem & S)
{
  row
    r;
  row_entry::list_constiterator
    it;
  double
    x = 0;
  non_zero_entries (r);
  foreach (it, r)
  {
    x += it->coeff * S.value (it->Var);
  };
  if (sense () == Greater)
    return rhs () - x;
  else if( sense() == Less )
     return x - rhs();
  else
    return fabs (x - rhs ());
}


//FIXME
double
cons_obj::violation (solution & S)
{
  row
    r;
  row_entry::list_constiterator
    it;
  double
    x = 0;
  non_zero_entries (r);
  foreach (it, r)
  {
    x += it->coeff * S.value (it->Var);
  };
  if (sense () == Greater)
    return rhs () - x;
  else if( sense() == Less )
     return x - rhs();
  else
    return fabs (x - rhs ());
}

void
cons_obj::init (subproblem & S_, int n, Activation a, Validity v)
{
  Act=a;
  Ref_Acons = new ABA_Constraint (S_, this, a, v, Liftable, n);
}

void
cons_obj::init (ILP_Problem & IP, int n, Activation a, Validity v)
{
  Act=a;
  Ref_Acons = new ABA_Constraint (IP, this, a, v, Liftable, n);
};

void
cons_obj::set_sense (cons_sense s)
{
  /*{\Mop sets the sense of the basic constraint.} */
  sense_ = s;
};


void
cons_obj::set_rhs (double r)
{
  /*{\Mop sets the right-hand side of the basic constraint.} */
  rhs_ = r;
};

Activation cons_obj::get_Act() {
   return Act;
}



ABA_Constraint *
cons_obj::Acons ()
{
  return Ref_Acons;
}


double
cons_obj::rhs ()
{
  /*{\Mop returns the right-hand-side.} */
  return rhs_;
};


cons_sense
cons_obj::sense ()
{
  /*{\Mop retunrs the sense.} */
  return sense_;
}


double
cons_obj::coeff (ABA_VARIABLE * v)
{
  if( CM.find((var_obj*)v) != CM.end() ){
    cout << "set\n";
    return CM[ (var_obj*)v ];
  }
  double
    d = coeff ((var_obj *) v);
  if (d != 0)
    return d;
  return v->coeff (Acons ());
};



void
cons_obj::set (var_obj * v, double d)
{
  CM[v] = d;
}

cons_obj::~cons_obj() {
  if(Ref_Acons!=0) {
    Ref_Acons->Ref_cons=0;
    delete Ref_Acons;
  };
};

---