scil.c

#ifndef SCIL_CPP
#define SCIL_CPP

#include <iostream.h>
#include <scil/scil.h>
#include <scil/subproblem.h>
#include <scil/sym_constraint.h>
#include <cplex.h>

#include <ctype.h>
#include <stdlib.h>

using namespace SCIL;
using namespace LEDA;

#define CPLEX_CONST const

struct ILP_Problem_Data {
  CPXENVptr m_pCPXEnv;
  CPXLPptr m_pCPXLP;
  Optsense m_OptSense;
  int m_NumVars;
  int m_NumCons;
  int m_Status;
  int m_GotSolution;
  double* m_pSolution;
  double* XSOL;

  void* cbdata;
  int wherefrom;

  bool rootcall;

  LEDA::list<sym_constraint*> SL;
  primal_heuristic* primal_heur;
  LEDA::array<var> ItoV;
  solution heur_sol;
  double heur_obj;
};

struct Variable_Data {
  ILP_Problem* m_pILP;
  int Index;
};

struct Basic_Constraint_Data {
  ILP_Problem* m_pILP;
  int Index;
};

/**************************************/
/* ILP_Problem member implementations */
/**************************************/

<<<<<<< scil.c
void dumpmatrix(ILP_Problem& IP) {
  //int *pnzcnt;
  //int *rmatbeg;
  //int *rmatind;
  //double *rmatval;
  //int rmatspace;
  //int *psurplus;
  int numrows, numcols;
  int rowcnt, colcnt;
  //int index;

  numrows = CPXgetnumrows(((ILP_Problem_Data*) IP.DATA)->m_pCPXEnv, ((ILP_Problem_Data*) IP.DATA)->m_pCPXLP);
  numcols = CPXgetnumcols(((ILP_Problem_Data*) IP.DATA)->m_pCPXEnv, ((ILP_Problem_Data*) IP.DATA)->m_pCPXLP);

  cout << "Matrix has " << numrows << " rows and " << numcols << " columns" << endl;

  double coef;

  for (rowcnt = 0; rowcnt < numrows; rowcnt++) {
    for (colcnt = 0; colcnt < numcols; colcnt++) {
      CPXgetcoef (((ILP_Problem_Data*) IP.DATA)->m_pCPXEnv, ((ILP_Problem_Data*) IP.DATA)->m_pCPXLP, rowcnt, colcnt, &coef);
      cout << coef << " ";
    }
    cout << endl;
  }

}

/*
void ILP_Problem::ReportCPLEXError(char* Where, char* What, int status) {
  char buffer[1024];
  cout << "Error in " << Where << ":" << endl;
  cout << What << endl;
  CPXgeterrorstring (m_pCPXEnv, status, buffer);
  cout << buffer << endl;
}
*/

subproblem* GlobalS=NULL;

int scil_row_size_without_constant(const row& r) {
    int o=0;
    if(r.NZ.head().Var==NULL) o=1;
    return r.NZ.size()-o;
}

double scil_row_const_part(const row& r) {
  if(r.NZ.head().Var==NULL) return r.NZ.head().Coeff;
  return 0;
};
=======
subproblem* GlobalS=NULL;

int scil_row_size_without_constant(const row& r) {
    int o=0;
    if(r.NZ.head().Var==nil) o=1;
    return r.NZ.size()-o;
}

double scil_row_const_part(const row& r) {
  if(r.NZ.head().Var==nil) return r.NZ.head().Coeff;
  return 0;
};
>>>>>>> 1.3

static int CPXPUBLIC
mycutcallback (CPLEX_CONST cpxenv* env,
               void      *cbdata,
               int       wherefrom,
               void      *cbhandle,
               int       *useraction_p)
{
  cout<<"Separation\n";

  int i;
  double d;
  CPXgetcallbackinfo(env, cbdata, wherefrom, 
                     CPX_CALLBACK_INFO_NODE_COUNT, &i);

  cout<<i<<" nodes ";

  CPXgetcallbackinfo(env, cbdata, wherefrom, 
                     CPX_CALLBACK_INFO_NODES_LEFT, &i);

  cout<<i<<" left ";

  CPXgetcallbacknodeobjval(env, cbdata, wherefrom, &d);

  cout<<d<<" curnode ";

  CPXgetcallbackinfo(env, cbdata, wherefrom, 
                     CPX_CALLBACK_INFO_BEST_INTEGER, &d);

  cout<<d<<" bestsol ";

  CPXgetcallbackinfo(env, cbdata, wherefrom, 
                     CPX_CALLBACK_INFO_BEST_REMAINING, &d);

  cout<<d<<" nodeleft\n";

  ILP_Problem* IP=static_cast<ILP_Problem *>(cbhandle);

<<<<<<< scil.c
  //dumpmatrix(*IP);

  //IP->cutcallback(env,cbdata,wherefrom);
  CPXgetcallbacknodex(env, cbdata, wherefrom, 
    ((ILP_Problem_Data*) IP->DATA)->XSOL, 0, 
    ((ILP_Problem_Data*) IP->DATA)->m_NumVars-1);
=======
  //IP->cutcallback(env,cbdata,wherefrom);
  int status = CPXgetcallbacknodex(env, cbdata, wherefrom, 
    ((ILP_Problem_Data*) IP->DATA)->XSOL, 0, 
    ((ILP_Problem_Data*) IP->DATA)->m_NumVars-1);
>>>>>>> 1.3

  int nc=0;

<<<<<<< scil.c
  GlobalS->ILP=IP;

  //cout<<env<<"hier\n";

  ((ILP_Problem_Data*) IP->DATA)->wherefrom=wherefrom;
  ((ILP_Problem_Data*) IP->DATA)->cbdata=cbdata;
  //((ILP_Problem_Data*) IP->DATA)->m_pCPXEnv=env;
=======
  GlobalS->ILP=IP;
>>>>>>> 1.3

  sym_constraint* s;
  sym_constraint::status rs;
<<<<<<< scil.c
  forall (s, ((ILP_Problem_Data*) IP->DATA)->SL)
    if(nc!=-1) {
      //cout<<"2\n";
      rs=s->separate(*GlobalS);
      //cout<<"4\n";
      if (rs == sym_constraint::constraint_found) nc++;
      if (rs == sym_constraint::fathom) nc=-1;
    };
=======
  forall (s, ((ILP_Problem_Data*) IP->DATA)->SL)
    if(nc!=-1) {
      rs=s->separate(*GlobalS);
      if (rs == sym_constraint::constraint_found) nc++;
      if (rs == sym_constraint::fathom) nc=-1;
    };
>>>>>>> 1.3

  if(nc==0) {
    *useraction_p = CPX_CALLBACK_DEFAULT;
    cout<<"NO CUTS\n";
  } else {
    *useraction_p = CPX_CALLBACK_SET;
    cout<<nc<<" CUTS\n";
  }

  return 0;
}

