CouenneBranchingObject.hpp

Go to the documentation of this file.

/* $Id: CouenneBranchingObject.hpp 925 2012-11-27 19:11:04Z stefan $
 *
 * Name:    CouenneBranchingObject.hpp
 * Authors: Pierre Bonami, IBM Corp.
 *          Pietro Belotti, Carnegie Mellon University
 * Purpose: Branching object for auxiliary variables
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNEBRANCHINGOBJECT_HPP
#define COUENNEBRANCHINGOBJECT_HPP

#include "stdio.h"
#include "CouenneExprAux.hpp"
#include "CouenneJournalist.hpp"
#include "OsiBranchingObject.hpp"

namespace Couenne {

class CouenneCutGenerator;
class CouenneProblem;

#define COUENNE_CROP 1
#define COUENNE_LCROP (1e2*COUENNE_CROP)

#define COUENNE_LARGE_INTERVAL 1e4
#define COUENNE_NEAR_BOUND 1e-2


class CouenneBranchingObject: public OsiTwoWayBranchingObject {

public:

  CouenneBranchingObject (OsiSolverInterface *solver,
                          const OsiObject *originalObject,
                          JnlstPtr jnlst, 
                          CouenneCutGenerator *c,
                          CouenneProblem *p,
                          expression *var, 
                          int way, 
                          CouNumber brpoint, 
                          bool doFBBT, 
                          bool doConvCuts);

  CouenneBranchingObject (const CouenneBranchingObject &src):

    OsiTwoWayBranchingObject (src),
    cutGen_       (src.cutGen_),
    problem_      (src.problem_),
    variable_     (src.variable_),
    jnlst_        (src.jnlst_),
    doFBBT_       (src.doFBBT_),
    doConvCuts_   (src.doConvCuts_),
    downEstimate_ (src.downEstimate_),
    upEstimate_   (src.upEstimate_),
    simulate_     (src.simulate_) {}

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

  virtual double branch (OsiSolverInterface * solver = NULL);

  virtual bool boundBranch () const
  {return !doConvCuts_;} // iff it does not add convexification cuts

  void setSimulate (bool s)
  {simulate_ = s;}

  expression *variable ()
  {return variable_;}

  void branchCore (OsiSolverInterface *, int, int, bool, double, t_chg_bounds *&);

  // FIXME: horrible global variables. Brrr.
  static int nOrbBr;
  static int maxDepthOrbBranch;
  static int nSGcomputations;

protected:

  CouenneCutGenerator *cutGen_;

  CouenneProblem *problem_;

  expression *variable_;

  JnlstPtr jnlst_;

  bool doFBBT_;

  bool doConvCuts_;

  double downEstimate_;

  double upEstimate_;

  bool simulate_;
};

}

#endif