00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <math.h>
00025
00026 #include "FedTimeD.hh"
00027
00028 #include <limits>
00029 #include <sstream>
00030
00031 using namespace certi;
00032
00033 namespace
00034 {
00035
00036 const char *infinity_str = "+inf" ;
00037
00038 }
00039
00040
00041
00042
00043 const double FedTime::epsilon = std::numeric_limits<double>::epsilon();
00044
00045 int
00046 FedTime::fcmp(const double x1, const double x2) {
00047 return certi::fcmp(x1,x2,FedTime::epsilon);
00048 }
00049
00050
00051
00052 FedTime::FedTime()
00053 : _fedTime(0),
00054 _zero(0),
00055 _epsilon(FedTime::epsilon),
00056 _positiveInfinity(std::numeric_limits<double>::infinity()) { }
00057
00058 FedTime::FedTime(const double &time)
00059 : _fedTime(time),
00060 _zero(0),
00061 _epsilon(FedTime::epsilon),
00062 _positiveInfinity(std::numeric_limits<double>::infinity()) { }
00063
00064 FedTime::FedTime(const FedTime &time)
00065 : _fedTime(time._fedTime),
00066 _zero(time._zero),
00067 _epsilon(time._epsilon),
00068 _positiveInfinity(time._positiveInfinity) { }
00069
00070
00071 FedTime::~FedTime()
00072 {
00073 }
00074
00075
00076 void
00077 FedTime::setZero()
00078 {
00079 _fedTime = _zero;
00080 }
00081
00082
00083 bool
00084 FedTime::isZero()
00085 {
00086 return bool(_fedTime == _zero);
00087 }
00088
00089
00090 void
00091 FedTime::setEpsilon()
00092 {
00093 _fedTime = _epsilon;
00094 }
00095
00096
00097 void
00098 FedTime::setPositiveInfinity()
00099 {
00100 _fedTime = _positiveInfinity;
00101 }
00102
00103
00104 bool
00105 FedTime::isPositiveInfinity() const
00106 {
00107 return bool(_fedTime == _positiveInfinity);
00108 }
00109
00110
00111 int
00112 FedTime::encodedLength() const
00113 {
00114
00115
00116 return (sizeof(_fedTime)+
00117 sizeof(_zero)+
00118 sizeof(_epsilon)+
00119 sizeof(_positiveInfinity));
00120 }
00121
00122
00123 void
00124 FedTime::encode(char *buffer) const
00125 {
00126
00127
00128
00129 }
00130
00131
00132 int
00133 FedTime::getPrintableLength() const
00134 {
00135 std::stringstream s ;
00136
00137 if (isPositiveInfinity())
00138 s << infinity_str ;
00139 else
00140 s << _fedTime ;
00141
00142 return s.str().length() + 1 ;
00143 }
00144
00145
00146 void
00147 FedTime::getPrintableString(char *str)
00148 {
00149 std::stringstream s ;
00150
00151 if (isPositiveInfinity())
00152 s << infinity_str ;
00153 else
00154 s << _fedTime ;
00155
00156 s >> str ;
00157 str[s.str().length()] = 0 ;
00158 }
00159
00160
00161 FedTime &
00162 FedTime::operator+=(const FedTime &time)
00163 {
00164 _fedTime += time._fedTime ;
00165 return *this;
00166 }
00167
00168
00169 FedTime &
00170 FedTime::operator-=(const FedTime &time)
00171 {
00172 _fedTime -= time._fedTime ;
00173 return *this;
00174 }
00175
00176
00177 bool
00178 FedTime::operator<=(const FedTime &time) const
00179 {
00180 if (const_cast<FedTime &>(time).isPositiveInfinity())
00181 return true;
00182 else if (isPositiveInfinity())
00183 return false;
00184 else
00185 return bool(::fcmp(_fedTime, time._fedTime, _epsilon) <= 0);
00186 }
00187
00188
00189 bool
00190 FedTime::operator<(const FedTime &time) const
00191 {
00192 if (isPositiveInfinity())
00193 return false;
00194 else
00195 return bool(time.isPositiveInfinity() || ::fcmp(_fedTime, time._fedTime, _epsilon) < 0);
00196 }
00197
00198
00199 bool
00200 FedTime::operator>=(const FedTime &time) const
00201 {
00202 if (isPositiveInfinity())
00203 return true;
00204 else if (time.isPositiveInfinity())
00205 return false;
00206 else
00207 return bool(::fcmp(_fedTime, time._fedTime, _epsilon) >= 0);
00208 }
00209
00210
00211 bool
00212 FedTime::operator>(const FedTime &time) const
00213 {
00214 if (time.isPositiveInfinity())
00215 return false;
00216 else
00217 return bool(isPositiveInfinity() || ::fcmp(_fedTime, time._fedTime, _epsilon) > 0);
00218 }
00219
00220
00221 bool
00222 FedTime::operator==(const FedTime &time) const
00223 {
00224 if (isPositiveInfinity() && time.isPositiveInfinity())
00225 return true;
00226 else if (isPositiveInfinity() || time.isPositiveInfinity())
00227 return false;
00228 else
00229 return bool(::fcmp(_fedTime, time._fedTime, _epsilon) == 0);
00230 }
00231
00232
00233 double
00234 FedTime::getTime() const
00235 {
00236 return _fedTime ;
00237 }
00238
00239
00240 bool
00241 FedTime::operator==(const double &time) const
00242 {
00243 return bool(!isPositiveInfinity() && ::fcmp(_fedTime, time, _epsilon) == 0);
00244 }
00245
00246
00247 bool
00248 FedTime::operator!=(const FedTime &time) const
00249 {
00250 return bool(::fcmp(_fedTime, time._fedTime, _epsilon) != 0);
00251 }
00252
00253
00254 bool
00255 FedTime::operator!=(const double &time) const
00256 {
00257 return bool(isPositiveInfinity() || ::fcmp(_fedTime, time, _epsilon) != 0);
00258 }
00259
00260
00261 FedTime &
00262 FedTime::operator=(const FedTime &time)
00263 {
00264 _fedTime = time._fedTime ;
00265 return *this ;
00266 }
00267
00268
00269 FedTime &
00270 FedTime::operator=(const double &time)
00271 {
00272 _fedTime = time ;
00273 return *this ;
00274 }
00275
00276 FedTime &
00277 FedTime::operator*=(const FedTime &time)
00278 {
00279 _fedTime *= time._fedTime ;
00280 return *this ;
00281 }
00282
00283 FedTime &
00284 FedTime::operator/=(const FedTime &time)
00285 {
00286 _fedTime /= time._fedTime ;
00287 return *this ;
00288 }
00289
00290 FedTime &
00291 FedTime::operator+=(const double &time)
00292 {
00293 _fedTime += time ;
00294 return *this ;
00295 }
00296
00297 FedTime &
00298 FedTime::operator-=(const double &time)
00299 {
00300 _fedTime -= time ;
00301 return *this ;
00302 }
00303
00304 FedTime &
00305 FedTime::operator*=(const double &time)
00306 {
00307 _fedTime *= time ;
00308 return *this ;
00309 }
00310
00311 FedTime &
00312 FedTime::operator/=(const double &time)
00313 {
00314 _fedTime /= time ;
00315 return *this ;
00316 }
00317
00318
00319 FedTime
00320 FedTime::operator+(const FedTime &time)
00321 {
00322 FedTime fedtime = _fedTime + time._fedTime ;
00323 return fedtime ;
00324 }
00325
00326 FedTime
00327 FedTime::operator+(const double &time)
00328 {
00329 FedTime fedtime = _fedTime + time ;
00330 return fedtime ;
00331 }
00332
00333
00334 FedTime
00335 FedTime::operator-(const FedTime &time)
00336 {
00337 FedTime fedtime = _fedTime - time._fedTime ;
00338 return fedtime ;
00339 }
00340
00341 FedTime
00342 FedTime::operator-(const double &time)
00343 {
00344 FedTime fedtime = _fedTime - time ;
00345 return fedtime ;
00346 }
00347
00348
00349 FedTime
00350 FedTime::operator*(const FedTime &time)
00351 {
00352 FedTime fedtime = _fedTime * time._fedTime ;
00353 return fedtime ;
00354 }
00355
00356 FedTime
00357 FedTime::operator*(const double &time)
00358 {
00359 FedTime fedtime = _fedTime * time ;
00360 return fedtime ;
00361 }
00362
00363
00364 FedTime
00365 FedTime::operator/(const FedTime &time)
00366 {
00367 FedTime fedtime = _fedTime / time._fedTime ;
00368 return fedtime ;
00369 }
00370
00371 FedTime
00372 FedTime::operator/(const double &time)
00373 {
00374 FedTime fedtime = _fedTime / time ;
00375 return fedtime ;
00376 }
00377
00378
00379 namespace certi {
00380 std::ostream &
00381 operator<<(std::ostream &s, const FedTime &time)
00382 {
00383 if (time.isPositiveInfinity())
00384 s << infinity_str ;
00385 else
00386 s << time.getTime();
00387 return s ;
00388 }
00389 }
00390
00391
00392
00393 FedTime
00394 operator+(const double &d, const FedTime &time)
00395 {
00396 FedTime fedtime = d + time.getTime();
00397 return fedtime ;
00398 }
00399
00400
00401 FedTime
00402 operator-(const double &d, const FedTime &time)
00403 {
00404 FedTime fedtime = d - time.getTime();
00405 return fedtime ;
00406 }
00407
00408
00409 FedTime
00410 operator*(const double &d, const FedTime &time)
00411 {
00412 FedTime fedtime = d * time.getTime();
00413 return fedtime ;
00414 }
00415
00416
00417 FedTime
00418 operator/(const double &d, const FedTime &time)
00419 {
00420 FedTime fedtime = d / time.getTime();
00421 return fedtime ;
00422 }
00423
00424
00425