| |
libFAUDES
Sections
Index
|
tp_timeinterval.hGo to the documentation of this file.00001 /** @file tp_timeinterval.h Class TimeInterval */ 00002 00003 00004 /* 00005 Timeplugin for FAU Discrete Event Systems Library (libfaudes) 00006 00007 Copyright (C) 2007 Ruediger Berndt 00008 Copyright (C) 2007 Thomas Moor 00009 Exclusive copyright is granted to Klaus Schmidt 00010 00011 */ 00012 00013 #ifndef FAUDES_TP_TIMEINTERVAL_H 00014 #define FAUDES_TP_TIMEINTERVAL_H 00015 00016 #include "corefaudes.h" 00017 #include <cstdlib> 00018 #include <cstring> 00019 #include <cfloat> 00020 #include <climits> 00021 #include <iostream> 00022 00023 00024 namespace faudes { 00025 00026 /** 00027 * Type to represent time. 00028 * 00029 * The time plugin will compile with integer or float time type. However, 00030 * we insist in discrete time in the sense that there is a smallest 00031 * time step. So float time would be cosmetic only. 00032 * 00033 * Note that timed generators do not explicitely refer to a physical time unit like e.g. 00034 * hours or seconds. However, it is assumed, that a fixed conversion factor 00035 * from values of type tpTime to some physical unit exists. Thus, we say tpTime 00036 * variables hold time in faudes-time units. We feel that this is consistent with 00037 * Alur's timed automata. 00038 * 00039 * @ingroup TimedPlugin 00040 */ 00041 class tpTime { 00042 public: 00043 /** Datatype for point on time axis */ 00044 typedef long int Type; 00045 /** Maximum time, associated with infinitiy */ 00046 const static Type Max=INT_MAX; 00047 /** Minimum time, associated with minus infinitiy */ 00048 const static Type Min=INT_MIN+1; 00049 /** Undefined time value */ 00050 const static Type UnDef=INT_MIN; 00051 /** Smallest representable time step */ 00052 const static Type Step=1; 00053 /** convert to string */ 00054 std::string static Str(Type time) { 00055 if(time == UnDef) return "undef"; 00056 if(time < Min) return "err"; 00057 if(time == Min) return "-inf"; 00058 if(time > Max) return "err"; 00059 if(time == Max) return "inf"; 00060 return ToStringInteger(time); 00061 }; 00062 }; 00063 00064 /* 00065 Alternative time representation: cosmetic float 00066 class tpTime { 00067 public: 00068 typedef double Type; 00069 const static Type Max=FLT_MAX; 00070 const static Type Min=FLT_MIN*0.5; 00071 const static Type UnDef=FLT_MIN; 00072 const static Type Step=0.0001; 00073 }; 00074 */ 00075 00076 00077 00078 /** 00079 * Model of a time interval. An interval consisits of a lower and upper bound, 00080 * plus flags to indicate whether the bounds are inclusive or not. 00081 * The maximum and minimum values of the time data tyle are interpreted as infinity. 00082 * 00083 * 00084 * @ingroup TimedPlugin 00085 */ 00086 class TimeInterval { 00087 00088 public: 00089 00090 /** 00091 * Default constructor - sets time interval to (-inf; +inf) 00092 */ 00093 TimeInterval(void) {SetFull();}; 00094 00095 /** 00096 * Default destructor 00097 */ 00098 ~TimeInterval(void) {}; 00099 00100 /** 00101 * Set the lower bound to a given value. 00102 * If the value is minus infinity, it is set exclusive. Otherwise, 00103 * the exclusive/inclusive flag is kept. 00104 * 00105 * @param time 00106 * The new value of lower bound 00107 */ 00108 void LB(tpTime::Type time) { 00109 if(time <= tpTime::Min) time=tpTime::Min; 00110 if(time >= tpTime::Max) time=tpTime::Max; 00111 mstLB=time; 00112 if(mstLB==tpTime::Min) mbLBincl=false; 00113 } 00114 00115 00116 /** 00117 * Set the upper bound to a given value. 00118 * If the value is infinity, it is set exclusive. Otherwise, 00119 * the exclusive/inclusive flag is kept. 00120 * 00121 * @param time 00122 * The new value of upper bound 00123 */ 00124 void UB(tpTime::Type time) { 00125 if(time <= tpTime::Min) time=tpTime::Min; 00126 if(time >= tpTime::Max) time=tpTime::Max; 00127 mstUB=time; 00128 if(mstUB==tpTime::Max) mbUBincl=false; 00129 } 00130 00131 00132 /** 00133 * Configures the upper bound to be inclusive. 00134 * If the upper bound is infinity, it stays exclusive. 00135 * 00136 * @param incl 00137 */ 00138 void UBincl(bool incl) { 00139 mbUBincl=incl; 00140 if(mstUB>=tpTime::Max) mbUBincl=false; 00141 } 00142 00143 00144 /** 00145 * Configures the lower bound to be inclusive. 00146 * If the lower bound is minus infinity, it stays exclusive. 00147 * 00148 * @param incl 00149 */ 00150 void LBincl(bool incl) { 00151 mbLBincl=incl; 00152 if(mstLB<=tpTime::Min) mbLBincl=false; 00153 } 00154 00155 00156 /** 00157 * Set upper bound to infinity 00158 */ 00159 void setUBinf(void) { 00160 mstUB=tpTime::Max; mbUBincl=false; } 00161 00162 /** 00163 * Set lower bound to infinity 00164 */ 00165 void setLBinf(void) { 00166 mstLB=tpTime::Min; mbLBincl=false; } 00167 00168 /** 00169 * Return upper bound. 00170 * 00171 * @return upper bound 00172 */ 00173 tpTime::Type UB(void) const {return mstUB;} 00174 00175 /** 00176 * Return lower bound. 00177 * 00178 * @return lower bound 00179 */ 00180 tpTime::Type LB(void) const {return mstLB;} 00181 00182 /** 00183 * Test for lower bound inclusive 00184 * 00185 * @return true for inclusive 00186 */ 00187 bool LBincl(void) const {return mbLBincl;} 00188 00189 /** 00190 * Test for upper bound inclusive 00191 * 00192 * @return true for inclusive 00193 */ 00194 bool UBincl(void) const {return mbUBincl;} 00195 00196 /** 00197 * Test for lower bound infinity 00198 * 00199 * @return true for infinity 00200 */ 00201 bool LBinf(void) const {return mstLB == tpTime::Min; } 00202 00203 /** 00204 * Test for upper bound infinity 00205 * 00206 * @return true for infinity 00207 */ 00208 bool UBinf(void) const {return mstUB == tpTime::Max;} 00209 00210 00211 /** 00212 * Convert to canonical representation. 00213 * 00214 * Uses tpTime::Step to convert to aleft closed / right opened 00215 * representation 00216 */ 00217 void Canonical(void); 00218 00219 /** 00220 * Set to full (-inf, +inf) 00221 */ 00222 void SetFull(void) { 00223 mstUB=tpTime::Max; mstLB=tpTime::Min; mbUBincl=false; mbLBincl=false; }; 00224 00225 /** 00226 * Set to empty (1, -1) 00227 */ 00228 void SetEmpty(void) { 00229 mstUB=-1; mstLB=1; mbUBincl=false; mbLBincl=false; }; 00230 00231 /** 00232 * Set to positive [0, inf) 00233 */ 00234 void SetPositive(void) { 00235 mstUB=tpTime::Max; mstLB=0; mbUBincl=false; mbLBincl=true; }; 00236 00237 00238 /** 00239 * Set to negative (-inf, 0] 00240 */ 00241 void SetNegative(void) { 00242 mstLB=tpTime::Min; mstUB=0; mbUBincl=false; mbLBincl=true; }; 00243 00244 /** 00245 * Test whether interval is full 00246 * 00247 * @return 00248 * True if interval is (-inf,+inf) 00249 */ 00250 bool Full(void) const { return (mstUB==tpTime::Max) && (mstLB==tpTime::Min) ;}; 00251 00252 /** 00253 * Test interval for empty set 00254 * 00255 * @return 00256 * True if interval is empty 00257 */ 00258 bool Empty(void) const; 00259 00260 /** 00261 * Test whether interval includes [0,inf) 00262 * 00263 * @return 00264 * True if interval includes [0,inf) 00265 */ 00266 bool IncludesPositive(void) const { 00267 return ( (mstLB<0) || ((mstLB ==0) && mbLBincl) ) && (mstUB==tpTime::Max);}; 00268 00269 /** 00270 * Test whether interval includes (-inf,0] 00271 * 00272 * @return 00273 * True if interval includes (-inf,0] 00274 */ 00275 bool IncludesNegative(void) const { 00276 return ( (mstUB>0) || ((mstUB ==0) && mbUBincl) ) && (mstLB==tpTime::Min);}; 00277 00278 /** 00279 * Test whether a point satisfies interval 00280 * @return 00281 * True if interval includes the point 00282 */ 00283 bool In(tpTime::Type time) const; 00284 00285 00286 /** 00287 * Test whether two intervals are equal. 00288 * 00289 * Note that the test is strictly based on the 00290 * internal representation, ie [0,10] is not equal to [0,11). This 00291 * may change in future implementations to consider the tpTime::TypeStep 00292 * 00293 * @return 00294 * True on equality 00295 */ 00296 bool operator == (const TimeInterval& rOtherInterval) const { 00297 if(mstUB!=rOtherInterval.mstUB) return false; 00298 if(mstLB!=rOtherInterval.mstLB) return false; 00299 if(mbUBincl!=rOtherInterval.mbUBincl) return false; 00300 if(mbLBincl!=rOtherInterval.mbLBincl) return false; 00301 return true; 00302 } 00303 00304 /** 00305 * Test whether two intervals not equal. 00306 * 00307 * Note that the test is strictly based on the 00308 * internal representation, ie [0,10] is not equal to [0,11). This 00309 * may change in future implementations to consider the tpTime::TypeStep 00310 * 00311 * @return 00312 * False on equality 00313 */ 00314 bool operator != (const TimeInterval& rOtherInterval) const { 00315 return ! (*this == rOtherInterval) ; 00316 } 00317 00318 /** 00319 * Transform by left shift and intersection with [0, inf) 00320 * @param time 00321 * Amount to shift left 00322 * 00323 */ 00324 void PositiveLeftShift(tpTime::Type time); 00325 00326 /** 00327 * Intersect this interval with other interval 00328 * 00329 * @param rOtherInterval 00330 * 00331 */ 00332 void Intersect(const TimeInterval& rOtherInterval); 00333 00334 /** 00335 * Intersection of two time intervals. 00336 * 00337 * @param rInterval1 00338 * Reference of first time interval 00339 * @param rInterval2 00340 * Reference of second time interval 00341 * 00342 * @return Intersection of both intervals. 00343 */ 00344 static TimeInterval Intersect(const TimeInterval& rInterval1, const TimeInterval& rInterval2); 00345 00346 00347 /** 00348 * Merge this interval with other interval. 00349 * I.e. find smallest superset of the union of the two intervals. 00350 * 00351 * @param rOtherInterval 00352 * Reference to other time interval 00353 * 00354 */ 00355 void Merge(const TimeInterval& rOtherInterval); 00356 00357 /** 00358 * Merge this interval with other interval. 00359 * I.e. find smallest superset of the union of the two intervals. 00360 * 00361 * @param rInterval1 00362 * Reference of first time interval 00363 * @param rInterval2 00364 * Reference of second time interval 00365 * 00366 * @return Superset of both intervals. 00367 */ 00368 static TimeInterval Merge(const TimeInterval& rInterval1, const TimeInterval& rInterval2); 00369 00370 /** 00371 * Pretty printable string. 00372 * 00373 * @return printable string. 00374 */ 00375 std::string Str(void) const; 00376 00377 00378 private: 00379 00380 /** Upper bound */ 00381 tpTime::Type mstUB; 00382 00383 /** Lower bound */ 00384 tpTime::Type mstLB; 00385 00386 /** Flag to indicate that the upper bound is part of the interval */ 00387 bool mbUBincl; 00388 00389 /** Flag to indicate that lower boundary is part of the interval. */ 00390 bool mbLBincl; 00391 00392 }; 00393 00394 00395 } // end namespace faudes 00396 00397 00398 #endif |
libFAUDES 2.14g --- 2009-12-3 --- c++ source docu by doxygen 1.5.6