MsProcessor.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURMSPROCESSOR_H
#define MINOTAURMSPROCESSOR_H
 
#include "NodeProcessor.h"
#include "Types.h"
 
namespace Minotaur {
 
  class Engine;
  class Problem;
  class Solution;
  typedef const Solution* ConstSolutionPtr;
 
  struct MBPStats {
    UInt bra;    
    UInt inf;    
    UInt opt;    
    UInt prob;   
    UInt proc;   
    UInt ub;     
  };
 
  class MsProcessor : public NodeProcessor {
 
  public:
    MsProcessor(EnvPtr env);
 
    MsProcessor(EnvPtr env, EnginePtr engine, HandlerVector handlers_);
 
    ~MsProcessor();
 
    // True if a new solution was found while processing this node.
    bool foundNewSolution(); 
 
    // Find branches that will be used to branch at this node.
    Branches getBranches();
 
    // Get warm-start information.
    WarmStartPtr getWarmStart();
 
    // Implement NodeProcessor::process().
    void process(NodePtr node, RelaxationPtr rel, 
                 SolutionPoolPtr s_pool);
 
    // Get a corner of the variable space box randomly
    double* getBoxCorner(UInt n, RelaxationPtr rel1, 
                         int threadid, int K);
 
    // Get a corner of the variable space box randomly
    double* getFarBoxCorner(UInt n, RelaxationPtr rel1, 
                            int threadid, double* prev_opt, int K);
 
 
    // Generate a random starting point within variable bounds (for relaxations)
    double* getStartPointScheme1(UInt n, RelaxationPtr rel1);
 
    double* getStartPointScheme2(UInt n, RelaxationPtr rel1, int threadid,
                                 double radius, int numsols, 
                                 double* prev_start_point);
 
    double* getStartPointScheme4(UInt n, RelaxationPtr rel1, int threadid,
                                 double radius, int numsols, 
                                 double* prev_start_point, 
                                 double* prev_opt, double costhetalim);
 
    double* getStartPointScheme5(UInt n, RelaxationPtr rel1, int threadid, 
                                 double radius, double* prev_start_point,
                                 double* prev_opt, int K, double lambda);
 
    //double* getStartPointScheme6(UInt n, RelaxationPtr rel1, int threadid,
                                 //double radius, int numsols, 
                                 //double* prev_start_point,
                                 //double* prev_opt, int K, double lambda);
 
    // Generate initial point based on variable fixing
    double* genInitialPoint(UInt n, RelaxationPtr rel);
 
    // Calculating inner product of two vectors
    double InnerProduct(double b[], double c[], UInt n);
 
    // Calculating Euclidean norm
    double ENorm(double b[], UInt n);
 
    // Calculate the Euclidean distance between two vectors
    double EDist(double b[], double c[], UInt n);
 
    // Testing parallelism
    void par();           
 
    // write statistics. Base class method.
    void writeStats(std::ostream &out) const; 
 
    // write statistics. Base class method.
    void writeStats() const; 
 
  protected:
 
    std::stack<Modification *> relMods_;
 
    Branches branches_;
 
    bool contOnErr_;
 
    double cutOff_;
 
    EnginePtr engine_;
 
    EngineStatus engineStatus_;
 
    EnvPtr env_;
 
    HandlerVector handlers_;
 
    LoggerPtr logger_;
 
    static const std::string me_;
 
    UInt numSolutions_;
 
    UInt numRestarts_;
 
    UInt numThreads_;
 
    RelaxationPtr relaxation_;
 
    UInt schemeId_;
 
    MBPStats stats_;
 
    WarmStartPtr ws_;
 
    virtual bool isFeasible_(NodePtr node, ConstSolutionPtr sol, 
                             SolutionPoolPtr s_pool, bool &should_prune);
 
    virtual void solveRelaxation_();
 
    virtual void solveRelaxation_(EnginePtr e1);
 
 
    virtual bool shouldPrune_(NodePtr node, double solval, 
                              SolutionPoolPtr s_pool);
 
  };
 
  typedef MsProcessor* MsProcessorPtr;
 
}
#endif