Go to the documentation of this file.00001 #ifndef __STDAIR_BAS_CONTINUOUSATTRIBUTELITE_HPP
00002 #define __STDAIR_BAS_CONTINUOUSATTRIBUTELITE_HPP
00003
00004
00005
00006
00007
00008 #include <cassert>
00009 #include <iosfwd>
00010 #include <string>
00011 #include <vector>
00012 #include <map>
00013
00014 #include <stdair/stdair_basic_types.hpp>
00015
00016 #include <stdair/stdair_exceptions.hpp>
00017 #include <stdair/basic/DictionaryManager.hpp>
00018
00019 namespace stdair {
00020
00025 template <typename T>
00026 struct ContinuousAttributeLite {
00027 public:
00028
00032 typedef std::map<T, stdair::Probability_T> ContinuousDistribution_T;
00033
00034 public:
00035
00039 const T getValue(const stdair::Probability_T& iCumulativeProbability) const{
00040 const DictionaryKey_T& lKey =
00041 DictionaryManager::valueToKey (iCumulativeProbability);
00042
00043
00044 unsigned int idx = 0;
00045 for (; idx < _size; ++idx) {
00046 if (_cumulativeDistribution.at(idx) > lKey) {
00047 break;
00048 }
00049 }
00050
00051 if (idx == 0) {
00052 return _valueArray.at(idx);
00053 }
00054 if (idx == _size) {
00055 return _valueArray.at(idx-1);
00056 }
00057
00058
00059 const stdair::Probability_T& lCumulativeCurrentPoint =
00060 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx));
00061 const T& lValueCurrentPoint = _valueArray.at(idx);
00062
00063
00064 const stdair::Probability_T& lCumulativePreviousPoint =
00065 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx-1));
00066 const T& lValuePreviousPoint = _valueArray.at(idx-1);
00067
00068 if (lCumulativePreviousPoint == lCumulativeCurrentPoint) {
00069 return lValuePreviousPoint;
00070 }
00071
00072 T oValue= lValuePreviousPoint + (lValueCurrentPoint - lValuePreviousPoint)
00073 * (iCumulativeProbability - lCumulativePreviousPoint)
00074 / (lCumulativeCurrentPoint - lCumulativePreviousPoint);
00075
00076 return oValue;
00077 }
00078
00079 public:
00080
00084 const stdair::Probability_T getRemainingProportion(const T& iValue) const {
00085
00086
00087 unsigned int idx = 0;
00088 for (; idx < _size; ++idx) {
00089 if (_valueArray.at(idx) > iValue) {
00090 break;
00091 }
00092 }
00093 if (idx == 0) {
00094 const stdair::Probability_T& oCumulativeProbability =
00095 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx));
00096 return 1 - oCumulativeProbability;
00097 }
00098 if (idx == _size) {
00099 const stdair::Probability_T& oCumulativeProbability =
00100 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx-1));
00101 return 1 - oCumulativeProbability;
00102 }
00103
00104
00105 const stdair::Probability_T& lCumulativeCurrentPoint =
00106 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx));
00107 const T& lValueCurrentPoint = _valueArray.at(idx);
00108
00109
00110 const stdair::Probability_T& lCumulativePreviousPoint =
00111 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx-1));
00112 const T& lValuePreviousPoint = _valueArray.at(idx-1);
00113
00114 if (lValuePreviousPoint == lValueCurrentPoint) {
00115 return 1 - lCumulativePreviousPoint;
00116 }
00117
00118 const stdair::Probability_T& oCumulativeProbability =
00119 lCumulativePreviousPoint + (lCumulativeCurrentPoint - lCumulativePreviousPoint)
00120 * (iValue - lValuePreviousPoint)
00121 / (lValueCurrentPoint - lValuePreviousPoint);
00122
00123 return 1 - oCumulativeProbability;
00124 }
00125
00126 public:
00127
00131 const double getDerivativeValue(const T iKey) const{
00132
00133
00134 unsigned int idx = 0;
00135 for (; idx < _size; ++idx) {
00136 if (_valueArray.at(idx) > iKey) {
00137 break;
00138 }
00139 }
00140 assert (idx != 0);
00141 assert (idx != _size);
00142
00143
00144 const stdair::Probability_T& lCumulativeCurrentPoint =
00145 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx));
00146 const T& lValueCurrentPoint = _valueArray.at(idx);
00147
00148
00149 const stdair::Probability_T& lCumulativePreviousPoint =
00150 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx-1));
00151 const T& lValuePreviousPoint = _valueArray.at(idx-1);
00152 assert (lValueCurrentPoint != lValuePreviousPoint);
00153
00154 const double oValue= (lCumulativeCurrentPoint - lCumulativePreviousPoint)
00155 / (lValueCurrentPoint - lValuePreviousPoint);
00156
00157 return oValue;
00158 }
00159
00163 const T getUpperBound (const T iKey) const {
00164
00165 unsigned int idx = 0;
00166 for (; idx < _size; ++idx) {
00167 if (_valueArray.at(idx) > iKey) {
00168 break;
00169 }
00170 }
00171 assert (idx != 0);
00172 assert (idx != _size);
00173
00174 return _valueArray.at (idx);
00175 }
00176
00177 public:
00178
00182 const std::string displayCumulativeDistribution() const {
00183 std::ostringstream oStr;
00184
00185 for (unsigned int idx = 0; idx < _size; ++idx) {
00186 if (idx != 0) {
00187 oStr << ", ";
00188 }
00189
00190 const stdair::Probability_T& lProbability =
00191 DictionaryManager::keyToValue (_cumulativeDistribution.at(idx));
00192
00193 oStr << _valueArray.at(idx) << ":" << lProbability;
00194 }
00195 return oStr.str();
00196 }
00197
00198
00199 public:
00200
00204 ContinuousAttributeLite (const ContinuousDistribution_T& iValueMap)
00205 : _size (iValueMap.size()) {
00206 init (iValueMap);
00207 }
00208
00212 ContinuousAttributeLite (const ContinuousAttributeLite& iCAL)
00213 : _size (iCAL._size),
00214 _cumulativeDistribution (iCAL._cumulativeDistribution),
00215 _valueArray (iCAL._valueArray) {
00216 }
00217
00221 ContinuousAttributeLite& operator= (const ContinuousAttributeLite& iCAL) {
00222 _size = iCAL._size;
00223 _cumulativeDistribution = iCAL._cumulativeDistribution;
00224 _valueArray = iCAL._valueArray;
00225 return *this;
00226 }
00227
00231 virtual ~ContinuousAttributeLite() {
00232 }
00233
00234 private:
00238 ContinuousAttributeLite() : _size(1) {
00239 }
00240
00245 void init (const ContinuousDistribution_T& iValueMap) {
00246
00247 const unsigned int lSize = iValueMap.size();
00248 _cumulativeDistribution.reserve (lSize);
00249 _valueArray.reserve (lSize);
00250
00251
00252 for (typename ContinuousDistribution_T::const_iterator it =
00253 iValueMap.begin(); it != iValueMap.end(); ++it) {
00254
00255 const T& attributeValue = it->first;
00256 const DictionaryKey_T& lKey = DictionaryManager::valueToKey (it->second);
00257
00258
00259 _cumulativeDistribution.push_back (lKey);
00260 _valueArray.push_back (attributeValue);
00261 }
00262 }
00263
00264
00265 private:
00266
00270 unsigned int _size;
00271
00275 std::vector<DictionaryKey_T> _cumulativeDistribution;
00276
00280 std::vector<T> _valueArray;
00281 };
00282
00283 }
00284 #endif // __STDAIR_BAS_CONTINUOUSATTRIBUTELITE_HPP