$treeview $search $mathjax
TraDemGen Logo  1.00.0
$projectbrief
$projectbrief
$searchbox

ContinuousAttribute.hpp

Go to the documentation of this file.
00001 #ifndef __TRADEMGEN_BAS_CONTINUOUSATTRIBUTE_HPP
00002 #define __TRADEMGEN_BAS_CONTINUOUSATTRIBUTE_HPP
00003 
00004 // //////////////////////////////////////////////////////////////////////
00005 // Import section
00006 // //////////////////////////////////////////////////////////////////////
00007 // STL
00008 #include <string>
00009 #include <map>
00010 // StdAir
00011 #include <stdair/stdair_date_time_types.hpp>
00012 #include <stdair/service/Logger.hpp>
00013 // TraDemGen
00014 #include <trademgen/basic/DictionaryManager.hpp>
00015 
00016 namespace TRADEMGEN {
00017 
00020   template <class T>
00021   struct ContinuousAttribute {
00022   public:
00023 
00024     // ///////////// Type definitions //////////////
00026     typedef std::multimap<T, DictionaryKey_T> ContinuousDistribution_T;
00027     typedef std::multimap<DictionaryKey_T, T> ContinuousInverseDistribution_T;
00028 
00029   private:
00030     // ///////////// Getters ///////////
00032     const ContinuousDistribution_T& getCumulativeDistribution() const {
00033       return _cumulativeDistribution;
00034     }
00035   
00037     const ContinuousInverseDistribution_T& getInverseCumulativeDistribution () const {
00038       return _inverseCumulativeDistribution;
00039     }
00040 
00041   private:
00042     // ///////////// Setters ///////////
00044     void setCumulativeDistribution (const ContinuousDistribution_T& iCumulativeDistribution) {
00045       _cumulativeDistribution = iCumulativeDistribution;
00046       determineInverseCumulativeDistributionFromCumulativeDistribution();
00047     }
00048 
00049   public:
00050     // /////////////// Business Methods //////////
00052     const T getValue (const stdair::Probability_T& iCumulativeProbability) const{
00053       const DictionaryKey_T lKey =
00054         DictionaryManager::valueToKey (iCumulativeProbability);
00055       typename ContinuousInverseDistribution_T::const_iterator it =
00056         _inverseCumulativeDistribution.lower_bound (lKey);
00057     
00058       stdair::Probability_T cumulativeProbabilityNextPoint =
00059         DictionaryManager::keyToValue (it->first);
00060       T valueNextPoint = it->second;
00061     
00062       if (it == _inverseCumulativeDistribution.begin()) {
00063         STDAIR_LOG_DEBUG ("Last element");
00064         return valueNextPoint;
00065       }
00066       --it;
00067     
00068       stdair::Probability_T cumulativeProbabilityPreviousPoint =
00069         DictionaryManager::keyToValue (it->first);
00070       T valuePreviousPoint = it->second;
00071       if (cumulativeProbabilityNextPoint == cumulativeProbabilityPreviousPoint) {
00072         return valuePreviousPoint;
00073       }
00074 
00075       return valuePreviousPoint + (valueNextPoint - valuePreviousPoint)
00076         * (iCumulativeProbability - cumulativeProbabilityPreviousPoint)
00077         / (cumulativeProbabilityNextPoint - cumulativeProbabilityPreviousPoint);
00078     }
00079     
00080   public:
00081     // ////////////// Display Support Methods //////////
00083     const std::string displayCumulativeDistribution() const {
00084       std::ostringstream oStr;
00085       unsigned int idx = 0;
00086       for (typename ContinuousDistribution_T::const_iterator it =
00087              _cumulativeDistribution.begin();
00088            it != _cumulativeDistribution.end(); ++it, ++idx) {
00089         if (idx != 0) {
00090           oStr << ", ";
00091         }
00092         oStr << it->first << ":"
00093              << DictionaryManager::keyToValue (it->second);
00094       }
00095       return oStr.str();
00096     }
00097     
00099     const std::string displayInverseCumulativeDistribution() const {
00100       std::ostringstream oStr;
00101       for (typename ContinuousInverseDistribution_T::const_iterator it =
00102              _inverseCumulativeDistribution.begin();
00103            it != _inverseCumulativeDistribution.end(); ++it) {
00104         oStr << "cumulative prob: " << DictionaryManager::keyToValue (it->first)
00105              << "  value: " << it->second << std::endl;
00106       }
00107       return oStr.str();
00108     }
00109     
00110   public:
00111     // ////////// Constructors and destructors /////////
00113     ContinuousAttribute () { }
00114     
00116     ContinuousAttribute (const ContinuousDistribution_T& iCumulativeDistribution)
00117       : _cumulativeDistribution (iCumulativeDistribution) {
00118       determineInverseCumulativeDistributionFromCumulativeDistribution();
00119     }
00120     
00122     ContinuousAttribute (const ContinuousAttribute& iContinuousAttribute)
00123       : _cumulativeDistribution (iContinuousAttribute._cumulativeDistribution),
00124         _inverseCumulativeDistribution (iContinuousAttribute._inverseCumulativeDistribution) {
00125     }
00126     
00128     virtual ~ContinuousAttribute () { }
00129 
00132     void determineInverseCumulativeDistributionFromCumulativeDistribution () {
00133       for (typename ContinuousDistribution_T::iterator itCumulativeDistribution =
00134              _cumulativeDistribution.begin();
00135            itCumulativeDistribution != _cumulativeDistribution.end();
00136            ++itCumulativeDistribution) {
00137         _inverseCumulativeDistribution.
00138           insert (typename ContinuousInverseDistribution_T::
00139                   value_type (itCumulativeDistribution->second,
00140                               itCumulativeDistribution->first));
00141       }
00142     }
00143   
00144   private:
00145     // ////////// Attributes //////////
00146     
00148     ContinuousDistribution_T _cumulativeDistribution;
00149     
00151     ContinuousInverseDistribution_T _inverseCumulativeDistribution;
00152   };
00153   
00154 }
00155 #endif // __STDAIR_BAS_CONTINUOUSATTRIBUTE_HPP