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

Optimiser.cpp

Go to the documentation of this file.
00001 // //////////////////////////////////////////////////////////////////////
00002 // Import section
00003 // //////////////////////////////////////////////////////////////////////
00004 // C
00005 #include <assert.h>
00006 // STL
00007 //#include <cmath>
00008 #include <sstream>
00009 #include <iomanip>
00010 // RMOL
00011 #include <rmol/basic/BasChronometer.hpp>
00012 #include <rmol/field/FldYieldRange.hpp>
00013 #include <rmol/field/FldDistributionParameters.hpp>
00014 #include <rmol/bom/StudyStatManager.hpp>
00015 #include <rmol/bom/BucketHolder.hpp>
00016 //#include <rmol/bom/Resource.hpp>
00017 #include <rmol/bom/MCOptimiser.hpp>
00018 #include <rmol/bom/Emsr.hpp>
00019 #include <rmol/bom/DPOptimiser.hpp>
00020 #include <rmol/factory/FacPartialSumHolder.hpp>
00021 #include <rmol/factory/FacPartialSumHolderHolder.hpp>
00022 #include <rmol/factory/FacDemand.hpp>
00023 #include <rmol/factory/FacBucket.hpp>
00024 #include <rmol/command/Optimiser.hpp>
00025 #include <rmol/service/Logger.hpp>
00026 
00027 namespace RMOL {
00028 
00029   // //////////////////////////////////////////////////////////////////////
00030   void Optimiser::
00031   optimalOptimisationByMCIntegration (const int K, 
00032                                       const ResourceCapacity_T iCabinCapacity,
00033                                       BucketHolder& ioBucketHolder,
00034                                       BidPriceVector_T& ioBidPriceVector) {
00035     // Retrieve the BucketHolder
00036     // BucketHolder& ioBucketHolder = ioResource.getBucketHolder();
00037 
00038     // Number of classes/buckets: n
00039     const short nbOfClasses = ioBucketHolder.getSize();
00040 
00041     // Create a holder for the list of Partial Sum Lists
00042     PartialSumHolderHolder& aPartialSumHolderHolder =
00043       FacPartialSumHolderHolder::instance().create();
00044 
00051     for (short j = 0 ; j <= nbOfClasses; ++j) {
00052       PartialSumHolder& aPartialSumList = 
00053         FacPartialSumHolder::instance().create ();
00054 
00055       FacPartialSumHolderHolder::instance().
00056         addPartialSumHolder (aPartialSumHolderHolder, aPartialSumList);
00057     }
00058 
00059     // Call the class performing the actual algorithm
00060     MCOptimiser::optimalOptimisationByMCIntegration (K, iCabinCapacity, 
00061                                                      ioBucketHolder,
00062                                                      aPartialSumHolderHolder,
00063                                                      ioBidPriceVector);
00064   }
00065 
00066   // //////////////////////////////////////////////////////////////////////
00067   void Optimiser::
00068   optimalOptimisationByMCIntegration (const int K, 
00069                                       const ResourceCapacity_T iCabinCapacity,
00070                                       BucketHolder& ioBucketHolder,
00071                                       BidPriceVector_T& ioBidPriceVector,
00072                                       StudyStatManager& ioStudyStatManager) {
00073     BasChronometer lMCIntegrationBasChrono;
00074     lMCIntegrationBasChrono.start();
00075     // Retrieve the BucketHolder
00076     // BucketHolder& ioBucketHolder = ioResource.getBucketHolder();
00077 
00078     // Number of classes/buckets: n
00079     const short nbOfClasses = ioBucketHolder.getSize();
00080 
00081     // Create a holder for the list of Partial Sum Lists
00082     PartialSumHolderHolder& aPartialSumHolderHolder =
00083       FacPartialSumHolderHolder::instance().create();
00084 
00091     for (short j = 0 ; j <= nbOfClasses; ++j) {
00092       PartialSumHolder& aPartialSumList = 
00093         FacPartialSumHolder::instance().create ();
00094 
00095       FacPartialSumHolderHolder::instance().
00096         addPartialSumHolder (aPartialSumHolderHolder, aPartialSumList);
00097     }
00098 
00099     // Call the class performing the actual algorithm
00100     MCOptimiser::optimalOptimisationByMCIntegration (K, iCabinCapacity, 
00101                                                      ioBucketHolder,
00102                                                      aPartialSumHolderHolder,
00103                                                      ioBidPriceVector,
00104                                                      ioStudyStatManager);
00105     const double lMCIntegrationTime = lMCIntegrationBasChrono.elapsed();
00106     ioStudyStatManager.addMeasure ("MCIntegrationRunningTime",
00107                                    lMCIntegrationTime);
00108   }
00109 
00110   // //////////////////////////////////////////////////////////////////////
00111   void Optimiser::
00112   optimalOptimisationByDP (const ResourceCapacity_T iCabinCapacity,
00113                            BucketHolder& ioBucketHolder) {
00114     BidPriceVector_T lBidPriceVector;
00115     DPOptimiser::optimalOptimisationByDP (iCabinCapacity,
00116                                           ioBucketHolder,
00117                                           lBidPriceVector);
00118 
00119     // DEBUG
00120     std::ostringstream ostr;
00121     // Store current formatting flags of the stream
00122     std::ios::fmtflags oldFlags = ostr.flags();
00123 
00124     ostr << "BPV: " << std::fixed << std::setprecision (2);
00125     
00126     unsigned int i = 0;
00127 
00128     for (BidPriceVector_T::const_iterator itBP = lBidPriceVector.begin();
00129          itBP != lBidPriceVector.end(); ++itBP, ++i) {
00130       const double bidPrice = *itBP;
00131       ostr << "[" << i << "]: " << bidPrice << ", ";
00132     }
00133 
00134     // Reset formatting flags of stream
00135     ostr.flags (oldFlags);
00136 
00137     RMOL_LOG_DEBUG (ostr.str());
00138   }
00139 
00140   // //////////////////////////////////////////////////////////////////////
00141   void Optimiser::
00142   heuristicOptimisationByEmsr (const ResourceCapacity_T iCabinCapacity,
00143                                BucketHolder& ioBucketHolder,
00144                                BidPriceVector_T& ioBidPriceVector) {
00145     Emsr::heuristicOptimisationByEmsr (iCabinCapacity,
00146                                        ioBucketHolder,
00147                                        ioBidPriceVector);
00148   }
00149 
00150   // //////////////////////////////////////////////////////////////////////
00151   void Optimiser::
00152   heuristicOptimisationByEmsr (const ResourceCapacity_T iCabinCapacity,
00153                                BucketHolder& ioBucketHolder,
00154                                BidPriceVector_T& ioBidPriceVector,
00155                                StudyStatManager& ioStudyStatManager) {
00156     BasChronometer lEMRSBasChrono;
00157     lEMRSBasChrono.start();
00158     Emsr::heuristicOptimisationByEmsr (iCabinCapacity,
00159                                        ioBucketHolder,
00160                                        ioBidPriceVector);
00161     const double lEMRSTime = lEMRSBasChrono.elapsed();
00162     ioStudyStatManager.addMeasure ("EMSRRunningTime", lEMRSTime);
00163   }
00164 
00165   // //////////////////////////////////////////////////////////////////////
00166   void Optimiser::
00167   heuristicOptimisationByEmsrA (const ResourceCapacity_T iCabinCapacity,
00168                                 BucketHolder& ioBucketHolder) {
00169     Emsr::heuristicOptimisationByEmsrA (iCabinCapacity, ioBucketHolder);
00170   }
00171   
00172   // //////////////////////////////////////////////////////////////////////
00173   void Optimiser::heuristicOptimisationByEmsrAwithSellup 
00174   (const ResourceCapacity_T iCabinCapacity, 
00175    BucketHolder& ioBucketHolder,
00176    SellupProbabilityVector_T& iSellupProbabilityVector) {
00177     Emsr::heuristicOptimisationByEmsrAwithSellup (iCabinCapacity, 
00178                                                 ioBucketHolder, 
00179                                                 iSellupProbabilityVector);
00180   }
00181 
00182   // //////////////////////////////////////////////////////////////////////
00183   void Optimiser::
00184   heuristicOptimisationByEmsrB (const ResourceCapacity_T iCabinCapacity,
00185                                 BucketHolder& ioBucketHolder) {
00186     
00187     // Create the aggregated class/bucket.
00188     FldYieldRange aYieldRange = FldYieldRange (0);
00189     FldDistributionParameters aDistribParams = FldDistributionParameters(0,0);
00190     Demand& aDemand =
00191       FacDemand::instance().create (aDistribParams, aYieldRange);
00192     Bucket& aBucket = FacBucket::instance().create (aYieldRange, aDemand);
00193     
00194     Emsr::heuristicOptimisationByEmsrB (iCabinCapacity,
00195                                         ioBucketHolder,
00196                                         aBucket);
00197   }
00198 
00199   // //////////////////////////////////////////////////////////////////////
00200   void Optimiser::
00201   legOptimisationByMC (const ResourceCapacity_T iCabinCapacity,
00202                        BucketHolder& ioBucketHolder,
00203                        BidPriceVector_T& ioBidPriceVector) {
00204     MCOptimiser::legOptimisationByMC (iCabinCapacity, ioBucketHolder,
00205                                       ioBidPriceVector);
00206   }
00207   
00208 }