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 #include <sstream>
00009 #include <iostream>
00010 // RMOL
00011 #include <rmol/basic/BasConst_RMOL_Service.hpp>
00012 #include <rmol/field/FldYieldRange.hpp>
00013 #include <rmol/field/FldDistributionParameters.hpp>
00014 #include <rmol/bom/Demand.hpp>
00015 #include <rmol/bom/Bucket.hpp>
00016 #include <rmol/bom/BucketHolder.hpp>
00017 #include <rmol/bom/StudyStatManager.hpp>
00018 #include <rmol/factory/FacRmolServiceContext.hpp>
00019 #include <rmol/command/Optimiser.hpp>
00020 #include <rmol/service/RMOL_ServiceContext.hpp>
00021 #include <rmol/service/Logger.hpp>
00022 #include <rmol/RMOL_Service.hpp>
00023 
00024 namespace RMOL {
00025 
00026   // //////////////////////////////////////////////////////////////////////
00027   RMOL_Service::RMOL_Service () :
00028     _rmolServiceContext (NULL) {
00029   }
00030 
00031   // //////////////////////////////////////////////////////////////////////
00032   RMOL_Service::RMOL_Service (const RMOL_Service& iService) :
00033     _rmolServiceContext (iService._rmolServiceContext) {
00034   }
00035 
00036   // //////////////////////////////////////////////////////////////////////
00037   RMOL_Service::RMOL_Service (std::ostream& ioLogStream,
00038                               const ResourceCapacity_T iResourceCapacity) {
00039     // Initialise the context
00040     init (ioLogStream, iResourceCapacity);
00041   }
00042 
00043   // //////////////////////////////////////////////////////////////////////
00044   RMOL_Service::~RMOL_Service () {
00045   }
00046 
00047   // //////////////////////////////////////////////////////////////////////
00048   void RMOL_Service::init (std::ostream& ioLogStream,
00049                            const ResourceCapacity_T iResourceCapacity) {
00050     // Set the log file
00051     logInit (LOG::DEBUG, ioLogStream);
00052 
00053     // Initialise the context
00054     RMOL_ServiceContext& lRMOL_ServiceContext = 
00055       FacRmolServiceContext::instance().create (iResourceCapacity);
00056     _rmolServiceContext = &lRMOL_ServiceContext;
00057   }
00058   
00059   // //////////////////////////////////////////////////////////////////////
00060   void RMOL_Service::logInit (const LOG::EN_LogLevel iLogLevel,
00061                               std::ostream& ioLogOutputFile) {
00062     Logger::instance().setLogParameters (iLogLevel, ioLogOutputFile);
00063   }
00064 
00065   // //////////////////////////////////////////////////////////////////////
00066   void RMOL_Service::setUpStudyStatManager () {
00067     assert (_rmolServiceContext != NULL);
00068     _rmolServiceContext->setUpStudyStatManager ();
00069   }
00070 
00071   // //////////////////////////////////////////////////////////////////////
00072   void RMOL_Service::
00073   setResourceCapacity (const ResourceCapacity_T iResourceCapacity) {
00074     assert (_rmolServiceContext != NULL);
00075     _rmolServiceContext->setResourceCapacity (iResourceCapacity);
00076   }
00077 
00078   // //////////////////////////////////////////////////////////////////////
00079   void RMOL_Service::addBucket (const double iYieldRange, 
00080                                 const double iDemandMean,
00081                                 const double iDemandStandardDev) {
00082     assert (_rmolServiceContext != NULL);
00083     _rmolServiceContext->addBucket (iYieldRange, iDemandMean,
00084                                     iDemandStandardDev);
00085   }
00086 
00087   // //////////////////////////////////////////////////////////////////////
00088   void RMOL_Service::addBucket(const double iYieldRange, 
00089                                const double iDemandMean,
00090                                const double iDemandStandardDev,
00091                                GeneratedDemandVector_T* ioGeneratedDemandVector){
00092     assert (_rmolServiceContext != NULL);
00093     _rmolServiceContext->addBucket (iYieldRange, iDemandMean,
00094                                     iDemandStandardDev, ioGeneratedDemandVector);
00095   }
00096 
00097   // //////////////////////////////////////////////////////////////////////
00098   GeneratedDemandVector_T* RMOL_Service::
00099   generateDemand (const int K, const double& iMean, const double& iDeviation) {
00100     return _rmolServiceContext->generateDemand (K, iMean, iDeviation);
00101   }
00102 
00103   // //////////////////////////////////////////////////////////////////////
00104   GeneratedDemandVector_T* RMOL_Service::
00105   generateDemand (GeneratedDemandVector_T* ioFirstVector,
00106                   GeneratedDemandVector_T* ioSecondVector) {
00107     return _rmolServiceContext->generateDemand (ioFirstVector, ioSecondVector);
00108   }
00109 
00110   // //////////////////////////////////////////////////////////////////////
00111   void RMOL_Service::readFromInputFile (const std::string& iInputFileName) {
00112     assert (_rmolServiceContext != NULL);
00113     _rmolServiceContext->readFromInputFile (iInputFileName);
00114   }
00115 
00116   // //////////////////////////////////////////////////////////////////////
00117   void RMOL_Service::buildContextForMC (const int K) {
00118     assert (_rmolServiceContext != NULL);
00119     _rmolServiceContext->buildContextForMC (K);
00120   }
00121 
00122   // //////////////////////////////////////////////////////////////////////
00123   void RMOL_Service::reset () {
00124     assert (_rmolServiceContext != NULL);
00125     _rmolServiceContext->reset ();
00126   }
00127   
00128   // //////////////////////////////////////////////////////////////////////
00129   void RMOL_Service::
00130   optimalOptimisationByMCIntegration (const int K) {
00131     
00132     assert (_rmolServiceContext != NULL);
00133     const double iCapacity = _rmolServiceContext->getCapacity();
00134     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00135     assert (oBucketHolder_ptr != NULL);
00136     BidPriceVector_T lBidPriceVector;
00137 
00138     StudyStatManager* lStudyStatManager_ptr =
00139       _rmolServiceContext->getStudyStatManager();
00140 
00141     if (lStudyStatManager_ptr == NULL) {
00142       Optimiser::optimalOptimisationByMCIntegration (K, iCapacity, 
00143                                                      *oBucketHolder_ptr,
00144                                                      lBidPriceVector);
00145     } else {
00146       Optimiser::optimalOptimisationByMCIntegration (K, iCapacity, 
00147                                                      *oBucketHolder_ptr,
00148                                                      lBidPriceVector,
00149                                                      *lStudyStatManager_ptr);
00150     }
00151     // DEBUG
00152     RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00153 
00154     std::ostringstream logStream;
00155     logStream << "Bid-Price Vector (BPV): ";
00156     unsigned int size = lBidPriceVector.size();
00157     
00158     for (unsigned int i = 0; i < size; ++i) {
00159       const double bidPrice = lBidPriceVector.at(i);
00160       logStream << std::fixed << std::setprecision (2) << bidPrice << " ";
00161     }
00162     RMOL_LOG_DEBUG (logStream.str());
00163 
00164     if (lStudyStatManager_ptr != NULL) {
00165       RMOL_LOG_DEBUG (lStudyStatManager_ptr->describe());
00166     }
00167   }
00168 
00169   // //////////////////////////////////////////////////////////////////////
00170   void RMOL_Service::
00171   optimalOptimisationByMCIntegration(const int K,
00172                                      BidPriceVector_T& ioBidPriceVector,
00173                                      BookingLimitVector_T& ioBookingLimitVector){
00174     
00175     assert (_rmolServiceContext != NULL);
00176     const double iCapacity = _rmolServiceContext->getCapacity();
00177     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00178     assert (oBucketHolder_ptr != NULL);
00179 
00180     Optimiser::optimalOptimisationByMCIntegration (K, iCapacity, 
00181                                                    *oBucketHolder_ptr,
00182                                                    ioBidPriceVector);
00183 
00184     // Fill up booking vector
00185     oBucketHolder_ptr->fillup (ioBookingLimitVector);
00186   }
00187 
00188   // //////////////////////////////////////////////////////////////////////
00189   void RMOL_Service::
00190   optimalOptimisationByDP () {
00191     
00192     assert (_rmolServiceContext != NULL);
00193     const double iCapacity = _rmolServiceContext->getCapacity();
00194     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00195     assert (oBucketHolder_ptr != NULL);
00196 
00197     Optimiser::optimalOptimisationByDP (iCapacity, *oBucketHolder_ptr);
00198 
00199     // DEBUG
00200     RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00201   }
00202 
00203   // //////////////////////////////////////////////////////////////////////
00204   void RMOL_Service::
00205   optimalOptimisationByDP (BookingLimitVector_T& ioBookingLimitVector) {
00206     
00207     assert (_rmolServiceContext != NULL);
00208     const double iCapacity = _rmolServiceContext->getCapacity();
00209     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00210     assert (oBucketHolder_ptr != NULL);
00211 
00212     Optimiser::optimalOptimisationByDP (iCapacity, *oBucketHolder_ptr);
00213 
00214     // Fill up booking vector
00215     oBucketHolder_ptr->fillup (ioBookingLimitVector);
00216   }
00217   
00218   // //////////////////////////////////////////////////////////////////////
00219   void RMOL_Service::heuristicOptimisationByEmsr () {
00220     assert (_rmolServiceContext != NULL);
00221     const double iCapacity = _rmolServiceContext->getCapacity();
00222     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00223     assert (oBucketHolder_ptr != NULL);
00224     BidPriceVector_T lBidPriceVector;
00225     
00226     StudyStatManager* lStudyStatManager_ptr =
00227       _rmolServiceContext->getStudyStatManager();
00228     
00229     if (lStudyStatManager_ptr == NULL) {
00230       Optimiser::heuristicOptimisationByEmsr (iCapacity, *oBucketHolder_ptr,
00231                                               lBidPriceVector);
00232     } else {      
00233       Optimiser::heuristicOptimisationByEmsr (iCapacity, *oBucketHolder_ptr,
00234                                               lBidPriceVector,
00235                                               *lStudyStatManager_ptr);
00236     }
00237     
00238     // DEBUG
00239     RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00240     std::ostringstream logStream;
00241     logStream << "Bid-Price Vector (BPV): ";
00242     unsigned int size = lBidPriceVector.size();
00243     
00244     for (unsigned int i = 0; i < size; ++i) {
00245       const double bidPrice = lBidPriceVector.at(i);
00246       logStream << std::fixed << std::setprecision (2) << bidPrice << " ";
00247     }
00248     RMOL_LOG_DEBUG (logStream.str());
00249 
00250     if (lStudyStatManager_ptr != NULL) {
00251       RMOL_LOG_DEBUG (lStudyStatManager_ptr->describe());
00252     }
00253   }
00254 
00255   // //////////////////////////////////////////////////////////////////////
00256   void RMOL_Service::
00257   heuristicOptimisationByEmsr (BidPriceVector_T& ioBidPriceVector,
00258                                BookingLimitVector_T& ioBookingLimitVector) {
00259     assert (_rmolServiceContext != NULL);
00260     const double iCapacity = _rmolServiceContext->getCapacity();
00261     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00262     assert (oBucketHolder_ptr != NULL);
00263 
00264     Optimiser::heuristicOptimisationByEmsr (iCapacity, *oBucketHolder_ptr,
00265                                             ioBidPriceVector);
00266 
00267     // Update the booking limit vector.
00268     for (oBucketHolder_ptr->begin(); oBucketHolder_ptr->hasNotReachedEnd();
00269          oBucketHolder_ptr->iterate()) {
00270       Bucket& currentBucket = oBucketHolder_ptr->getCurrentBucket();
00271       const double lBookingLimit = currentBucket.getCumulatedBookingLimit();
00272       ioBookingLimitVector.push_back (lBookingLimit);
00273     }
00274     
00275   }
00276 
00277   // //////////////////////////////////////////////////////////////////////
00278   void RMOL_Service::heuristicOptimisationByEmsrA () {
00279     assert (_rmolServiceContext != NULL);
00280     const double iCapacity = _rmolServiceContext->getCapacity();
00281     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00282     assert (oBucketHolder_ptr != NULL);
00283 
00284     Optimiser::heuristicOptimisationByEmsrA (iCapacity, *oBucketHolder_ptr);
00285 
00286     // DEBUG
00287     RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00288   }
00289 
00290   // //////////////////////////////////////////////////////////////////////
00291   void RMOL_Service::
00292   heuristicOptimisationByEmsrA (BidPriceVector_T& ioBidPriceVector,
00293                                 BookingLimitVector_T& ioBookingLimitVector) {
00294     assert (_rmolServiceContext != NULL);
00295     const double iCapacity = _rmolServiceContext->getCapacity();
00296     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00297     assert (oBucketHolder_ptr != NULL);
00298 
00299     Optimiser::heuristicOptimisationByEmsrA (iCapacity, *oBucketHolder_ptr);
00300 
00301     // Fill up booking vector
00302     oBucketHolder_ptr->fillup (ioBookingLimitVector);
00303   }
00304   
00305   // //////////////////////////////////////////////////////////////////////
00306   void RMOL_Service::heuristicOptimisationByEmsrAwithSellup 
00307   (SellupProbabilityVector_T& iSellupProbabilityVector) {
00308 
00309     assert (_rmolServiceContext != NULL);
00310     const double iCapacity = _rmolServiceContext->getCapacity();
00311     BucketHolder* ioBucketHolder_ptr = 
00312       _rmolServiceContext->getBucketHolder();
00313     assert (ioBucketHolder_ptr != NULL);
00314 
00315     Optimiser::
00316       heuristicOptimisationByEmsrAwithSellup (iCapacity, 
00317                                               *ioBucketHolder_ptr,
00318                                               iSellupProbabilityVector);
00319 
00320     // DEBUG
00321     RMOL_LOG_DEBUG (ioBucketHolder_ptr->display());
00322   }
00323 
00324   // //////////////////////////////////////////////////////////////////////
00325   void RMOL_Service::heuristicOptimisationByEmsrAwithSellup 
00326   (SellupProbabilityVector_T& iSellupProbabilityVector,
00327    BidPriceVector_T& ioBidPriceVector,
00328    BookingLimitVector_T& ioBookingLimitVector) {
00329     
00330     assert (_rmolServiceContext != NULL);
00331     const double iCapacity = _rmolServiceContext->getCapacity();
00332     BucketHolder* ioBucketHolder_ptr = 
00333       _rmolServiceContext->getBucketHolder();
00334     assert (ioBucketHolder_ptr != NULL);
00335 
00336     Optimiser::
00337       heuristicOptimisationByEmsrAwithSellup (iCapacity, 
00338                                               *ioBucketHolder_ptr,
00339                                               iSellupProbabilityVector);
00340 
00341     // Fill up booking limit vector
00342     ioBucketHolder_ptr->fillup (ioBookingLimitVector);
00343   }
00344 
00345   // //////////////////////////////////////////////////////////////////////
00346   void RMOL_Service::heuristicOptimisationByEmsrB () {
00347     assert (_rmolServiceContext != NULL);
00348     const double iCapacity = _rmolServiceContext->getCapacity();
00349     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00350     assert (oBucketHolder_ptr != NULL);
00351 
00352     Optimiser::heuristicOptimisationByEmsrB (iCapacity, *oBucketHolder_ptr);
00353 
00354     // DEBUG
00355     RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00356   }
00357 
00358   // //////////////////////////////////////////////////////////////////////
00359   void RMOL_Service::
00360   heuristicOptimisationByEmsrB (BidPriceVector_T& ioBidPriceVector,
00361                                 BookingLimitVector_T& ioBookingLimitVector) {
00362     assert (_rmolServiceContext != NULL);
00363     const double iCapacity = _rmolServiceContext->getCapacity();
00364     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00365     assert (oBucketHolder_ptr != NULL);
00366 
00367     Optimiser::heuristicOptimisationByEmsrB (iCapacity, *oBucketHolder_ptr);
00368 
00369     // Fill up booking vector
00370     oBucketHolder_ptr->fillup (ioBookingLimitVector);
00371   }
00372 
00373   // ///////////////////////////////////////////////////////////////////////
00374   void RMOL_Service:: legOptimisationByMC () {
00375     assert (_rmolServiceContext != NULL);
00376     const ResourceCapacity_T iCapacity = _rmolServiceContext->getCapacity();
00377     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00378     assert (oBucketHolder_ptr != NULL);
00379 
00380     BidPriceVector_T lBidPriceVector;
00381     Optimiser::legOptimisationByMC (iCapacity, *oBucketHolder_ptr,
00382                                     lBidPriceVector);
00383     
00384     // DEBUG
00385     RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00386     std::ostringstream logStream;
00387     logStream << "Bid-Price Vector (BPV): ";
00388     unsigned int size = lBidPriceVector.size();
00389     
00390     for (unsigned int i = 0; i < size; ++i) {
00391       const double bidPrice = lBidPriceVector.at(i);
00392       logStream << std::fixed << std::setprecision (2) << bidPrice << " ";
00393     }
00394     RMOL_LOG_DEBUG (logStream.str());
00395   }
00396 
00397   // ///////////////////////////////////////////////////////////////////////
00398   void RMOL_Service::
00399   legOptimisationByMC (BidPriceVector_T& ioBidPriceVector,
00400                        BookingLimitVector_T& ioBookingLimitVector) {
00401     assert (_rmolServiceContext != NULL);
00402     const ResourceCapacity_T iCapacity = _rmolServiceContext->getCapacity();
00403     BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00404     assert (oBucketHolder_ptr != NULL);
00405     
00406     Optimiser::legOptimisationByMC (iCapacity, *oBucketHolder_ptr,
00407                                     ioBidPriceVector);
00408 
00409     // Fill up booking vector
00410     oBucketHolder_ptr->fillup (ioBookingLimitVector);
00411   }
00412   
00413 }
SourceForge Logo

Generated on Sat Jun 6 13:48:25 2009 for RMOL by Doxygen 1.5.7.1