RMOL Logo  0.25.3
C++ library of Revenue Management and Optimisation classes and functions
Emsr.cpp
Go to the documentation of this file.
00001 // //////////////////////////////////////////////////////////////////////
00002 // Import section
00003 // //////////////////////////////////////////////////////////////////////
00004 // C
00005 #include <assert.h>
00006 // STL
00007 #include <iostream>
00008 #include <cmath>
00009 #include <list>
00010 #include <algorithm>
00011 // StdAir
00012 #include <stdair/stdair_rm_types.hpp>
00013 #include <stdair/bom/LegCabin.hpp>
00014 #include <stdair/bom/VirtualClassStruct.hpp>
00015 // RMOL
00016 #include <rmol/bom/Emsr.hpp>
00017 #include <rmol/bom/EmsrUtils.hpp>
00018 
00019 namespace RMOL {
00020   // //////////////////////////////////////////////////////////////////
00021   void Emsr::heuristicOptimisationByEmsrA (stdair::LegCabin& ioLegCabin) {
00022     stdair::VirtualClassList_T& lVirtualClassList =
00023       ioLegCabin.getVirtualClassList ();
00024     const stdair::CabinCapacity_T& lCabinCapacity =
00025       ioLegCabin.getOfferedCapacity();
00026 
00032     stdair::VirtualClassList_T::iterator itVC =lVirtualClassList.begin();
00033     assert (itVC != lVirtualClassList.end());
00034     
00035     stdair::VirtualClassStruct& lFirstVC = *itVC;
00036     lFirstVC.setCumulatedBookingLimit (lCabinCapacity);
00037     ++itVC;
00038     for (; itVC != lVirtualClassList.end(); ++itVC) {
00039       stdair::VirtualClassStruct& lNextVC = *itVC;
00040 
00041       // Initialise the protection for class/bucket j.
00042       stdair::ProtectionLevel_T lProtectionLevel = 0.0;
00043 
00044       for(stdair::VirtualClassList_T::iterator itHigherVC =
00045             lVirtualClassList.begin(); itHigherVC != itVC; ++itHigherVC) {
00046         stdair::VirtualClassStruct& lHigherVC = *itHigherVC;
00047         const double lPartialProtectionLevel =
00048           EmsrUtils::computeProtectionLevel (lHigherVC, lNextVC);
00049         lProtectionLevel += lPartialProtectionLevel;
00050       }
00051       stdair::VirtualClassList_T::iterator itCurrentVC = itVC; --itCurrentVC;
00052       stdair::VirtualClassStruct& lCurrentVC = *itCurrentVC;
00053       lCurrentVC.setCumulatedProtection (lProtectionLevel);
00054 
00055       // Compute the booking limit for the class/bucket j+1 (can be negative).
00056       const double lBookingLimit = lCabinCapacity - lProtectionLevel;
00057       
00058       // Set the booking limit for class/bucket j+1.
00059       lNextVC.setCumulatedBookingLimit (lBookingLimit);   
00060     }
00061   }
00062 
00063   // //////////////////////////////////////////////////////////////////
00064   void Emsr::heuristicOptimisationByEmsrB (stdair::LegCabin& ioLegCabin) {
00065     stdair::VirtualClassList_T& lVirtualClassList =
00066       ioLegCabin.getVirtualClassList ();
00067     const stdair::CabinCapacity_T& lCabinCapacity =
00068       ioLegCabin.getOfferedCapacity();
00069     
00075     stdair::VirtualClassList_T::iterator itVC =lVirtualClassList.begin();
00076     assert (itVC != lVirtualClassList.end());
00077     
00078     stdair::VirtualClassStruct& lFirstVC = *itVC;
00079     lFirstVC.setCumulatedBookingLimit (lCabinCapacity);
00080     ++itVC;
00081     stdair::VirtualClassStruct lAggregatedVC = lFirstVC;
00082     for (; itVC != lVirtualClassList.end(); ++itVC) {
00083       stdair::VirtualClassStruct& lNextVC = *itVC;
00084 
00085       // Compute the protection level for the aggregated class/bucket
00086       // using the Little-Wood formular.
00087       const stdair::ProtectionLevel_T lProtectionLevel =
00088         EmsrUtils::computeProtectionLevel (lAggregatedVC, lNextVC);
00089 
00090       // Set the protection level for class/bucket j.
00091       stdair::VirtualClassList_T::iterator itCurrentVC = itVC; --itCurrentVC;
00092       stdair::VirtualClassStruct& lCurrentVC = *itCurrentVC;
00093       lCurrentVC.setCumulatedProtection (lProtectionLevel);
00094 
00095       // Compute the booking limit for class/bucket j+1 (can be negative).
00096       const double lBookingLimit = lCabinCapacity - lProtectionLevel;
00097       
00098       // Set the booking limit for class/bucket j+1.
00099       lNextVC.setCumulatedBookingLimit (lBookingLimit);
00100 
00101       // Compute the aggregated class/bucket of classes/buckets 1,..,j.
00102       EmsrUtils::computeAggregatedVirtualClass (lAggregatedVC, lNextVC);
00103 
00104     } 
00105   }
00106 
00107   // //////////////////////////////////////////////////////////////////
00108   void Emsr::heuristicOptimisationByEmsr (stdair::LegCabin& ioLegCabin) {
00109     stdair::VirtualClassList_T& lVirtualClassList =
00110       ioLegCabin.getVirtualClassList ();
00111     const stdair::CabinCapacity_T& lCapacity = ioLegCabin.getOfferedCapacity();
00112     ioLegCabin.emptyBidPriceVector();
00113     stdair::BidPriceVector_T& lBidPriceVector =
00114       ioLegCabin.getBidPriceVector();
00115     
00116     // Cabin capacity in integer.
00117     const int lCabinCapacity = static_cast<const int> (lCapacity);
00118 
00119     // List of all EMSR values.
00120     stdair::EmsrValueList_T lEmsrValueList;
00121 
00127     for (stdair::VirtualClassList_T::iterator itVC = lVirtualClassList.begin();
00128          itVC != lVirtualClassList.end(); ++itVC) {
00129       stdair::VirtualClassStruct& lCurrentVC = *itVC;
00130       for (int k = 1; k <= lCabinCapacity; ++k) {
00131         const double emsrValue = EmsrUtils::computeEmsrValue (k, lCurrentVC);
00132         lEmsrValueList.push_back(emsrValue);
00133       }
00134     }
00135 
00136     // Sort the EMSR values from high to low.
00137     std::sort(lEmsrValueList.rbegin(), lEmsrValueList.rend());
00138 
00139     // Sanity check
00140     const int lEmsrValueListSize = lEmsrValueList.size();
00141     assert (lEmsrValueListSize >= lCabinCapacity);
00142 
00143     // Copy the EMSR sorted values to the BPV.
00144     stdair::EmsrValueList_T::const_iterator itCurrentValue =
00145       lEmsrValueList.begin();
00146     for (int j = 0; j < lCabinCapacity; ++j, ++itCurrentValue) {
00147       const double lBidPrice = *itCurrentValue;
00148       lBidPriceVector.push_back (lBidPrice);
00149     }
00150     lEmsrValueList.clear();
00151     
00152     // Build the protection levels and booking limits.
00153     if (lVirtualClassList.size() > 1) {
00154       int lCapacityIndex = 0;
00155       for (stdair::VirtualClassList_T::iterator itVC =lVirtualClassList.begin();
00156            itVC != lVirtualClassList.end();) {
00157         stdair::VirtualClassStruct& lCurrentVC = *itVC;
00158         if (itVC != lVirtualClassList.end()) {
00159           ++itVC;
00160         }
00161         stdair::VirtualClassStruct& lNextVC = *itVC;
00162         const stdair::Yield_T lNextYield = lNextVC.getYield();
00163         while ((lCapacityIndex < lCabinCapacity)
00164                && (lBidPriceVector.at(lCapacityIndex) > lNextYield)) {
00165             ++lCapacityIndex;
00166         }
00167         lCurrentVC.setCumulatedProtection (lCapacityIndex);
00168         lNextVC.setCumulatedBookingLimit (lCapacity - lCapacityIndex);
00169       }
00170     }
00171   }
00172 
00173 }
 All Classes Namespaces Files Functions Variables Typedefs Friends Defines