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;
};

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

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

  var_obj* v;
  forall_defined(v, CM) {
    R+=var(v)*CM[v];
  }

  //R.normalize();

  //if(R.undefined()) {
  //  cout<<"Have to implement nonzero\n";
    //return (*Ref_Acons)::ABA_CONSTRAINT->genRow(vars, ro); 
  //}
  row_entry t;
  int j;
  double rhs1=0;
  ro.realloc(R.size());
  forall(t, R) {
    if(t.Var==nil) { j=-1; rhs1+=t.coeff; } else
    j=t.Var.var_pointer()->index();
    if (j!=-1) ro.insert(j, t.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
    t;
  double
    x = 0;
  non_zero_entries (r);
  forall (t, r)
  {
    x += t.coeff * S.value (t.Var);
  };

  return x - rhs ();
}

bool
cons_obj::violated (subproblem & S)
{
  row
    r;
  row_entry
    t;
  double
    x = 0;
  non_zero_entries (r);
  forall (t, r)
  {
    x += t.coeff * S.value (t.Var);
  };

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


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

void
cons_obj::init (ILP_Problem & IP, int n, Activation a)
{
  Act=a;
  Ref_Acons = new ABA_Constraint (IP, this, a, Global, 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;
};

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.defined ((var_obj *) v))
    {
      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;
  };
};

---