00001
00002
00003
00004
00005
00006
00007 #ifdef STORM_USEF
00008 #include "g1ifwt2ds_.h"
00009 #include "dg1ifwt2ds_.h"
00010 #include "g1ifwt2dsws_.h"
00011 #include "dg1ifwt2dsws_.h"
00012 #endif
00013
00014 #include "stormdef.h"
00015 #define H00 STORMDEF_MATHCONST_GHB1H00
00016 #define H10 STORMDEF_MATHCONST_GHB1H10
00017 #define H11 STORMDEF_MATHCONST_GHB1H11
00018
00019
00020 int g1ifwt2ds(
00021 const int& Sizef2d,
00022 const int& ns,
00023 const int& size,
00024 const float* wdata,
00025 float* sdata
00026 ) {
00027
00028 #ifdef STORM_USEF
00029
00030 int iflag;
00031 g1ifwt2ds_( &Sizef2d, &ns, &size, wdata, sdata, &iflag );
00032 return iflag;
00033
00034 #else
00035
00036 int ii,size2;
00037 int size1 = ns;
00038
00039 #ifdef STORM_FWT_CCHECKUSAGE
00040 if ( size1 < ns ) return 1;
00041 #endif
00042
00043 for( int i = 0; i < 2*size*size; i++ ) {
00044 sdata[i] = wdata[i];
00045 }
00046
00047 if ( size == ns ) return 0;
00048
00049 float *u = new float[2*Sizef2d];
00050 float *v = new float[2*Sizef2d];
00051
00052 while ( size1 < size ) {
00053
00054 size2 = size1;
00055 size1 = 2 * size1;
00056
00057 for( int j = 0; j < size1; j++ ) {
00058 for( int i = 0; i < size1; i++ ) {
00059 ii = i * size;
00060 u[2*i] = sdata[2*(ii+j)];
00061 u[2*i+1] = sdata[2*(ii+j)+1];
00062 }
00063 for( int i = 0; i < size2; i++ ) {
00064 v[4*i] = H00 * u[2*i]
00065 + H11 * u[2*(size2+i)]
00066 + H10 * u[2*i+1];
00067 v[4*i+1] = - H10 * u[2*(size2+i)]
00068 + H11 * u[2*i+1]
00069 + H00 * u[2*(size2+i)+1];
00070 v[4*i+2] = H00 * u[2*i]
00071 - H11 * u[2*(size2+i)]
00072 - H10 * u[2*i+1];
00073 v[4*i+3] = - H10 * u[2*(size2+i)]
00074 + H11 * u[2*i+1]
00075 - H00 * u[2*(size2+i)+1];
00076 }
00077 for( int i = 0; i < size1; i++ ) {
00078 ii = i * size;
00079 sdata[2*(ii+j)] = v[2*i];
00080 sdata[2*(ii+j)+1] = v[2*i+1];
00081 }
00082 }
00083
00084 for( int i = 0; i < size1; i++ ) {
00085 ii = i * size;
00086 for( int j = 0; j < size1; j++ ) {
00087 u[2*j] = sdata[2*(ii+j)];
00088 u[2*j+1] = sdata[2*(ii+j)+1];
00089 }
00090 for( int j = 0; j < size2; j++ ) {
00091 v[4*j] = H00 * u[2*j]
00092 + H11 * u[2*(size2+j)]
00093 + H10 * u[2*j+1];
00094 v[4*j+1] = - H10 * u[2*(size2+j)]
00095 + H11 * u[2*j+1]
00096 + H00 * u[2*(size2+j)+1];
00097 v[4*j+2] = H00 * u[2*j]
00098 - H11 * u[2*(size2+j)]
00099 - H10 * u[2*j+1];
00100 v[4*j+3] = - H10 * u[2*(size2+j)]
00101 + H11 * u[2*j+1]
00102 - H00 * u[2*(size2+j)+1];
00103 }
00104 for( int j = 0; j < size1; j++ ) {
00105 sdata[2*(ii+j)] = v[2*j];
00106 sdata[2*(ii+j)+1] = v[2*j+1];
00107 }
00108 }
00109 }
00110 delete [] u;
00111 delete [] v;
00112
00113 #ifdef STORM_FWT_CCHECKUSAGE
00114 if ( size1 > size ) return 2;
00115 #endif
00116
00117 return 0;
00118
00119 #endif
00120
00121 }
00122
00123
00124
00125 int g1ifwt2ds(
00126 const int& Sizef2d,
00127 const int& ns,
00128 const int& size,
00129 const double* wdata,
00130 double* sdata
00131 ) {
00132
00133 #ifdef STORM_USEF
00134
00135 int iflag;
00136 dg1ifwt2ds_( &Sizef2d, &ns, &size, wdata, sdata, &iflag );
00137 return iflag;
00138
00139 #else
00140
00141 int ii,size2;
00142 int size1 = ns;
00143
00144 #ifdef STORM_FWT_CCHECKUSAGE
00145 if ( size1 < ns ) return 1;
00146 #endif
00147
00148 for( int i = 0; i < 2*size*size; i++ ) {
00149 sdata[i] = wdata[i];
00150 }
00151
00152 if ( size == ns ) return 0;
00153
00154 double *u = new double[2*Sizef2d];
00155 double *v = new double[2*Sizef2d];
00156
00157 while ( size1 < size ) {
00158
00159 size2 = size1;
00160 size1 = 2 * size1;
00161
00162 for( int j = 0; j < size1; j++ ) {
00163 for( int i = 0; i < size1; i++ ) {
00164 ii = i * size;
00165 u[2*i] = sdata[2*(ii+j)];
00166 u[2*i+1] = sdata[2*(ii+j)+1];
00167 }
00168 for( int i = 0; i < size2; i++ ) {
00169 v[4*i] = H00 * u[2*i]
00170 + H11 * u[2*(size2+i)]
00171 + H10 * u[2*i+1];
00172 v[4*i+1] = - H10 * u[2*(size2+i)]
00173 + H11 * u[2*i+1]
00174 + H00 * u[2*(size2+i)+1];
00175 v[4*i+2] = H00 * u[2*i]
00176 - H11 * u[2*(size2+i)]
00177 - H10 * u[2*i+1];
00178 v[4*i+3] = - H10 * u[2*(size2+i)]
00179 + H11 * u[2*i+1]
00180 - H00 * u[2*(size2+i)+1];
00181 }
00182 for( int i = 0; i < size1; i++ ) {
00183 ii = i * size;
00184 sdata[2*(ii+j)] = v[2*i];
00185 sdata[2*(ii+j)+1] = v[2*i+1];
00186 }
00187 }
00188
00189 for( int i = 0; i < size1; i++ ) {
00190 ii = i * size;
00191 for( int j = 0; j < size1; j++ ) {
00192 u[2*j] = sdata[2*(ii+j)];
00193 u[2*j+1] = sdata[2*(ii+j)+1];
00194 }
00195 for( int j = 0; j < size2; j++ ) {
00196 v[4*j] = H00 * u[2*j]
00197 + H11 * u[2*(size2+j)]
00198 + H10 * u[2*j+1];
00199 v[4*j+1] = - H10 * u[2*(size2+j)]
00200 + H11 * u[2*j+1]
00201 + H00 * u[2*(size2+j)+1];
00202 v[4*j+2] = H00 * u[2*j]
00203 - H11 * u[2*(size2+j)]
00204 - H10 * u[2*j+1];
00205 v[4*j+3] = - H10 * u[2*(size2+j)]
00206 + H11 * u[2*j+1]
00207 - H00 * u[2*(size2+j)+1];
00208 }
00209 for( int j = 0; j < size1; j++ ) {
00210 sdata[2*(ii+j)] = v[2*j];
00211 sdata[2*(ii+j)+1] = v[2*j+1];
00212 }
00213 }
00214 }
00215 delete [] u;
00216 delete [] v;
00217
00218 #ifdef STORM_FWT_CCHECKUSAGE
00219 if ( size1 > size ) return 2;
00220 #endif
00221
00222 return 0;
00223
00224 #endif
00225
00226 }
00227
00228
00229
00230 int g1ifwt2ds(
00231 const int& Sizef2d,
00232 const int& ns,
00233 const int& size,
00234 const float* wdata,
00235 float* sdata,
00236 float* ws
00237 ) {
00238
00239 #ifdef STORM_USEF
00240
00241 int iflag;
00242 g1ifwt2dsws_( &Sizef2d, &ns, &size, wdata, sdata, ws, &iflag );
00243 return iflag;
00244
00245 #else
00246
00247 int ii,size2;
00248 int size1 = ns;
00249 float *u = ws;
00250 float *v = &ws[2*Sizef2d];
00251
00252 #ifdef STORM_FWT_CCHECKUSAGE
00253 if ( size1 < ns ) return 1;
00254 #endif
00255
00256 for( int i = 0; i < 2*size*size; i++ ) {
00257 sdata[i] = wdata[i];
00258 }
00259
00260 if ( size == ns ) return 0;
00261
00262 while ( size1 < size ) {
00263
00264 size2 = size1;
00265 size1 = 2 * size1;
00266
00267 for( int j = 0; j < size1; j++ ) {
00268 for( int i = 0; i < size1; i++ ) {
00269 ii = i * size;
00270 u[2*i] = sdata[2*(ii+j)];
00271 u[2*i+1] = sdata[2*(ii+j)+1];
00272 }
00273 for( int i = 0; i < size2; i++ ) {
00274 v[4*i] = H00 * u[2*i]
00275 + H11 * u[2*(size2+i)]
00276 + H10 * u[2*i+1];
00277 v[4*i+1] = - H10 * u[2*(size2+i)]
00278 + H11 * u[2*i+1]
00279 + H00 * u[2*(size2+i)+1];
00280 v[4*i+2] = H00 * u[2*i]
00281 - H11 * u[2*(size2+i)]
00282 - H10 * u[2*i+1];
00283 v[4*i+3] = - H10 * u[2*(size2+i)]
00284 + H11 * u[2*i+1]
00285 - H00 * u[2*(size2+i)+1];
00286 }
00287 for( int i = 0; i < size1; i++ ) {
00288 ii = i * size;
00289 sdata[2*(ii+j)] = v[2*i];
00290 sdata[2*(ii+j)+1] = v[2*i+1];
00291 }
00292 }
00293
00294 for( int i = 0; i < size1; i++ ) {
00295 ii = i * size;
00296 for( int j = 0; j < size1; j++ ) {
00297 u[2*j] = sdata[2*(ii+j)];
00298 u[2*j+1] = sdata[2*(ii+j)+1];
00299 }
00300 for( int j = 0; j < size2; j++ ) {
00301 v[4*j] = H00 * u[2*j]
00302 + H11 * u[2*(size2+j)]
00303 + H10 * u[2*j+1];
00304 v[4*j+1] = - H10 * u[2*(size2+j)]
00305 + H11 * u[2*j+1]
00306 + H00 * u[2*(size2+j)+1];
00307 v[4*j+2] = H00 * u[2*j]
00308 - H11 * u[2*(size2+j)]
00309 - H10 * u[2*j+1];
00310 v[4*j+3] = - H10 * u[2*(size2+j)]
00311 + H11 * u[2*j+1]
00312 - H00 * u[2*(size2+j)+1];
00313 }
00314 for( int j = 0; j < size1; j++ ) {
00315 sdata[2*(ii+j)] = v[2*j];
00316 sdata[2*(ii+j)+1] = v[2*j+1];
00317 }
00318 }
00319
00320 }
00321
00322 #ifdef STORM_FWT_CCHECKUSAGE
00323 if ( size1 > size ) return 2;
00324 #endif
00325
00326 return 0;
00327
00328 #endif
00329
00330 }
00331
00332
00333
00334 int g1ifwt2ds(
00335 const int& Sizef2d,
00336 const int& ns,
00337 const int& size,
00338 const double* wdata,
00339 double* sdata,
00340 double* ws
00341 ) {
00342
00343 #ifdef STORM_USEF
00344
00345 int iflag;
00346 dg1ifwt2dsws_( &Sizef2d, &ns, &size, wdata, sdata, ws, &iflag );
00347 return iflag;
00348
00349 #else
00350
00351 int ii,size2;
00352 int size1 = ns;
00353 double* u = ws;
00354 double* v = &ws[2*Sizef2d];
00355
00356 #ifdef STORM_FWT_CCHECKUSAGE
00357 if ( size1 < ns ) return 1;
00358 #endif
00359
00360 for( int i = 0; i < 2*size*size; i++ ) {
00361 sdata[i] = wdata[i];
00362 }
00363
00364 if ( size == ns ) return 0;
00365
00366 while ( size1 < size ) {
00367
00368 size2 = size1;
00369 size1 = 2 * size1;
00370
00371 for( int j = 0; j < size1; j++ ) {
00372 for( int i = 0; i < size1; i++ ) {
00373 ii = i * size;
00374 u[2*i] = sdata[2*(ii+j)];
00375 u[2*i+1] = sdata[2*(ii+j)+1];
00376 }
00377 for( int i = 0; i < size2; i++ ) {
00378 v[4*i] =
00379 H00 * u[2*i]
00380 + H11 * u[2*(size2+i)]
00381 + H10 * u[2*i+1];
00382 v[4*i+1] =
00383 - H10 * u[2*(size2+i)]
00384 + H11 * u[2*i+1]
00385 + H00 * u[2*(size2+i)+1];
00386 v[4*i+2] =
00387 H00 * u[2*i]
00388 - H11 * u[2*(size2+i)]
00389 - H10 * u[2*i+1];
00390 v[4*i+3] =
00391 - H10 * u[2*(size2+i)]
00392 + H11 * u[2*i+1]
00393 - H00 * u[2*(size2+i)+1];
00394 }
00395 for( int i = 0; i < size1; i++ ) {
00396 ii = i * size;
00397 sdata[2*(ii+j)] = v[2*i];
00398 sdata[2*(ii+j)+1] = v[2*i+1];
00399 }
00400 }
00401
00402 for( int i = 0; i < size1; i++ ) {
00403 ii = i * size;
00404 for( int j = 0; j < size1; j++ ) {
00405 u[2*j] = sdata[2*(ii+j)];
00406 u[2*j+1] = sdata[2*(ii+j)+1];
00407 }
00408 for( int j = 0; j < size2; j++ ) {
00409 v[4*j] =
00410 H00 * u[2*j]
00411 + H11 * u[2*(size2+j)]
00412 + H10 * u[2*j+1];
00413 v[4*j+1] =
00414 - H10 * u[2*(size2+j)]
00415 + H11 * u[2*j+1]
00416 + H00 * u[2*(size2+j)+1];
00417 v[4*j+2] =
00418 H00 * u[2*j]
00419 - H11 * u[2*(size2+j)]
00420 - H10 * u[2*j+1];
00421 v[4*j+3] =
00422 - H10 * u[2*(size2+j)]
00423 + H11 * u[2*j+1]
00424 - H00 * u[2*(size2+j)+1];
00425 }
00426 for( int j = 0; j < size1; j++ ) {
00427 sdata[2*(ii+j)] = v[2*j];
00428 sdata[2*(ii+j)+1] = v[2*j+1];
00429 }
00430 }
00431
00432 }
00433
00434 #ifdef STORM_FWT_CCHECKUSAGE
00435 if ( size1 > size ) return 2;
00436 #endif
00437
00438 return 0;
00439
00440 #endif
00441
00442 }
00443
00444 #undef H00
00445 #undef H10
00446 #undef H11
00447
