BonRegisteredOptions.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines Corporation 2007
//
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Authors :
// Pierre Bonami, Carnegie Mellon University,
//
// Date : 27/08/2007

#ifndef BonRegisteredOptions_H
#define BonRegisteredOptions_H

#include "IpRegOptions.hpp"
#include "IpException.hpp"
#include "CoinError.hpp"
#include "IpTypes.hpp"
#include <iostream>

/* Forward declaration, the function will be defined in BonAmplTMINLP.cpp, if ASL is available */
namespace Ipopt {
  class AmplOptionsList;
}

namespace Bonmin {
class RegisteredOptions: public Ipopt::RegisteredOptions{
  public:
    enum ExtraOptInfosBits{
    validInHybrid=0,
    validInQG,
    validInOA,
    validInBBB,
    validInEcp,
    validIniFP,
    validInCbc
   };


/* Table of values
 * only B-Hyb 1
 * B-Hyb & B-QG 3
 * B-Hyb & B-OA 5
 * B-Hyb & B-QG & B-OA & B-ECP 23
 */



   enum ExtraCategoriesInfo{
    BonminCategory = 0,
    IpoptCategory ,
    FilterCategory ,
    BqpdCategory ,
    CouenneCategory ,
    UndocumentedCategory 
   };
    RegisteredOptions():
       Ipopt::RegisteredOptions(){
    }

    ~RegisteredOptions(){
    }

   //DECLARE_STD_EXCEPTION(OPTION_NOT_REGISTERED); 
   void SetRegisteringCategory (const std::string &registering_category,
                                const ExtraCategoriesInfo extra){
      Ipopt::RegisteredOptions::SetRegisteringCategory(registering_category);
      categoriesInfos_[registering_category] = extra;}
 
   inline void optionExists(const std::string & option){
     if(!IsValid(GetOption(option))){
       std::string msg = "Try to access option: "+option;
       msg += "\n Option is not registered.\n";
       throw CoinError("Bonmin::RegisteredOption","optionExists",msg);
     }
   }

   inline void setOptionExtraInfo(const std::string & option, int code){
      optionExists(option);
      bonOptInfos_[option] = code;
   }

   inline void optionValidForHybrid(const std::string &option){
      optionExists(option);
     bonOptInfos_[option] |= 1 << validInHybrid;}

   inline void optionValidForBQG(const std::string &option){
     optionExists(option);
     bonOptInfos_[option] |= 1 << validInQG;}
   
   inline void optionValidForBOA(const std::string &option){
     optionExists(option);
     bonOptInfos_[option] |= 1 << validInOA;}
   
   inline void optionValidForBBB(const std::string &option){
     optionExists(option);
     bonOptInfos_[option] |= 1 << validInBBB;}
   
   inline void optionValidForBEcp(const std::string &option){
     optionExists(option);
     bonOptInfos_[option] |= 1 << validInEcp;}
   
   inline void optionValidForBiFP(const std::string &option){
     optionExists(option);
     bonOptInfos_[option] |= 1 << validIniFP;}
   
   inline void optionValidForCbc(const std::string &option){
     optionExists(option);
     bonOptInfos_[option] |= 1 << validInCbc;}


   inline bool isValidForHybrid(const std::string &option){
      optionExists(option);
     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
     if(i != bonOptInfos_.end()) 
     return (i->second) & (1 << validInHybrid);
     else return true;}

   inline bool isValidForBQG(const std::string &option){
     optionExists(option);
     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
     if(i != bonOptInfos_.end()) 
       return (i->second) & (1 << validInQG);
     else return true;}
   
   inline bool isValidForBOA(const std::string &option){
     optionExists(option);
     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
     if(i != bonOptInfos_.end()) 
     return (i->second) & (1 << validInOA);
     return true;}
   
   inline bool isValidForBBB(const std::string &option){
     optionExists(option);
     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
     if(i != bonOptInfos_.end()) 
     return (i->second) & (1 << validInBBB);
     return true;}

   
   inline bool isValidForBEcp(const std::string &option){
     optionExists(option);
     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
     if(i != bonOptInfos_.end()) 
     return (i->second) & (1 << validInEcp);
     return true;}

   
   inline bool isValidForBiFP(const std::string &option){
     optionExists(option);
     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
     if(i != bonOptInfos_.end()) 
     return (i->second) & (1 << validIniFP);
     return true;}

   
   inline bool isValidForCbc(const std::string &option){
     optionExists(option);
     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
     if(i != bonOptInfos_.end()) 
     return (i->second) & (1 << validInCbc);
     return true;}


   void writeLatexOptionsTable(std::ostream &of, ExtraCategoriesInfo which);

   void writeHtmlOptionsTable(std::ostream &of, ExtraCategoriesInfo which);


   void writeLatexHtmlDoc(std::ostream &of, ExtraCategoriesInfo which);
  void writeBonminOpt(std::ostream &os, ExtraCategoriesInfo which);

   ExtraCategoriesInfo categoriesInfo(const std::string &s)
   {
      std::map<std::string, ExtraCategoriesInfo>::iterator i = categoriesInfos_.find(s);
      if(i == categoriesInfos_.end())
        return IpoptCategory;
      return i->second;
   }
  
   /* Forward declaration, the function will be defined in BonAmplTMINLP.cpp*/
   void fillAmplOptionList(ExtraCategoriesInfo which, Ipopt::AmplOptionsList * amplOptList);

   private:
   void chooseOptions(ExtraCategoriesInfo which, std::list<Ipopt::RegisteredOption *> &options);
   void writeHtmlOptionsTable(std::ostream & os, std::list<Ipopt::RegisteredOption *> &options);
   std::map<std::string, int> bonOptInfos_;
   std::map<std::string, ExtraCategoriesInfo> categoriesInfos_;
};

}/*Ends namespace Bonmin.*/
#endif