00001
00002
00003
00004
00005 #include <assert.h>
00006
00007 #include <iomanip>
00008 #include <sstream>
00009 #include <iostream>
00010
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/command/Forecaster.hpp>
00021 #include <rmol/service/RMOL_ServiceContext.hpp>
00022 #include <rmol/service/Logger.hpp>
00023 #include <rmol/RMOL_Service.hpp>
00024
00025 namespace RMOL {
00026
00027
00028 RMOL_Service::RMOL_Service () :
00029 _rmolServiceContext (NULL) {
00030 }
00031
00032
00033 RMOL_Service::RMOL_Service (const RMOL_Service& iService) :
00034 _rmolServiceContext (iService._rmolServiceContext) {
00035 }
00036
00037
00038 RMOL_Service::RMOL_Service (std::ostream& ioLogStream) {
00039
00040 init (ioLogStream);
00041 }
00042
00043
00044 RMOL_Service::RMOL_Service (std::ostream& ioLogStream,
00045 const ResourceCapacity_T iResourceCapacity) {
00046
00047 init (ioLogStream, iResourceCapacity);
00048 }
00049
00050
00051 RMOL_Service::~RMOL_Service () {
00052 }
00053
00054
00055 void RMOL_Service::init (std::ostream& ioLogStream) {
00056
00057 logInit (LOG::DEBUG, ioLogStream);
00058
00059
00060 RMOL_ServiceContext& lRMOL_ServiceContext =
00061 FacRmolServiceContext::instance().create ();
00062 _rmolServiceContext = &lRMOL_ServiceContext;
00063 }
00064
00065
00066 void RMOL_Service::init (std::ostream& ioLogStream,
00067 const ResourceCapacity_T iResourceCapacity) {
00068
00069 logInit (LOG::DEBUG, ioLogStream);
00070
00071
00072 RMOL_ServiceContext& lRMOL_ServiceContext =
00073 FacRmolServiceContext::instance().create (iResourceCapacity);
00074 _rmolServiceContext = &lRMOL_ServiceContext;
00075 }
00076
00077
00078 void RMOL_Service::logInit (const LOG::EN_LogLevel iLogLevel,
00079 std::ostream& ioLogOutputFile) {
00080 Logger::instance().setLogParameters (iLogLevel, ioLogOutputFile);
00081 }
00082
00083
00084 void RMOL_Service::setUpStudyStatManager () {
00085 assert (_rmolServiceContext != NULL);
00086 _rmolServiceContext->setUpStudyStatManager ();
00087 }
00088
00089
00090 void RMOL_Service::
00091 setResourceCapacity (const ResourceCapacity_T iResourceCapacity) {
00092 assert (_rmolServiceContext != NULL);
00093 _rmolServiceContext->setResourceCapacity (iResourceCapacity);
00094 }
00095
00096
00097 void RMOL_Service::addBucket (const double iYieldRange,
00098 const double iDemandMean,
00099 const double iDemandStandardDev) {
00100 assert (_rmolServiceContext != NULL);
00101 _rmolServiceContext->addBucket (iYieldRange, iDemandMean,
00102 iDemandStandardDev);
00103 }
00104
00105
00106 void RMOL_Service::addBucket(const double iYieldRange,
00107 const double iDemandMean,
00108 const double iDemandStandardDev,
00109 GeneratedDemandVector_T* ioGeneratedDemandVector){
00110 assert (_rmolServiceContext != NULL);
00111 _rmolServiceContext->addBucket (iYieldRange, iDemandMean,
00112 iDemandStandardDev, ioGeneratedDemandVector);
00113 }
00114
00115
00116 GeneratedDemandVector_T* RMOL_Service::
00117 generateDemand (const int K, const double& iMean, const double& iDeviation) {
00118 return _rmolServiceContext->generateDemand (K, iMean, iDeviation);
00119 }
00120
00121
00122 GeneratedDemandVector_T* RMOL_Service::
00123 generateDemand (GeneratedDemandVector_T* ioFirstVector,
00124 GeneratedDemandVector_T* ioSecondVector) {
00125 return _rmolServiceContext->generateDemand (ioFirstVector, ioSecondVector);
00126 }
00127
00128
00129 void RMOL_Service::readFromInputFile (const std::string& iInputFileName) {
00130 assert (_rmolServiceContext != NULL);
00131 _rmolServiceContext->readFromInputFile (iInputFileName);
00132 }
00133
00134
00135 void RMOL_Service::buildContextForMC (const int K) {
00136 assert (_rmolServiceContext != NULL);
00137 _rmolServiceContext->buildContextForMC (K);
00138 }
00139
00140
00141 void RMOL_Service::reset () {
00142 assert (_rmolServiceContext != NULL);
00143 _rmolServiceContext->reset ();
00144 }
00145
00146
00147 void RMOL_Service::
00148 optimalOptimisationByMCIntegration (const int K) {
00149
00150 assert (_rmolServiceContext != NULL);
00151 const double iCapacity = _rmolServiceContext->getCapacity();
00152 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00153 assert (oBucketHolder_ptr != NULL);
00154 BidPriceVector_T lBidPriceVector;
00155
00156 StudyStatManager* lStudyStatManager_ptr =
00157 _rmolServiceContext->getStudyStatManager();
00158
00159 if (lStudyStatManager_ptr == NULL) {
00160 Optimiser::optimalOptimisationByMCIntegration (K, iCapacity,
00161 *oBucketHolder_ptr,
00162 lBidPriceVector);
00163 } else {
00164 Optimiser::optimalOptimisationByMCIntegration (K, iCapacity,
00165 *oBucketHolder_ptr,
00166 lBidPriceVector,
00167 *lStudyStatManager_ptr);
00168 }
00169
00170 RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00171
00172 std::ostringstream logStream;
00173 logStream << "Bid-Price Vector (BPV): ";
00174 unsigned int size = lBidPriceVector.size();
00175
00176 for (unsigned int i = 0; i < size; ++i) {
00177 const double bidPrice = lBidPriceVector.at(i);
00178 logStream << std::fixed << std::setprecision (2) << bidPrice << " ";
00179 }
00180 RMOL_LOG_DEBUG (logStream.str());
00181
00182 if (lStudyStatManager_ptr != NULL) {
00183 RMOL_LOG_DEBUG (lStudyStatManager_ptr->describe());
00184 }
00185 }
00186
00187
00188 void RMOL_Service::
00189 optimalOptimisationByMCIntegration(const int K,
00190 BidPriceVector_T& ioBidPriceVector,
00191 BookingLimitVector_T& ioBookingLimitVector){
00192
00193 assert (_rmolServiceContext != NULL);
00194 const double iCapacity = _rmolServiceContext->getCapacity();
00195 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00196 assert (oBucketHolder_ptr != NULL);
00197
00198 Optimiser::optimalOptimisationByMCIntegration (K, iCapacity,
00199 *oBucketHolder_ptr,
00200 ioBidPriceVector);
00201
00202
00203 oBucketHolder_ptr->fillup (ioBookingLimitVector);
00204 }
00205
00206
00207 void RMOL_Service::
00208 optimalOptimisationByDP () {
00209
00210 assert (_rmolServiceContext != NULL);
00211 const double iCapacity = _rmolServiceContext->getCapacity();
00212 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00213 assert (oBucketHolder_ptr != NULL);
00214
00215 Optimiser::optimalOptimisationByDP (iCapacity, *oBucketHolder_ptr);
00216
00217
00218 RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00219 }
00220
00221
00222 void RMOL_Service::
00223 optimalOptimisationByDP (BookingLimitVector_T& ioBookingLimitVector) {
00224
00225 assert (_rmolServiceContext != NULL);
00226 const double iCapacity = _rmolServiceContext->getCapacity();
00227 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00228 assert (oBucketHolder_ptr != NULL);
00229
00230 Optimiser::optimalOptimisationByDP (iCapacity, *oBucketHolder_ptr);
00231
00232
00233 oBucketHolder_ptr->fillup (ioBookingLimitVector);
00234 }
00235
00236
00237 void RMOL_Service::heuristicOptimisationByEmsr () {
00238 assert (_rmolServiceContext != NULL);
00239 const double iCapacity = _rmolServiceContext->getCapacity();
00240 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00241 assert (oBucketHolder_ptr != NULL);
00242 BidPriceVector_T lBidPriceVector;
00243
00244 StudyStatManager* lStudyStatManager_ptr =
00245 _rmolServiceContext->getStudyStatManager();
00246
00247 if (lStudyStatManager_ptr == NULL) {
00248 Optimiser::heuristicOptimisationByEmsr (iCapacity, *oBucketHolder_ptr,
00249 lBidPriceVector);
00250 } else {
00251 Optimiser::heuristicOptimisationByEmsr (iCapacity, *oBucketHolder_ptr,
00252 lBidPriceVector,
00253 *lStudyStatManager_ptr);
00254 }
00255
00256
00257 RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00258 std::ostringstream logStream;
00259 logStream << "Bid-Price Vector (BPV): ";
00260 unsigned int size = lBidPriceVector.size();
00261
00262 for (unsigned int i = 0; i < size; ++i) {
00263 const double bidPrice = lBidPriceVector.at(i);
00264 logStream << std::fixed << std::setprecision (2) << bidPrice << " ";
00265 }
00266 RMOL_LOG_DEBUG (logStream.str());
00267
00268 if (lStudyStatManager_ptr != NULL) {
00269 RMOL_LOG_DEBUG (lStudyStatManager_ptr->describe());
00270 }
00271 }
00272
00273
00274 void RMOL_Service::
00275 heuristicOptimisationByEmsr (BidPriceVector_T& ioBidPriceVector,
00276 BookingLimitVector_T& ioBookingLimitVector) {
00277 assert (_rmolServiceContext != NULL);
00278 const double iCapacity = _rmolServiceContext->getCapacity();
00279 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00280 assert (oBucketHolder_ptr != NULL);
00281
00282 Optimiser::heuristicOptimisationByEmsr (iCapacity, *oBucketHolder_ptr,
00283 ioBidPriceVector);
00284
00285
00286 for (oBucketHolder_ptr->begin(); oBucketHolder_ptr->hasNotReachedEnd();
00287 oBucketHolder_ptr->iterate()) {
00288 Bucket& currentBucket = oBucketHolder_ptr->getCurrentBucket();
00289 const double lBookingLimit = currentBucket.getCumulatedBookingLimit();
00290 ioBookingLimitVector.push_back (lBookingLimit);
00291 }
00292
00293 }
00294
00295
00296 void RMOL_Service::heuristicOptimisationByEmsrA () {
00297 assert (_rmolServiceContext != NULL);
00298 const double iCapacity = _rmolServiceContext->getCapacity();
00299 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00300 assert (oBucketHolder_ptr != NULL);
00301
00302 Optimiser::heuristicOptimisationByEmsrA (iCapacity, *oBucketHolder_ptr);
00303
00304
00305 RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00306 }
00307
00308
00309 void RMOL_Service::
00310 heuristicOptimisationByEmsrA (BidPriceVector_T& ioBidPriceVector,
00311 BookingLimitVector_T& ioBookingLimitVector) {
00312 assert (_rmolServiceContext != NULL);
00313 const double iCapacity = _rmolServiceContext->getCapacity();
00314 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00315 assert (oBucketHolder_ptr != NULL);
00316
00317 Optimiser::heuristicOptimisationByEmsrA (iCapacity, *oBucketHolder_ptr);
00318
00319
00320 oBucketHolder_ptr->fillup (ioBookingLimitVector);
00321 }
00322
00323
00324 void RMOL_Service::heuristicOptimisationByEmsrAwithSellup
00325 (SellupProbabilityVector_T& iSellupProbabilityVector) {
00326
00327 assert (_rmolServiceContext != NULL);
00328 const double iCapacity = _rmolServiceContext->getCapacity();
00329 BucketHolder* ioBucketHolder_ptr =
00330 _rmolServiceContext->getBucketHolder();
00331 assert (ioBucketHolder_ptr != NULL);
00332
00333 Optimiser::
00334 heuristicOptimisationByEmsrAwithSellup (iCapacity,
00335 *ioBucketHolder_ptr,
00336 iSellupProbabilityVector);
00337
00338
00339 RMOL_LOG_DEBUG (ioBucketHolder_ptr->display());
00340 }
00341
00342
00343 void RMOL_Service::heuristicOptimisationByEmsrAwithSellup
00344 (SellupProbabilityVector_T& iSellupProbabilityVector,
00345 BidPriceVector_T& ioBidPriceVector,
00346 BookingLimitVector_T& ioBookingLimitVector) {
00347
00348 assert (_rmolServiceContext != NULL);
00349 const double iCapacity = _rmolServiceContext->getCapacity();
00350 BucketHolder* ioBucketHolder_ptr =
00351 _rmolServiceContext->getBucketHolder();
00352 assert (ioBucketHolder_ptr != NULL);
00353
00354 Optimiser::
00355 heuristicOptimisationByEmsrAwithSellup (iCapacity,
00356 *ioBucketHolder_ptr,
00357 iSellupProbabilityVector);
00358
00359
00360 ioBucketHolder_ptr->fillup (ioBookingLimitVector);
00361 }
00362
00363
00364 void RMOL_Service::heuristicOptimisationByEmsrB () {
00365 assert (_rmolServiceContext != NULL);
00366 const double iCapacity = _rmolServiceContext->getCapacity();
00367 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00368 assert (oBucketHolder_ptr != NULL);
00369
00370 Optimiser::heuristicOptimisationByEmsrB (iCapacity, *oBucketHolder_ptr);
00371
00372
00373 RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00374 }
00375
00376
00377 void RMOL_Service::
00378 heuristicOptimisationByEmsrB (BidPriceVector_T& ioBidPriceVector,
00379 BookingLimitVector_T& ioBookingLimitVector) {
00380 assert (_rmolServiceContext != NULL);
00381 const double iCapacity = _rmolServiceContext->getCapacity();
00382 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00383 assert (oBucketHolder_ptr != NULL);
00384
00385 Optimiser::heuristicOptimisationByEmsrB (iCapacity, *oBucketHolder_ptr);
00386
00387
00388 oBucketHolder_ptr->fillup (ioBookingLimitVector);
00389 }
00390
00391
00392 void RMOL_Service:: legOptimisationByMC () {
00393 assert (_rmolServiceContext != NULL);
00394 const ResourceCapacity_T iCapacity = _rmolServiceContext->getCapacity();
00395 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00396 assert (oBucketHolder_ptr != NULL);
00397
00398 BidPriceVector_T lBidPriceVector;
00399 Optimiser::legOptimisationByMC (iCapacity, *oBucketHolder_ptr,
00400 lBidPriceVector);
00401
00402
00403 RMOL_LOG_DEBUG (oBucketHolder_ptr->display());
00404 std::ostringstream logStream;
00405 logStream << "Bid-Price Vector (BPV): ";
00406 unsigned int size = lBidPriceVector.size();
00407
00408 for (unsigned int i = 0; i < size; ++i) {
00409 const double bidPrice = lBidPriceVector.at(i);
00410 logStream << std::fixed << std::setprecision (2) << bidPrice << " ";
00411 }
00412 RMOL_LOG_DEBUG (logStream.str());
00413 }
00414
00415
00416 void RMOL_Service::
00417 legOptimisationByMC (BidPriceVector_T& ioBidPriceVector,
00418 BookingLimitVector_T& ioBookingLimitVector) {
00419 assert (_rmolServiceContext != NULL);
00420 const ResourceCapacity_T iCapacity = _rmolServiceContext->getCapacity();
00421 BucketHolder* oBucketHolder_ptr = _rmolServiceContext->getBucketHolder();
00422 assert (oBucketHolder_ptr != NULL);
00423
00424 Optimiser::legOptimisationByMC (iCapacity, *oBucketHolder_ptr,
00425 ioBidPriceVector);
00426
00427
00428 oBucketHolder_ptr->fillup (ioBookingLimitVector);
00429 }
00430
00431
00432 void demandUnconstrainingByExpectationMaximization () {
00433
00434
00435 std::ostringstream logStream;
00436 logStream << "Testing demand unconstraining by Expectation Maximization";
00437 RMOL_LOG_DEBUG (logStream.str());
00438
00439 }
00440
00441
00442 void RMOL_Service::demandForecastByQForecasting
00443 (HistoricalDataHolderHolder_T& iHistoricalDataHolderHolder,
00444 PriceHolder_T& iPriceHolder) {
00445
00446
00447 ForecastedDemandParameterList_T lForecastedDemandParameterList;
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473 std::ostringstream logStream;
00474 logStream << "Testing Demand Forecasting by Q-Forecasting";
00475 RMOL_LOG_DEBUG (logStream.str());
00476
00477 }
00478
00479
00480 void RMOL_Service::demandForecastByQForecasting
00481 (ForecastedDemandParameterList_T oForecastedDemandParameterList,
00482 HistoricalDataHolderHolder_T& iHistoricalDataHolderHolder,
00483 PriceHolder_T& iPriceHolder) {
00484
00485
00486
00487
00488
00489
00490 Forecaster::demandForecastByQForecasting (oForecastedDemandParameterList,
00491 iHistoricalDataHolderHolder,
00492 iPriceHolder);
00493
00494
00495
00496
00497 }
00498
00499
00500 }