00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef __signals_intervals__
00025 #define __signals_intervals__
00026
00027 #include <math.h>
00028 #include <iostream>
00029
00030 #ifdef WIN32
00031 inline double log2(double e) { return log(e)/log(double(2)); }
00032 #endif
00033
00034 using namespace std;
00035
00036 struct interval
00037 {
00038 bool valid;
00039 double lo;
00040 double hi;
00041
00042 interval () : valid(false), lo(-HUGE_VAL), hi(HUGE_VAL) { }
00043 interval (double n) : valid(true), lo(n), hi(n) { }
00044 interval (double n, double m) : valid(true), lo(min(n,m)), hi(max(n,m)) {}
00045 interval (const interval& r) : valid(r.valid), lo(r.lo), hi(r.hi) { }
00046
00047 bool isconst() { return valid & (lo == hi); }
00048 };
00049
00050 inline ostream& operator<<(ostream& dst, const interval& i)
00051 {
00052 if (i.valid) {
00053 return dst << "interval(" << i.lo << ", " << i.hi << ")";
00054 } else {
00055 return dst << "interval()";
00056 }
00057 }
00058
00059 inline double min(double x, double y) { return (x<y) ? x:y; }
00060 inline double max(double x, double y) { return (x>y) ? x:y; }
00061 inline double min4(double a, double b, double c, double d) { return min(min(a,b),min(c,d)); }
00062 inline double max4(double a, double b, double c, double d) { return max(max(a,b),max(c,d)); }
00063
00064 inline interval reunion(const interval& x, const interval& y)
00065 {
00066 if (x.valid & y.valid) {
00067 return interval(min(x.lo,y.lo), max(x.hi,y.hi));
00068 } else {
00069 return interval();
00070 }
00071 }
00072
00073
00074 inline interval operator+(const interval& x, const interval& y)
00075 {
00076 return (x.valid&y.valid) ? interval(x.lo+y.lo, x.hi+y.hi) : interval();
00077 }
00078
00079 inline interval operator-(const interval& x, const interval& y)
00080 {
00081 return (x.valid & y.valid) ? interval(x.lo-y.hi, x.hi-y.lo) : interval();;
00082 }
00083
00084 inline interval operator*(const interval& x, const interval& y)
00085 {
00086 if (x.valid&y.valid) {
00087 double a=x.lo*y.lo;
00088 double b=x.lo*y.hi;
00089 double c=x.hi*y.lo;
00090 double d=x.hi*y.hi;
00091 return interval(min4(a,b,c,d), max4(a,b,c,d));
00092 } else {
00093 return interval();
00094 }
00095 }
00096
00097 inline interval operator/(const interval& x, const interval& y)
00098 {
00099 return (x.valid && y.valid && (y.lo > 0 | y.hi < 0))
00100 ? x * interval(1/y.hi,1/y.lo)
00101 : interval();
00102 }
00103
00104 inline interval operator%(const interval& x, const interval& y)
00105 {
00106 return (x.valid && y.valid && x.lo >= 0 && y.lo > 0)
00107 ? interval(0,y.hi)
00108 : interval();
00109 }
00110
00111 inline int bitmask (double x) { return (1 << (int(log2(x))+1)) - 1; }
00112
00113
00114
00115 inline interval operator&(const interval& x, const interval& y)
00116 {
00117 if (x.valid && y.valid) {
00118 if (x.lo >= 0 & y.lo >= 0) {
00119 return interval(0, bitmask(x.hi) & bitmask(y.hi));
00120 } else if (y.lo >= 0) {
00121 return interval(0, bitmask(y.hi));
00122 } else if (x.lo >= 0) {
00123 return interval(0, bitmask(y.hi));
00124 } else {
00125 return interval();
00126 }
00127 } else if (x.valid & x.lo >= 0) {
00128 return interval(0, bitmask(x.hi));
00129 } else if (y.valid & y.lo >= 0) {
00130 return interval(0, bitmask(y.hi));
00131 } else {
00132 return interval();
00133 }
00134 }
00135
00136 inline interval operator|(const interval& x, const interval& y)
00137 {
00138 if (x.valid && y.valid && x.lo >= 0 && y.lo >= 0) {
00139 return interval(0, bitmask(x.hi) | bitmask(y.hi));
00140 } else {
00141 return interval();
00142 }
00143 }
00144
00145 inline interval operator^(const interval&, const interval&)
00146 {
00147 return interval();
00148 }
00149
00150 inline interval operator<<(const interval&, const interval&)
00151 {
00152 return interval();
00153 }
00154
00155 inline interval operator>>(const interval&, const interval&)
00156 {
00157 return interval();
00158 }
00159
00160
00161
00162
00163
00164 inline interval operator<(const interval&, const interval&)
00165 {
00166 return interval(0,1);
00167 }
00168
00169 inline interval operator<=(const interval&, const interval&)
00170 {
00171 return interval(0,1);
00172 }
00173
00174 inline interval operator>(const interval&, const interval&)
00175 {
00176 return interval(0,1);
00177 }
00178
00179 inline interval operator>=(const interval&, const interval&)
00180 {
00181 return interval(0,1);
00182 }
00183
00184 inline interval operator==(const interval&, const interval&)
00185 {
00186 return interval(0,1);
00187 }
00188
00189 inline interval operator!=(const interval&, const interval&)
00190 {
00191 return interval(0,1);
00192 }
00193
00194
00195
00196 inline interval min(const interval& x, const interval& y)
00197 {
00198 return interval(min(x.lo,y.lo), min(x.hi,y.hi));
00199 }
00200
00201 inline interval max(const interval& x, const interval& y)
00202 {
00203 return interval(max(x.lo,y.lo), max(x.hi,y.hi));
00204 }
00205
00206 inline interval abs(const interval& x)
00207 {
00208 if (x.valid) {
00209 if (x.lo >= 0) {
00210 return x;
00211 } else if (x.hi < 0) {
00212 return interval(fabs(x.hi), fabs(x.lo));
00213 } else {
00214 return interval(0, max(fabs(x.lo), x.hi));
00215 }
00216 } else {
00217 return x;
00218 }
00219 }
00220
00221 #endif