AlpsKnowledgeBrokerSerial.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Abstract Library for Parallel Search (ALPS).     *
 *                                                                           *
 * ALPS is distributed under the Eclipse Public License as part of the       *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           * 
 *                                                                           *
 * Copyright (C) 2001-2013, Lehigh University, Yan Xu, and Ted Ralphs.       *
 *===========================================================================*/

#ifndef AlpsKnowledgeBrokerSerial_h_
#define AlpsKnowledgeBrokerSerial_h_

#include "Alps.h"
#include "AlpsEnumProcessT.h"
#include "AlpsKnowledgeBroker.h"
#include "AlpsMessage.h"
#include "AlpsModel.h"
#include "AlpsParams.h"

//#############################################################################

class AlpsKnowledgeBrokerSerial : public AlpsKnowledgeBroker {
 private:
    AlpsKnowledgeBrokerSerial(const AlpsKnowledgeBrokerSerial&);
    AlpsKnowledgeBrokerSerial& operator=(const AlpsKnowledgeBrokerSerial&);

 public:
    AlpsKnowledgeBrokerSerial() 
    : 
    AlpsKnowledgeBroker() 
    {} 

    AlpsKnowledgeBrokerSerial(AlpsModel& model) 
    : 
    AlpsKnowledgeBroker() 
    {
        initializeSearch(0, NULL, model); 
    }   

    AlpsKnowledgeBrokerSerial(int argc, 
                  char* argv[], 
                  AlpsModel& model) 
    : 
    AlpsKnowledgeBroker() 
    { 
        initializeSearch(argc, argv, model); 
    }


    virtual ~AlpsKnowledgeBrokerSerial() {}

    //-------------------------------------------------------------------------

    virtual void searchLog();
    
    virtual double getIncumbentValue() const {
    return getBestQuality();
    }

    virtual double getBestQuality() const {
    if (AlpsKnowledgeBroker::hasKnowledge(AlpsKnowledgeTypeSolution)) {
        return getBestKnowledge(AlpsKnowledgeTypeSolution).second;
        }
    else {
        return ALPS_INC_MAX;
        }
    }

    virtual void printBestSolution(char* outputFile = 0) const {

    if (msgLevel_ < 1) return;
    
    if (getNumKnowledges(AlpsKnowledgeTypeSolution) <= 0) {
        std::cout << "\nALPS did not find a solution."
              << std::endl;
        return;
    }
    if (outputFile != 0) {                 
            // Write to outputFile
        std::ofstream os(outputFile);
        os << "============================================" << std::endl;
        if (getSolStatus() == AlpsExitStatusOptimal) {
        os << "Optimal solution:" << std::endl;
        }
        else {
        os << "Best solution found:" << std::endl;
        }
        os << "Cost = " << getBestQuality();
        os << std::endl;
        dynamic_cast<AlpsSolution* >
        (getBestKnowledge(AlpsKnowledgeTypeSolution).first)->print(os);
    }
    else {                                  // Write to std::cout
        std::cout << "============================================" << std::endl;
        if (getSolStatus() == AlpsExitStatusOptimal) {
        std::cout << "Optimal solution:" << std::endl;
        }
        else {
        std::cout << "Best solution found:" << std::endl;
        }
        std::cout << "Cost = " << getBestQuality();
        std::cout << std::endl;
        dynamic_cast<AlpsSolution* >
        (getBestKnowledge(AlpsKnowledgeTypeSolution).first)->print(std::cout);
        std::cout << "============================================" << std::endl;
    }
    }

    virtual void initializeSearch(int argc, 
                                  char* argv[], 
                                  AlpsModel& model);
    
    virtual void rootSearch(AlpsTreeNode* root);
    
};
#endif