static int CPXPUBLIC
myheurcallback (CPLEX_CONST cpxenv* env,
               void      *cbdata,
               int       wherefrom,
               void      *cbhandle,
               double    *objval_p,
               double    *x,
               int       *checkfeas_p,
               int       *useraction_p)
{
  ILP_Problem* IP=static_cast<ILP_Problem *>(cbhandle);

<<<<<<< scil.c
  //((ILP_Problem_Data*) IP->DATA)->cutcallback(env,cbdata,wherefrom);
  CPXgetcallbacknodex(env, cbdata, wherefrom, ((ILP_Problem_Data*) IP->DATA)->XSOL, 0, ((ILP_Problem_Data*) IP->DATA)->m_NumVars-1);
=======
  //((ILP_Problem_Data*) IP->DATA)->cutcallback(env,cbdata,wherefrom);
  int status = CPXgetcallbacknodex(env, cbdata, wherefrom, ((ILP_Problem_Data*) IP->DATA)->XSOL, 0, ((ILP_Problem_Data*) IP->DATA)->m_NumVars-1);
>>>>>>> 1.3

  GlobalS->ILP=IP;

  if(((ILP_Problem_Data*) IP->DATA)->primal_heur!=0) {
    ((ILP_Problem_Data*) IP->DATA)->primal_heur->heuristic(*GlobalS);
  };
  
  for(int i=0; i<IP->number_of_variables(); i++) x[i]=0;

  double obj=0;
  solution::item i;
  forall_items(i, ((ILP_Problem_Data*) IP->DATA)->heur_sol) {
    x[((ILP_Problem_Data*) IP->DATA)->heur_sol.key(i).getIndex()]=
     ((ILP_Problem_Data*) IP->DATA)->heur_sol.value(((ILP_Problem_Data*) IP->DATA)->heur_sol.key(i));
    obj+=((ILP_Problem_Data*) IP->DATA)->heur_sol.key(i).obj()*((ILP_Problem_Data*) IP->DATA)->heur_sol.value(((ILP_Problem_Data*) IP->DATA)->heur_sol.key(i));
  }

  cout<<obj<<" Heuristic Solution\n";
  *objval_p=obj;

  *checkfeas_p = 1;

  *useraction_p = CPX_CALLBACK_SET;

  return 0;
};


