CouenneSOSObject.hpp

Go to the documentation of this file.

/* $Id: CouenneSOSObject.hpp 490 2011-01-14 16:07:12Z pbelotti $
 *
 * Name:    CouenneSOSObject.hpp
 * Authors: Pietro Belotti, Lehigh University
 * Purpose: SOS Object
 *
 * (C) Carnegie-Mellon University, 2008-09.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNESOSOBJECT_HPP
#define COUENNESOSOBJECT_HPP

#include "OsiBranchingObject.hpp"
#include "CouenneJournalist.hpp"

namespace Couenne {

class CouenneProblem;
class CouenneSOSObject;
class exprVar;


// TODO: SOS of the form sum x_i \le k with k small. Instead of
// branching on a single variable do a SOS-like branching

class CouenneSOSBranchingObject: public OsiSOSBranchingObject {

protected:

  CouenneProblem *problem_;

  exprVar *reference_;

  JnlstPtr jnlst_;

  bool doFBBT_;

  bool doConvCuts_;

public:

  // Default Constructor 
  CouenneSOSBranchingObject () {}

  // Useful constructor
  CouenneSOSBranchingObject (CouenneProblem *p,
                             exprVar *ref,
                             OsiSolverInterface *solver,  
                             const OsiSOS *originalObject,
                             int way, 
                             double separator,
                             JnlstPtr jnlst,
                             bool doFBBT,
                             bool doConvCuts):

    OsiSOSBranchingObject (solver, originalObject, way, separator),
    problem_   (p),
    reference_ (ref),
    jnlst_ (jnlst),
    doFBBT_ (doFBBT),
    doConvCuts_ (doConvCuts) {}

  
  // Copy constructor 
  CouenneSOSBranchingObject (const CouenneSOSBranchingObject &src):
    OsiSOSBranchingObject (src),
    problem_    (src.problem_),
    reference_  (src.reference_),
    jnlst_      (src.jnlst_),
    doFBBT_     (src.doFBBT_),
    doConvCuts_ (src.doConvCuts_) {}

   
  virtual OsiBranchingObject * clone() const
  {return new CouenneSOSBranchingObject (*this);}

  virtual double branch (OsiSolverInterface * solver);
};



class CouenneSOSObject: public OsiSOS {

protected:

  CouenneProblem *problem_;

  exprVar *reference_;

  JnlstPtr jnlst_;

  bool doFBBT_;

  bool doConvCuts_;

public:

  CouenneSOSObject (OsiSolverInterface *solver, int nelem, int *indices, double *weights, int type,
                    CouenneProblem *problem,
                    exprVar *ref,
                    JnlstPtr jnlst,
                    bool doFBBT,
                    bool doConvCuts):

    OsiSOS      (solver, nelem, indices, weights, type),
    problem_    (problem),
    reference_  (ref),
    jnlst_      (jnlst),
    doFBBT_     (doFBBT),
    doConvCuts_ (doConvCuts) {}


  CouenneSOSObject (const CouenneSOSObject &src):
    OsiSOS      (src),
    problem_    (src.problem_),
    reference_  (src.reference_),
    jnlst_      (src.jnlst_),
    doFBBT_     (src.doFBBT_),
    doConvCuts_ (src.doConvCuts_) {}
    
  virtual OsiObject * clone () const
  {return new CouenneSOSObject (*this);}

  OsiBranchingObject *createBranch (OsiSolverInterface* si, 
                                    const OsiBranchingInformation* info, int way) const;

  //exprVar *Reference () const
  //{return reference_;}
};

}

#endif