RMOL Logo Get Revenue Management Optimisation Library at SourceForge.net. Fast, secure and Free Open Source software downloads

RMOL_Service.cpp

Go to the documentation of this file.
00001 // //////////////////////////////////////////////////////////////////////
00002 // Import section
00003 // //////////////////////////////////////////////////////////////////////
00004 // C
00005 #include <assert.h>
00006 // STL
00007 #include <iomanip>
00008 // RMOL
00009 #include <rmol/basic/BasConst_RMOL_Service.hpp>
00010 #include <rmol/field/FldYieldRange.hpp>
00011 #include <rmol/field/FldDistributionParameters.hpp>
00012 #include <rmol/bom/Demand.hpp>
00013 #include <rmol/bom/Bucket.hpp>
00014 #include <rmol/bom/BucketHolder.hpp>
00015 #include <rmol/factory/FacRmolServiceContext.hpp>
00016 #include <rmol/command/Optimiser.hpp>
00017 #include <rmol/service/RMOL_ServiceContext.hpp>
00018 #include <rmol/service/Logger.hpp>
00019 #include <rmol/RMOL_Service.hpp>
00020 
00021 namespace RMOL {
00022 
00023   // //////////////////////////////////////////////////////////////////////
00024   RMOL_Service::RMOL_Service () :
00025     _rmolServiceContext (NULL) {
00026   }
00027 
00028   // //////////////////////////////////////////////////////////////////////
00029   RMOL_Service::RMOL_Service (const RMOL_Service& iService) :
00030     _rmolServiceContext (iService._rmolServiceContext) {
00031   }
00032 
00033   // //////////////////////////////////////////////////////////////////////
00034   RMOL_Service::RMOL_Service (std::ostream& ioLogStream,
00035                               const ResourceCapacity_T iResourceCapacity) {
00036     // Initialise the context
00037     init (ioLogStream, iResourceCapacity);
00038   }
00039 
00040   // //////////////////////////////////////////////////////////////////////
00041   RMOL_Service::~RMOL_Service () {
00042   }
00043 
00044   // //////////////////////////////////////////////////////////////////////
00045   void RMOL_Service::init (std::ostream& ioLogStream,
00046                            const ResourceCapacity_T iResourceCapacity) {
00047     // Set the log file
00048     logInit (LOG::DEBUG, ioLogStream);
00049 
00050     // Initialise the context
00051     RMOL_ServiceContext& lRMOL_ServiceContext = 
00052       FacRmolServiceContext::instance().create (iResourceCapacity);
00053     _rmolServiceContext = &lRMOL_ServiceContext;
00054   }
00055   
00056   // //////////////////////////////////////////////////////////////////////
00057   void RMOL_Service::logInit (const LOG::EN_LogLevel iLogLevel,
00058                               std::ostream& ioLogOutputFile) {
00059     Logger::instance().setLogParameters (iLogLevel, ioLogOutputFile);
00060   }
00061 
00062   // //////////////////////////////////////////////////////////////////////
00063   void RMOL_Service::addBucket (const double iYieldRange, 
00064                                 const double iDemandMean,
00065                                 const double iDemandStandardDev) {
00066     assert (_rmolServiceContext != NULL);
00067     _rmolServiceContext->addBucket (iYieldRange, iDemandMean,
00068                                     iDemandStandardDev);
00069   }
00070 
00071   // //////////////////////////////////////////////////////////////////////
00072   void RMOL_Service::readFromInputFile (const std::string& iInputFileName) {
00073     assert (_rmolServiceContext != NULL);
00074     _rmolServiceContext->readFromInputFile (iInputFileName);
00075   }
00076 
00077   // //////////////////////////////////////////////////////////////////////
00078   void RMOL_Service::
00079   optimalOptimisationByMCIntegration (const int K) {
00080     
00081     assert (_rmolServiceContext != NULL);
00082     const double iCapacity = _rmolServiceContext->getCapacity();
00083     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00084     assert (ioBucketHolder_ptr != NULL);
00085 
00086     Optimiser::optimalOptimisationByMCIntegration (K, iCapacity, 
00087                                                    *ioBucketHolder_ptr);
00088 
00089     // DEBUG
00090     RMOL_LOG_DEBUG (ioBucketHolder_ptr->display());
00091   }
00092 
00093   // //////////////////////////////////////////////////////////////////////
00094   void RMOL_Service::
00095   optimalOptimisationByMCIntegration(const int K,
00096                                      BookingLimitVector_T& ioBookingLimitVector){
00097     
00098     assert (_rmolServiceContext != NULL);
00099     const double iCapacity = _rmolServiceContext->getCapacity();
00100     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00101     assert (ioBucketHolder_ptr != NULL);
00102 
00103     Optimiser::optimalOptimisationByMCIntegration (K, iCapacity, 
00104                                                    *ioBucketHolder_ptr);
00105 
00106     // Fill up booking vector
00107     ioBucketHolder_ptr->fillup (ioBookingLimitVector);
00108   }
00109 
00110   // //////////////////////////////////////////////////////////////////////
00111   void RMOL_Service::
00112   optimalOptimisationByDP () {
00113     
00114     assert (_rmolServiceContext != NULL);
00115     const double iCapacity = _rmolServiceContext->getCapacity();
00116     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00117     assert (ioBucketHolder_ptr != NULL);
00118 
00119     Optimiser::optimalOptimisationByDP (iCapacity, *ioBucketHolder_ptr);
00120 
00121     // DEBUG
00122     RMOL_LOG_DEBUG (ioBucketHolder_ptr->display());
00123   }
00124 
00125   // //////////////////////////////////////////////////////////////////////
00126   void RMOL_Service::
00127   optimalOptimisationByDP (BookingLimitVector_T& ioBookingLimitVector) {
00128     
00129     assert (_rmolServiceContext != NULL);
00130     const double iCapacity = _rmolServiceContext->getCapacity();
00131     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00132     assert (ioBucketHolder_ptr != NULL);
00133 
00134     Optimiser::optimalOptimisationByDP (iCapacity, *ioBucketHolder_ptr);
00135 
00136     // Fill up booking vector
00137     ioBucketHolder_ptr->fillup (ioBookingLimitVector);
00138   }
00139   
00140   // //////////////////////////////////////////////////////////////////////
00141   void RMOL_Service::heuristicOptimisationByEmsr () {
00142     assert (_rmolServiceContext != NULL);
00143     const double iCapacity = _rmolServiceContext->getCapacity();
00144     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00145     assert (ioBucketHolder_ptr != NULL);
00146     BidPriceVector_T lBidPriceVector;
00147 
00148     Optimiser::heuristicOptimisationByEmsr (iCapacity, *ioBucketHolder_ptr,
00149                                             lBidPriceVector);
00150 
00151     // DEBUG
00152     RMOL_LOG_DEBUG (ioBucketHolder_ptr->display());
00153     
00154     // std::cout << "Bid-Price Vector (BPV): ";
00155     unsigned int size = lBidPriceVector.size();
00156 
00157     // for (unsigned int i = 0; i < size; ++i) {
00158       // const double bidPrice = lBidPriceVector.at(i);
00159       // std::cout << std::fixed << std::setprecision (2) << bidPrice << " ";
00160     // }
00161     // std::cout << std::endl;
00162   }
00163 
00164   // //////////////////////////////////////////////////////////////////////
00165   void RMOL_Service::
00166   heuristicOptimisationByEmsr (BidPriceVector_T& ioBidPriceVector,
00167                                BookingLimitVector_T& ioBookingLimitVector) {
00168     assert (_rmolServiceContext != NULL);
00169     const double iCapacity = _rmolServiceContext->getCapacity();
00170     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00171     assert (ioBucketHolder_ptr != NULL);
00172 
00173     Optimiser::heuristicOptimisationByEmsr (iCapacity, *ioBucketHolder_ptr,
00174                                             ioBidPriceVector);
00175 
00176     // Update the booking limit vector.
00177     for (ioBucketHolder_ptr->begin(); ioBucketHolder_ptr->hasNotReachedEnd();
00178          ioBucketHolder_ptr->iterate()) {
00179       Bucket& currentBucket = ioBucketHolder_ptr->getCurrentBucket();
00180       const double lBookingLimit = currentBucket.getCumulatedBookingLimit();
00181       ioBookingLimitVector.push_back (lBookingLimit);
00182     }
00183     
00184   }
00185 
00186   // //////////////////////////////////////////////////////////////////////
00187   void RMOL_Service::heuristicOptimisationByEmsrA () {
00188     assert (_rmolServiceContext != NULL);
00189     const double iCapacity = _rmolServiceContext->getCapacity();
00190     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00191     assert (ioBucketHolder_ptr != NULL);
00192 
00193     Optimiser::heuristicOptimisationByEmsrA (iCapacity, *ioBucketHolder_ptr);
00194 
00195     // DEBUG
00196     RMOL_LOG_DEBUG (ioBucketHolder_ptr->display());
00197   }
00198 
00199   // //////////////////////////////////////////////////////////////////////
00200   void RMOL_Service::
00201   heuristicOptimisationByEmsrA (BookingLimitVector_T& ioBookingLimitVector) {
00202     assert (_rmolServiceContext != NULL);
00203     const double iCapacity = _rmolServiceContext->getCapacity();
00204     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00205     assert (ioBucketHolder_ptr != NULL);
00206 
00207     Optimiser::heuristicOptimisationByEmsrA (iCapacity, *ioBucketHolder_ptr);
00208 
00209     // Fill up booking vector
00210     ioBucketHolder_ptr->fillup (ioBookingLimitVector);
00211   }
00212   
00213   // //////////////////////////////////////////////////////////////////////
00214   void RMOL_Service::heuristicOptimisationByEmsrB () {
00215     assert (_rmolServiceContext != NULL);
00216     const double iCapacity = _rmolServiceContext->getCapacity();
00217     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00218     assert (ioBucketHolder_ptr != NULL);
00219 
00220     Optimiser::heuristicOptimisationByEmsrB (iCapacity, *ioBucketHolder_ptr);
00221 
00222     // DEBUG
00223     RMOL_LOG_DEBUG (ioBucketHolder_ptr->display());
00224   }
00225 
00226   // //////////////////////////////////////////////////////////////////////
00227   void RMOL_Service::
00228   heuristicOptimisationByEmsrB (BookingLimitVector_T& ioBookingLimitVector) {
00229     assert (_rmolServiceContext != NULL);
00230     const double iCapacity = _rmolServiceContext->getCapacity();
00231     BucketHolder* ioBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00232     assert (ioBucketHolder_ptr != NULL);
00233 
00234     Optimiser::heuristicOptimisationByEmsrB (iCapacity, *ioBucketHolder_ptr);
00235 
00236     // Fill up booking vector
00237     ioBucketHolder_ptr->fillup (ioBookingLimitVector);
00238   }
00239   
00240 }
SourceForge Logo

Generated on Fri Sep 11 06:32:00 2009 for RMOL by Doxygen 1.5.8