<<<<<<< scil.c
ILP_Problem::ILP_Problem(Optsense sense) {
  DATA=new ILP_Problem_Data;

  if(GlobalS==NULL) 
    GlobalS=new subproblem(this);
=======
ILP_Problem::ILP_Problem(Optsense sense) {
  DATA=new ILP_Problem_Data;
>>>>>>> 1.3

<<<<<<< scil.c
  ((ILP_Problem_Data*) DATA)->ItoV.resize(1000);
=======
  if(GlobalS==NULL) 
    GlobalS=new subproblem(this);

  ((ILP_Problem_Data*) DATA)->ItoV.resize(1000);
>>>>>>> 1.3

  ((ILP_Problem_Data*) DATA)->m_pCPXEnv = NULL;
  ((ILP_Problem_Data*) DATA)->m_pCPXLP = NULL;

  ((ILP_Problem_Data*) DATA)->m_NumVars=0;

  ((ILP_Problem_Data*) DATA)->m_pSolution=0;

  ((ILP_Problem_Data*) DATA)->primal_heur=0;

  ((ILP_Problem_Data*) DATA)->m_OptSense = sense;
 
<<<<<<< scil.c
  ((ILP_Problem_Data*) DATA)->m_GotSolution = 0;

  ((ILP_Problem_Data*) DATA)->m_pCPXEnv = CPXopenCPLEX(&((ILP_Problem_Data*) DATA)->m_Status);
=======
  ((ILP_Problem_Data*) DATA)->m_GotSolution = 0;
>>>>>>> 1.3

<<<<<<< scil.c
  //cout<<((ILP_Problem_Data*) DATA)->m_pCPXEnv<<"envpointer\n";
=======
  ((ILP_Problem_Data*) DATA)->m_pCPXEnv = CPXopenCPLEX(&((ILP_Problem_Data*) DATA)->m_Status);
>>>>>>> 1.3

  /*
  if (m_Status != 0) {
    ReportCPLEXError ("ILP_Problem::ILP_Problem", 
                      "Failed to open CPLEX environment", 
                      m_Status);
    return;
  }
  */

  ((ILP_Problem_Data*) DATA)->m_pCPXLP = CPXcreateprob(((ILP_Problem_Data*) DATA)->m_pCPXEnv, &((ILP_Problem_Data*) DATA)->m_Status, "scil_lp");

  /*
  if (m_Status != 0) {
    ReportCPLEXError ("ILP_Problem::ILP_Problem",
                      "Failed to create CPLEX Problem",
                      m_Status);
    return;
  }
  */

  // default sense for CPLEX LP is min, change that if necessary
  if (sense == Optsense_Max) {
    CPXchgobjsen(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP, CPX_MAX);
  }

  //CPXsetintparam (m_pCPXEnv, CPX_PARAM_MIPCBREDLP, CPX_OFF); 
  //CPXsetintparam (m_pCPXEnv, CPX_PARAM_PRELINEAR, CPX_OFF); 
  CPXsetintparam (((ILP_Problem_Data*) DATA)->m_pCPXEnv, CPX_PARAM_REDUCE, CPX_OFF);

  //CPXsetlpcallbackfunc (m_pCPXEnv, mycutcallback, this);
  CPXsetcutcallbackfunc (((ILP_Problem_Data*) DATA)->m_pCPXEnv, mycutcallback, this);
  
  CPXsetheuristiccallbackfunc (((ILP_Problem_Data*) DATA)->m_pCPXEnv, myheurcallback, this);
}

ILP_Problem::~ILP_Problem() {

  if (((ILP_Problem_Data*) DATA)->m_pCPXLP != NULL) {
    CPXfreeprob(((ILP_Problem_Data*) DATA)->m_pCPXEnv, &((ILP_Problem_Data*) DATA)->m_pCPXLP);

    /*
    if (m_Status != 0) {
      ReportCPLEXError ("ILP_Problem::~ILP_Problem",
                        "Failed to free CPLEX Problem",
                        m_Status);
    }
    */
  }
    
  if (((ILP_Problem_Data*) DATA)->m_pCPXEnv != NULL) {
    
    CPXcloseCPLEX(&((ILP_Problem_Data*) DATA)->m_pCPXEnv);
    
    /*
    if (m_Status != 0) {
      ReportCPLEXError ("ILP_Problem::~ILP_Problem",
                        "Failed to close CPLEX environment",
                        m_Status);
    }
    */
  }
  delete (ILP_Problem_Data*) DATA;
}

var ILP_Problem::add_variable(double obj, double lBound, double uBound,
                              Vartype t, Activation a) {

  var_obj* v = new var_obj(obj, lBound, uBound, t);
  return add_variable(v, a);
}

var ILP_Problem::add_variable(var_obj* v, Activation a) {

  char type = CPX_CONTINUOUS;

  if ((((ILP_Problem_Data*) DATA)->m_pCPXEnv == NULL) || (((ILP_Problem_Data*) DATA)->m_pCPXLP == NULL)) {
    cout << "Error in ILP_Problem::add_variable:" << endl;
    cout << "CPLEX Environment not properly initialized." << endl;
  }

  if (v->type() == Vartype_Integer) {
    if ((v->lower_bound() == 0) && (v->upper_bound() == 1)) {
      type = CPX_BINARY;
    } else {
      type = CPX_INTEGER;
    }
  }

  //cout << "Adding new variable:" << endl << "  Type " << type << endl;
<<<<<<< scil.c
  //cout << "  Objective " << v->objVal << endl;
  //cout << "  Upper " << v->uBound << endl;
  //cout << "  Lower " << v->lBound << endl;

  CPXnewcols(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP, 1, &(v->objVal), &(v->lBound),
                         &(v->uBound), &type, NULL);
  /*
=======
  //cout << "  Objective " << v->m_obj << endl;
  //cout << "  Upper " << v->m_uBound << endl;
  //cout << "  Lower " << v->m_lBound << endl;
  CPXnewcols(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP, 1, &(v->objVal), &(v->lBound),
                         &(v->uBound), &type, NULL);
  /*
>>>>>>> 1.3
  if (m_Status != 0) {
    ReportCPLEXError ("ILP_Problem::add_variable",
                      "Failed to add new column.",
                      m_Status);
    return NULL;
  }
  */
  // new columns are always added at the end of the problem
  // the index of the new column is therefore the current number of cols less 1
  ((Variable_Data*) v->DATA)->Index = CPXgetnumcols(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP) - 1;

  if(v->getIndex()>=((ILP_Problem_Data*) DATA)->ItoV.high()) 
    ((ILP_Problem_Data*) DATA)->ItoV.resize(2*((ILP_Problem_Data*) DATA)->ItoV.high());

  ((ILP_Problem_Data*) DATA)->ItoV[v->getIndex()]=v;

  // tell the variable which ILP it belongs to
  ((Variable_Data*) v->DATA)->m_pILP = this;
  ((ILP_Problem_Data*) DATA)->m_NumVars++;
  return v;
}

cons ILP_Problem::add_basic_constraint(cons_sense s, double rhs,
                                       Activation a) {
  cons_obj* c = new cons_obj(s, rhs);
  return add_basic_constraint(c, a);
}

cons ILP_Problem::add_basic_constraint (cons_obj* rc,
                                        Activation a) {

  if ((((ILP_Problem_Data*) DATA)->m_pCPXEnv == NULL) || (((ILP_Problem_Data*) DATA)->m_pCPXLP == NULL)) {
    cout << "Error in ILP_Problem::add_basic_constraint:" << endl;
    cout << "CPLEX Environment not properly initialized." << endl;
  }

  int rmatbeg;
  int *rmatind;
  double *rmatval;
  double rhs;
  char sense;

  rhs = rc->rhs();

  if (rc->sense() == Equal  ) { sense = 'E'; }
  if (rc->sense() == Less   ) { sense = 'L'; }
  if (rc->sense() == Greater) { sense = 'G'; }

  rmatbeg = 0;

  double d;
<<<<<<< scil.c
  //int nzcnt=rc->non_zero_coefficients (rmatind, rmatval, d);
  row r;
  rc->non_zero_entries(r);

  //cout<<r<<" row\n";

  r.normalize();

  //cout<<r<<" row\n";

  d=-scil_row_const_part(r);

  //cout<<d<<" d\n";

  rmatind=new int[scil_row_size_without_constant(r)];
  rmatval=new double[scil_row_size_without_constant(r)];
  int nzcnt=0;
  row_entry re;
  forall(re, r) if(re.Var!=NULL) {
    rmatind[nzcnt] = re.Var.getIndex();
    rmatval[nzcnt] = re.Coeff;
    nzcnt++;
  } //else cout<<"ERO\n";
=======
  //int nzcnt=rc->non_zero_coefficients (rmatind, rmatval, d);
  row r;
  rc->non_zero_entries(r);
  r.normalize();
  d=scil_row_const_part(r);

  rmatind=new int[scil_row_size_without_constant(r)];
  rmatval=new double[scil_row_size_without_constant(r)];
  int nzcnt=0;
  row_entry re;
  forall(re, r) if(re.Var!=nil) {
    rmatind[nzcnt] = re.Var.getIndex();
    rmatval[nzcnt] = re.Coeff;
    nzcnt++;
  }
>>>>>>> 1.3
  rhs+=d;

/*
  cout << "Adding new basic constraint:" << endl;
  cout << "  Sense " << sense << endl << "  RHS " << rhs << endl;
  cout << "  NumCoeff " << nzcnt << endl;

  for (int count = 0; count < nzcnt; count++) {
    cout << rmatval[count] << "*v" << rmatind[count];
    if (count < nzcnt - 1) { cout << " + "; }
  }
  cout << endl;
*/

  CPXaddrows (((ILP_Problem_Data*) DATA)->m_pCPXEnv, 
              ((ILP_Problem_Data*) DATA)->m_pCPXLP, 0, 1, nzcnt,
              &rhs, &sense, &rmatbeg, rmatind, rmatval, NULL, NULL);

  delete rmatind;
  delete rmatval;

  /*
  if (m_Status != 0) {
    ReportCPLEXError ("ILP_Problem::add_basic_constraint",
                      "Failed to add new row.",
                      m_Status);
    return NULL;
  }
  */

  // new rows are always added at the end of the problem
  // the index of the new row is therefore the current number of rows less 1
  ((Basic_Constraint_Data*) rc->DATA)->Index = 
    CPXgetnumrows(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP) - 1;

  // tell the constraint which ILP it belongs to
  ((Basic_Constraint_Data*) rc->DATA)->m_pILP = this;
  return rc;
}

cons ILP_Problem::add_basic_constraint_sub (cons_obj* rc,
                                        Activation a) {
<<<<<<< scil.c
  //cout<<"hier\n";
  if(((ILP_Problem_Data*) DATA)->rootcall==true) {
=======

  if(((ILP_Problem_Data*) DATA)->rootcall==true) {
>>>>>>> 1.3
    //cout<<"init add constr\n";
    return add_basic_constraint(rc,a);
  };

  //cout<<"add a usual constr\n";
  int rmatbeg;
  int *rmatind;
  double *rmatval;
  double rhs;
  char sense;

  rhs = rc->rhs();

  if (rc->sense() == Equal  ) { sense = 'E'; }
  if (rc->sense() == Less   ) { sense = 'L'; }
  if (rc->sense() == Greater) { sense = 'G'; }

  rmatbeg = 0;

  double d;
<<<<<<< scil.c
  //int nzcnt=rc->non_zero_coefficients (rmatind, rmatval, d);
  row r;
  rc->non_zero_entries(r);
  r.normalize();
  d=scil_row_const_part(r);

  rmatind=new int[scil_row_size_without_constant(r)];
  rmatval=new double[scil_row_size_without_constant(r)];
  //cout<<scil_row_size_without_constant(r)<<" size\n";
  int nzcnt=0;
  row_entry re;
  forall(re, r) if(re.Var!=NULL) {
    //cout<<nzcnt<<" "<<re.Coeff<<" "<<re.Var.getIndex()<<" count\n";
    rmatind[nzcnt] = re.Var.getIndex();
    rmatval[nzcnt] = re.Coeff;
    nzcnt++;
  } //else { cout<<"NIL\n"; };
=======
  //int nzcnt=rc->non_zero_coefficients (rmatind, rmatval, d);
  row r;
  rc->non_zero_entries(r);
  r.normalize();
  d=scil_row_const_part(r);

  rmatind=new int[scil_row_size_without_constant(r)];
  rmatval=new double[scil_row_size_without_constant(r)];
  int nzcnt=0;
  row_entry re;
  forall(re, r) if(re.Var!=nil) {
    rmatind[nzcnt] = re.Var.getIndex();
    rmatval[nzcnt] = re.Coeff;
    nzcnt++;
  }
>>>>>>> 1.3
  rhs+=d;

<<<<<<< scil.c
  //cout<<sense<<" "<<rhs<<" hier\n";
=======
  CPXcutcallbackadd (((ILP_Problem_Data*) DATA)->m_pCPXEnv, 
    ((ILP_Problem_Data*) DATA)->cbdata, ((ILP_Problem_Data*) DATA)->wherefrom, 
                     nzcnt, rhs, sense, rmatind, rmatval);
>>>>>>> 1.3

  CPXcutcallbackadd (((ILP_Problem_Data*) DATA)->m_pCPXEnv, 
    ((ILP_Problem_Data*) DATA)->cbdata, ((ILP_Problem_Data*) DATA)->wherefrom, 
                     nzcnt, rhs, sense, rmatind, rmatval);

  //cout<<"nbas\n";
  delete rmatind;
  delete rmatval;

    // new rows are always added at the end of the problem
  // the index of the new row is therefore the current number of rows less 1
  ((Basic_Constraint_Data*) rc->DATA)->Index = CPXgetnumrows(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP) - 1;

  // tell the constraint which ILP it belongs to
<<<<<<< scil.c
  ((Basic_Constraint_Data*) rc->DATA)->m_pILP = this;
  //cout<<"edhnd\n";
=======
  ((Basic_Constraint_Data*) rc->DATA)->m_pILP = this;
>>>>>>> 1.3
  return rc;
}


void ILP_Problem::optimize() {
  cout<< "Init sym constraints\n";

  ((ILP_Problem_Data*) DATA)->rootcall=true;

  GlobalS->ILP=this;

  sym_constraint* s;
  forall (s, ((ILP_Problem_Data*) DATA)->SL) {
    s->init(*GlobalS);
  }

  ((ILP_Problem_Data*) DATA)->rootcall=false;
  cout << "Optimizing problem" << endl;

  ((ILP_Problem_Data*) DATA)->XSOL=new double[((ILP_Problem_Data*) DATA)->m_NumVars];

  CPXmipopt (((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP);

  /*
  if (m_Status != 0) {
    ReportCPLEXError ("ILP_Problem::optimize",
                      "Failed to calculate optimal solution",
                      m_Status);
    return;
  }
  */

<<<<<<< scil.c
  int numcols = CPXgetnumcols(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP);
=======
  int numcols = CPXgetnumcols(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP);
  int lpstat;
>>>>>>> 1.3
  double objval;

  if (((ILP_Problem_Data*) DATA)->m_pSolution) { delete ((ILP_Problem_Data*) DATA)->m_pSolution; }

  ((ILP_Problem_Data*) DATA)->m_pSolution = new double[numcols];

  cout << "Retrieving solution" << endl;
  CPXgetmipx (((ILP_Problem_Data*) DATA)->m_pCPXEnv, 
              ((ILP_Problem_Data*) DATA)->m_pCPXLP, 
              ((ILP_Problem_Data*) DATA)->m_pSolution, 0, 
              numcols-1);

  /*
  if (m_Status != 0) {
    ReportCPLEXError ("ILP_Problem::optimize",
                      "Failed to retrieve solution",
                      m_Status);
    return;
  }
  */

  CPXgetmipobjval (((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP, &objval);

  ((ILP_Problem_Data*) DATA)->m_GotSolution = 1;
  cout << "Solution status: " << CPXgetstat(((ILP_Problem_Data*) DATA)->m_pCPXEnv, ((ILP_Problem_Data*) DATA)->m_pCPXLP) << endl << "Objective value: " << objval << endl;
}

double ILP_Problem::get_solution (const var& v) {
  if (!((ILP_Problem_Data*) DATA)->m_GotSolution) { return 0; } // no solution yet! (exception?)

  //  if (v.m_pVarObj->m_pILP != this) { return 0; }
  // this var does not even belong to this problem (exception?)

<<<<<<< scil.c
  if(v==NULL) return 1;
  return ((ILP_Problem_Data*) DATA)->m_pSolution[v.getIndex()];
=======
  if(v==nil) return 1;
  return ((ILP_Problem_Data*) DATA)->m_pSolution[v.getIndex()];
>>>>>>> 1.3
}

double ILP_Problem::get_solution(const row& r) {
  row_entry re;
  double d=0;
  forall(re, r) {
    d+=re.Coeff*get_solution(re.Var);
  };
  return d;
};

<<<<<<< scil.c

double subproblem::value (const var& v) {
  if(v==NULL) return 1;
=======

double subproblem::value (const var& v) {
  if(v==nil) return 1;
>>>>>>> 1.3
  //if(XSOL[v.getIndex()]>0.001) cout<<XSOL[v.getIndex()]<<endl;
  return ((ILP_Problem_Data*) ILP->DATA)->XSOL[v.getIndex()];
}

double subproblem::value(const row& r) {
  row_entry re;
  double d=0;
  forall(re, r) {
    d+=re.Coeff*value(re.Var);
  };
  return d;
};

<<<<<<< scil.c
int ILP_Problem::number_of_variables() {
  return ((ILP_Problem_Data*) DATA)->m_NumVars;
};

=======
int ILP_Problem::number_of_variables() {
  return ((ILP_Problem_Data*) DATA)->m_NumVars;
};

/*
void ILP_Problem::dumpmatrix() {
  int *pnzcnt;
  int *rmatbeg;
  int *rmatind;
  double *rmatval;
  int rmatspace;
  int *psurplus;
  int numrows, numcols;
  int rowcnt, colcnt;
  int index;

  numrows = CPXgetnumrows(m_pCPXEnv, m_pCPXLP);
  numcols = CPXgetnumcols(m_pCPXEnv, m_pCPXLP);

  cout << "Matrix has " << numrows << " rows and " << numcols << " columns" << endl;

  double coef;

  for (rowcnt = 0; rowcnt < numrows; rowcnt++) {
    for (colcnt = 0; colcnt < numcols; colcnt++) {
      m_Status = CPXgetcoef (m_pCPXEnv, m_pCPXLP, rowcnt, colcnt, &coef);
      if (m_Status != 0) {
        ReportCPLEXError ("ILP_Problem::dumpmatrix",
                          "Failed to retrieve matrix coefficient",
                          m_Status);
        return;
      }
      cout << coef << " ";
    }
    cout << endl;
  }

}

void ILP_Problem::ReportCPLEXError(char* Where, char* What, int status) {
  char buffer[1024];
  cout << "Error in " << Where << ":" << endl;
  cout << What << endl;
  CPXgeterrorstring (m_pCPXEnv, status, buffer);
  cout << buffer << endl;
}
*/
>>>>>>> 1.3

/******************************/
/* var member implementations */
/* and operator overloads     */
/******************************/

// two vars are equal only if they have the same column index AND
// belong to the same problem instance 
bool var::operator== (const var& v) const {
  if ((m_pVarObj == NULL) || (v.m_pVarObj == NULL)) {
    return m_pVarObj == v.m_pVarObj;
  }
  return (((Variable_Data*) m_pVarObj->DATA)->Index == ((Variable_Data*) v.m_pVarObj->DATA)->Index)
    && (((Variable_Data*) m_pVarObj->DATA)->m_pILP == ((Variable_Data*) v.m_pVarObj->DATA)->m_pILP);
}

row var::operator+ (const row& r) const {
  return row(*this)+r;
}

row var::operator- (const row& r) const {
  return row(*this)-r;
}

row var::operator* (double d) const {
  return row(*this)*d;
}

bool var::operator!= (const var& v) const {
  return !operator==(v);
}

bool var::operator< (const var& v) const {
  if (m_pVarObj == NULL) {
    return v.m_pVarObj != NULL;
  }
  if (v.m_pVarObj == NULL) {
    return false;
  }
  return ((Variable_Data*) m_pVarObj->DATA)->Index < ((Variable_Data*) v.m_pVarObj->DATA)->Index;
}

bool var::operator> (const var& v) const {
  if (v.m_pVarObj == NULL) {
    return m_pVarObj != NULL;
  }
  if (m_pVarObj == NULL) {
    return false;
  }
  return ((Variable_Data*) m_pVarObj->DATA)->Index > ((Variable_Data*) v.m_pVarObj->DATA)->Index;
}

bool var::operator<= (const var& v) const {
  if (m_pVarObj == NULL) {
    return true;
  }
  if (v.m_pVarObj == NULL) {
    return false;
  }
  return ((Variable_Data*) m_pVarObj->DATA)->Index <= ((Variable_Data*) v.m_pVarObj->DATA)->Index;
}

bool var::operator>= (const var& v) const {
  if (v.m_pVarObj == NULL) {
    return true;
  }
  if (m_pVarObj == NULL) {
    return false;
  }
  return ((Variable_Data*) m_pVarObj->DATA)->Index >= ((Variable_Data*) v.m_pVarObj->DATA)->Index;
}

int SCIL::compare(const var& t1, const var& t2) {
  if (t1<t2) return -1;
  if (t1>t2) return 1;
  return 0;
}

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

/****************************/
/* row_entry / column_entry */
/****************************/

row_entry::row_entry(var v, double d) {
  Var = v;
  Coeff = d;
}

int SCIL::compare(const row_entry& t1, const row_entry& t2) {
  return compare(t1.Var, t2.Var);
}

/*
column_entry::column_entry(cons c, double d) {
  m_cons = c;
  m_coeff = d;
}
*/

/******************************/
/* row member implementations */
/* and operator overloads     */
/******************************/

row row::operator* (double d) const {
  row_entry it;
  list<row_entry> newNZ;

  forall(it, NZ) {
    newNZ.append(row_entry(it.Var, d*it.Coeff)); 
  }

  //cout<<NZ.size()<<" Mult\n";
  return row(newNZ);
}

int row::size() {
  return NZ.size();
};

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

row row::operator+ (double d) const {
  return operator+(row(d));
}

/*
row SCIL::operator+ (double d, row r) const {
  return r+d;
}
*/

row row::operator+ (const var& v) const {
  return operator+(row(v));
}

row row::operator+ (const row& r) const {
  list<row_entry> newNZ;
  list_item item = r.first_item();
  row_entry re;
  double d;

  forall(re, NZ) {
    d = 0;
<<<<<<< scil.c
    while ((item != NULL) && (!(r.NZ[item].Var > re.Var))) {
      if (r.NZ[item].Var != re.Var) {
        //cout<<r.NZ[item]<<" coef1\n";
        newNZ.append(r.NZ[item]);
=======
    while ((item != NULL) && (!(r.NZ[item].Var > re.Var))) {
      if (r.NZ[item].Var != re.Var) {
        newNZ.append(r.NZ[item]);
>>>>>>> 1.3
      } else {
        d = r.NZ[item].Coeff;
      }
      item = r.NZ.succ(item);
    }
<<<<<<< scil.c
    //cout<<re.Var<<" "<<re.Coeff+d<<" Coeff\n";
    newNZ.append(row_entry(re.Var, re.Coeff + d));
=======
    newNZ.append(row_entry(re.Var, re.Coeff + d));
>>>>>>> 1.3
  }
  
  while (item != NULL) {
    newNZ.append(r.NZ[item]);
    item = r.NZ.succ(item);
  }
  return row(newNZ);
}

row row::operator- (const row& r) const {
  return operator+((-1)*r);
}

void row::normalize() {
  int count, len;
  NZ.sort();
  list_item li;
  count = 1;
  forall_items (li, NZ) {
    while ((count < NZ.length()) &&
           (NZ[li].Var == NZ[NZ.succ(li)].Var)) {
      NZ[li].Coeff += NZ[NZ.succ(li)].Coeff;
      len = NZ.length();
      NZ.del_item(NZ.succ(li));
      if (len == NZ.length()) {
        cout << "row::normalize error: list does not shrink - this should never happen" << endl;
        NZ[NZ.succ(li)].Var = NULL;
      }
    }
    count++;
  }
/*
  row_entry re;
  forall(re, NZ) cout<<re<<" ";
  cout<<"HIERROW\n";
*/
}

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

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

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

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

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

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

ostream& SCIL::operator<<(ostream& o,const row& r) {
  list_item li;

  li = r.first_item();
  while (li) {
    o << r.inf(li);
    li = r.next_item(li);
    if (li) { o << ","; }
  }
  return o<<"\n";
}

int SCIL::Hash(var v) { 
  return LEDA::Hash(v.m_pVarObj); 
}

int SCIL::ID_Number(const var & v) {
  return LEDA::ID_Number(v.m_pVarObj);
}

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

<<<<<<< scil.c
row& row::operator+= (const row_entry& re) {
  NZ.append(re);
  return *this;
}


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

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

row::row(list<row_entry>& L) {
  NZ=L;
/*
  row_entry re;
  forall(re, NZ) cout<<re<<" ";
  cout<<"DAROW\n";
*/
}

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


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

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

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

>>>>>>> 1.3
row& row::operator-= (const row& r) {
  row_entry st;
<<<<<<< scil.c
  forall(st, r.NZ) {
    NZ.append(row_entry(st.Var, -st.Coeff));
    //cout<<st.Var<<" "<<st.Coeff<<"-=\n";
=======
  forall(st, r.NZ) {
    NZ.append(row_entry(st.Var, -st.Coeff));
>>>>>>> 1.3
  }
  return *this;
}

var subproblem::add_continous_variable(double d1, double d2, double d3, Activation) {
  cout<<"ERROR\n";
  return NULL;
};

var subproblem::add_integer_variable(double, int, int, Activation) {
  cout<<"ERROR\n";
  return NULL;
};

var subproblem::add_binary_variable(double, Activation) {
  cout<<"ERROR\n";
  return NULL;
};

var subproblem::add_variable(var_obj*, Activation) {
  cout<<"ERROR\n";
  return NULL;
};

var subproblem::add_variable(double, double, double, Vartype, Activation) {
  cout<<"ERROR\n";
  return NULL;
};

cons subproblem::add_basic_constraint(cons_sense c, double r, Activation a) {
  return ILP->add_basic_constraint_sub(new cons_obj(c,r), a);
};


cons subproblem::add_basic_constraint(cons_obj* c, Activation a) {
  return ILP->add_basic_constraint_sub(c, a);
};

double subproblem::get_solution(const var& v) {
  return ILP->get_solution(v);
};

double subproblem::get_solution(const row& r) {
  return ILP->get_solution(r);
};

void subproblem::add_sym_constraint(sym_constraint* sc) {
  ILP->add_sym_constraint(sc);
};

subproblem::~subproblem() {
};

double subproblem::value(cons) {
  cout<<"ERROR\n";
  return 0;
};

bool subproblem::found_constraint() {
  cout<<"ERROR\n";
  return false;
};

double subproblem::get_obj_value() {
  cout<<"ERROR\n";
  return 0;
};

/*
bool cons_obj::violated(subproblem& s) {
  row r;
  non_zero_entries(r);

  row_entry re;
  double d=0;
  forall(re, r) {
    d+=re.m_coeff*s.value(re.m_var);
  }

  // TODO violation epsilon
  if((sense()==Equal) && (fabs(d-rhs())>0.01)) return true;
  if((sense()==Less) && (d>rhs()+0.01)) return true;
  if((sense()==Greater) && (d<rhs()-0.01)) return true;
  return false;
};
*/

/*
int cons_obj::non_zero_coefficients (int *&rmatind , double *&rmatval, double& d) {
  row r;
  non_zero_entries(r);
  r.normalize();
  d=r.const_part();

  rmatind=new int[r.size_without_constant()];
  rmatval=new double[r.size_without_constant()];
  int count=0;
  row_entry re;
  forall(re, r) if(re.m_var!=NULL) {
    rmatind[count] = re.m_var.getIndex();
    rmatval[count] = re.m_coeff;
    count++;
  }
  return count;
}
*/

void subproblem::save_solution(solution& s) {
<<<<<<< scil.c
  ILP->save_solution(s);
};

cons_obj::cons_obj() {
  DATA=new Basic_Constraint_Data;
  ((Basic_Constraint_Data*) DATA)->Index=-1;
  ((Basic_Constraint_Data*) DATA)->m_pILP=NULL;
};

cons_obj::cons_obj(cons_sense s, double rhs) {
  DATA=new Basic_Constraint_Data;  
  m_rhs   = rhs;
  m_sense = s;
  ((Basic_Constraint_Data*) DATA)->Index=-1;
  ((Basic_Constraint_Data*) DATA)->m_pILP=NULL;
};

cons_obj::~cons_obj() {
  delete (Basic_Constraint_Data*) DATA;
}

void ILP_Problem::add_sym_constraint(sym_constraint* c) {
  ((ILP_Problem_Data*) DATA)->SL.append(c);
};

void ILP_Problem::save_solution(solution& s) { 
  ((ILP_Problem_Data*) DATA)->heur_sol=s;
  ((ILP_Problem_Data*) DATA)->heur_obj=1;
};


var_obj::var_obj() {
  DATA=new Variable_Data;
  ((Variable_Data*) DATA)->Index   = -1;
  ((Variable_Data*) DATA)->m_pILP    = NULL;
  objVal     = 0;
  lBound  = 0;
  uBound  = 0;
  vt = Vartype_Integer;
}

var_obj::var_obj(double obj, double lBound_, double uBound_, Vartype vt_) {
  DATA=new Variable_Data;
  ((Variable_Data*) DATA)->Index   = -1;
  ((Variable_Data*) DATA)->m_pILP    = NULL;
  objVal     = obj;
  lBound  = lBound_;
  uBound  = uBound_;
  vt = vt_;
}

var_obj::~var_obj() {
  delete (Variable_Data*) DATA;
};

double var_obj::obj() const {
  return objVal;
};

double var_obj::lower_bound() const {
  return lBound;
};

double var_obj::upper_bound() const {
  return uBound;
};

Vartype var_obj::type() const {
  return vt;
};

int var_obj::getIndex() const { 
  return ((Variable_Data*) DATA)->Index; 
}

void solution::save_solution(subproblem& s) {
  var v;
  sp=&s;
  forall_variables(v, s) {
    if(s.value(v)!=0) {
      S[v]=s.value(v);
    }
  }
};

subproblem* solution::originating_subproblem() {
  return sp;
};

void solution::round_to_integer(var v) {
  S[v]=floor(S[v]+0.5);
};

double solution::value(var v) {
  return S[v];
};

double solution::value(row& r) {
  row_entry re;
  double d=0;
  forall(re, r) d+=re.Coeff*value(re.Var);
  return d;
};

subproblem::subproblem(ILP_Problem*) {};

LEDA::list_item row::first_item() const {
  return NZ.first();
}

LEDA::list_item row::next_item(const LEDA::list_item item) const {
  return NZ.succ(item);
}

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

row_constraint::row_constraint (row& r, cons_sense s) :
  NZV(r.size()), NZC(r.size()) {
  
  row_entry re;
  int idx = 0;
  
  forall (re, r.NZ) {
    NZV[idx]   = re.Var;
    NZC[idx] = re.Coeff;
    idx++;
    //cout<<re<<" ";
  }
  //cout<<"ROWCONSTR\n";
  set_sense(s);
  set_rhs(0);
}

double row_constraint::rhs() {
  if (NZV[0] == NULL) return -NZC[0];
  return 0;
}

void row_constraint::non_zero_entries(row& r) 
{
  for(int i=0; i<=NZC.high(); i++) {
    //if(NZV[i]!=NULL) 
    r+=row_entry(NZV[i],NZC[i]);
  }
}

row_constraint::~row_constraint() {
};

ostream& SCIL::operator<<(ostream& o,const row_entry& re) {
  return o<<"("<<re.Var<<","<<re.Coeff<<")";
}

istream& SCIL::operator>>(istream& i,const row_entry&) { return i; };

ostream& SCIL::operator<<(ostream& o,const column_entry&) { return o; };

istream& SCIL::operator>>(istream& i,const column_entry&) { return i; };


//TODO implement
subproblem::var_item subproblem::first_variable_item() {
  cout<<"ERROR\n";
  return 0;
};

subproblem::var_item subproblem::next_variable_item(var_item) {
  cout<<"ERROR\n";
  return 0;
};

var subproblem::get_variable(var_item) {
  cout<<"ERROR\n";
  return NULL;
};

subproblem::sc_item subproblem::first_sym_constraint_item() {
  cout<<"ERROR\n";
  return 0;
};

subproblem::sc_item subproblem::next_sym_constraint_item(sc_item) { 
  cout<<"ERROR\n";
  return 0;
};

sym_constraint* subproblem::get_sym_constraint(sc_item) {
  cout<<"ERROR\n";
  return NULL;
};

double cons_obj::slack(subproblem& s) {
  row r;
  non_zero_entries(r);
  row_entry re;
  double d=rhs();
  forall(re,r) {
    d-=re.Coeff*s.value(re.Var);
  };
  if(sense()==Equal) return fabs(d);
  if(sense()==Less) return -d;
  return d;
=======
  ILP->save_solution(s);
};

cons_obj::cons_obj() {
  DATA=new Basic_Constraint_Data;
  ((Basic_Constraint_Data*) DATA)->Index=-1;
  ((Basic_Constraint_Data*) DATA)->m_pILP=NULL;
};

cons_obj::cons_obj(cons_sense s, double rhs) {
  DATA=new Basic_Constraint_Data;  
  m_rhs   = rhs;
  m_sense = s;
  ((Basic_Constraint_Data*) DATA)->Index=-1;
  ((Basic_Constraint_Data*) DATA)->m_pILP=NULL;
};

cons_obj::~cons_obj() {
  delete (Basic_Constraint_Data*) DATA;
}

void ILP_Problem::add_sym_constraint(sym_constraint* c) {
  ((ILP_Problem_Data*) DATA)->SL.append(c);
};

void ILP_Problem::save_solution(solution& s) { 
  ((ILP_Problem_Data*) DATA)->heur_sol=s;
  ((ILP_Problem_Data*) DATA)->heur_obj=1;
};


var_obj::var_obj() {
  DATA=new Variable_Data;
  ((Variable_Data*) DATA)->Index   = -1;
  ((Variable_Data*) DATA)->m_pILP    = NULL;
  objVal     = 0;
  lBound  = 0;
  uBound  = 0;
  vt = Vartype_Integer;
}

var_obj::var_obj(double obj, double lBound, double uBound, Vartype vt_) {
  DATA=new Variable_Data;
  ((Variable_Data*) DATA)->Index   = -1;
  ((Variable_Data*) DATA)->m_pILP    = NULL;
  objVal     = obj;
  lBound  = lBound;
  uBound  = uBound;
  vt = vt_;
}

var_obj::~var_obj() {
  delete (Variable_Data*) DATA;
};

double var_obj::obj() const {
  return objVal;
};

double var_obj::lower_bound() const {
  return lBound;
};

double var_obj::upper_bound() const {
  return uBound;
};

Vartype var_obj::type() const {
  return vt;
};

int var_obj::getIndex() const { 
  return ((Variable_Data*) DATA)->Index; 
}

void solution::save_solution(subproblem& s) {
  var v;
  sp=&s;
  forall_variables(v, s) {
    if(s.value(v)!=0) {
      S[v]=s.value(v);
    }
  }
};

subproblem* solution::originating_subproblem() {
  return sp;
};

void solution::round_to_integer(var v) {
  S[v]=floor(S[v]+0.5);
};

double solution::value(var v) {
  return S[v];
};

double solution::value(row& r) {
  row_entry re;
  double d=0;
  forall(re, r) d+=re.Coeff*value(re.Var);
  return d;
};

subproblem::subproblem(ILP_Problem*) {};

LEDA::list_item row::first_item() const {
  return NZ.first();
}

LEDA::list_item row::next_item(const LEDA::list_item item) const {
  return NZ.succ(item);
}

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

row_constraint::row_constraint (row& r, cons_sense s) :
  NZV(r.size()), NZC(r.size()) {
  
  row_entry re;
  int idx = 0;
  
  forall (re, r.NZ) {
    NZV[idx]   = re.Var;
    NZC[idx] = re.Coeff;
    idx++;
  }
  set_sense(s);
  set_rhs(0);
}

double row_constraint::rhs() {
  if (NZV[0] == nil) return -NZC[0];
  return 0;
}

void row_constraint::non_zero_entries(row& r) 
{
  for(int i=0; i<=NZC.high(); i++) {
    if(NZV[i]!=nil) r+=row_entry(NZV[i],NZC[i]);
  }
}

row_constraint::~row_constraint() {
};

ostream& SCIL::operator<<(ostream& o,const row_entry& re) {
  return o<<"("<<re.Var<<","<<re.Coeff<<")";
}

istream& SCIL::operator>>(istream& i,const row_entry&) { return i; };

ostream& SCIL::operator<<(ostream& o,const column_entry&) { return o; };

istream& SCIL::operator>>(istream& i,const column_entry&) { return i; };


//TODO implement
subproblem::var_item subproblem::first_variable_item() {
};

subproblem::var_item subproblem::next_variable_item(var_item) {
};

var subproblem::get_variable(var_item) {
};

subproblem::sc_item subproblem::first_sym_constraint_item() {
};

subproblem::sc_item subproblem::next_sym_constraint_item(sc_item) { 
};

sym_constraint* subproblem::get_sym_constraint(sc_item) {
};

double cons_obj::slack(subproblem& s) {
  row r;
  non_zero_entries(r);
  row_entry re;
  double d=rhs();
  forall(re,r) {
    d-=re.Coeff*s.value(re.Var);
  };
  if(sense()==Equal) return fabs(d);
  if(sense()==Less) return -d;
  return d;
>>>>>>> 1.3
};

#endif // SCIL_CPP

---