00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <cmath>
00023
00024 namespace Gecode { namespace Iter { namespace Ranges {
00025
00037 template <class Val, class UnsVal, class I>
00038 class ScaleUp {
00039 protected:
00041 I i;
00043 int a;
00045 Val cur;
00047 Val end;
00048 public:
00050
00051
00052 ScaleUp(void);
00054 ScaleUp(I& i, int a);
00056 void init(I& i, int a);
00058
00060
00061
00062 bool operator()(void) const;
00064 void operator++(void);
00066
00068
00069
00070 Val min(void) const;
00072 Val max(void) const;
00074 UnsVal width(void) const;
00076 };
00077
00084 template <class I>
00085 class ScaleDown : public MinMax {
00086 protected:
00088 I i;
00090 int a;
00091 public:
00093
00094
00095 ScaleDown(void);
00097 ScaleDown(I& i, int a);
00099 void init(I& i, int a);
00101
00103
00104
00105 void operator++(void);
00107 };
00108
00109
00110
00111 template <class Val, class UnsVal, class I>
00112 forceinline
00113 ScaleUp<Val,UnsVal,I>::ScaleUp(void) {}
00114
00115 template <class Val, class UnsVal, class I>
00116 inline void
00117 ScaleUp<Val,UnsVal,I>::init(I& i0, int a0) {
00118 i = i0; a = a0;
00119 if (i()) {
00120 cur = a * i.min();
00121 end = a * i.max();
00122 } else {
00123 cur = 1;
00124 end = 0;
00125 }
00126 }
00127
00128 template <class Val, class UnsVal, class I>
00129 inline
00130 ScaleUp<Val,UnsVal,I>::ScaleUp(I& i0, int a0) : i(i0), a(a0) {
00131 if (i()) {
00132 cur = a * i.min();
00133 end = a * i.max();
00134 } else {
00135 cur = 1;
00136 end = 0;
00137 }
00138 }
00139
00140 template <class Val, class UnsVal, class I>
00141 forceinline void
00142 ScaleUp<Val,UnsVal,I>::operator++(void) {
00143 if (a == 1) {
00144 ++i;
00145 } else {
00146 cur += a;
00147 if (cur > end) {
00148 ++i;
00149 if (i()) {
00150 cur = a * i.min();
00151 end = a * i.max();
00152 }
00153 }
00154 }
00155 }
00156 template <class Val, class UnsVal, class I>
00157 forceinline bool
00158 ScaleUp<Val,UnsVal,I>::operator()(void) const {
00159 return (a == 1) ? i() : (cur <= end);
00160 }
00161
00162 template <class Val, class UnsVal, class I>
00163 forceinline Val
00164 ScaleUp<Val,UnsVal,I>::min(void) const {
00165 return (a == 1) ? static_cast<Val>(i.min()) : cur;
00166 }
00167 template <class Val, class UnsVal, class I>
00168 forceinline Val
00169 ScaleUp<Val,UnsVal,I>::max(void) const {
00170 return (a == 1) ? static_cast<Val>(i.max()) : cur;
00171 }
00172 template <class Val, class UnsVal, class I>
00173 forceinline UnsVal
00174 ScaleUp<Val,UnsVal,I>::width(void) const {
00175 return (a == 1) ?
00176 static_cast<UnsVal>(i.width()) :
00177 static_cast<UnsVal>(max - min + 1);
00178 }
00179
00180
00181
00182 template <class I>
00183 forceinline void
00184 ScaleDown<I>::operator++(void) {
00185 finish();
00186 while ((mi > ma) && i()) {
00187 mi = static_cast<int>(ceil(static_cast<double>(i.min())/a));
00188 ma = static_cast<int>(floor(static_cast<double>(i.max())/a));
00189 ++i;
00190 }
00191 while (i()) {
00192 int n_mi = static_cast<int>(ceil(static_cast<double>(i.min())/a));
00193 if (n_mi-ma > 1)
00194 break;
00195 int n_ma = static_cast<int>(floor(static_cast<double>(i.max())/a));
00196 if (n_mi <= n_ma) {
00197 ma = n_ma;
00198 }
00199 ++i;
00200 }
00201 }
00202
00203 template <class I>
00204 forceinline
00205 ScaleDown<I>::ScaleDown(void) {}
00206
00207 template <class I>
00208 inline void
00209 ScaleDown<I>::init(I& i0, int a0) {
00210 i = i0; a = a0;
00211 operator++();
00212 }
00213
00214 template <class I>
00215 inline
00216 ScaleDown<I>::ScaleDown(I& i0, int a0) : i(i0), a(a0) {
00217 i = i0; a = a0;
00218 operator++();
00219 }
00220
00221 }}}
00222
00223
00224