00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #if !defined (octave_binmap_h)
00024 #define octave_binmap_h 1
00025
00026 #include "Array.h"
00027 #include "Sparse.h"
00028 #include "Array-util.h"
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055 template <class U, class T, class R, class F>
00056 Array<U>
00057 binmap (const T& x, const Array<R>& ya, F fcn)
00058 {
00059 octave_idx_type len = ya.numel ();
00060
00061 const R *y = ya.data ();
00062
00063 Array<U> result (ya.dims ());
00064 U *p = result.fortran_vec ();
00065
00066 octave_idx_type i;
00067 for (i = 0; i < len - 3; i += 4)
00068 {
00069 octave_quit ();
00070
00071 p[i] = fcn (x, y[i]);
00072 p[i+1] = fcn (x, y[i+1]);
00073 p[i+2] = fcn (x, y[i+2]);
00074 p[i+3] = fcn (x, y[i+3]);
00075 }
00076
00077 octave_quit ();
00078
00079 for (; i < len; i++)
00080 p[i] = fcn (x, y[i]);
00081
00082 return result;
00083 }
00084
00085
00086 template <class U, class T, class R, class F>
00087 Array<U>
00088 binmap (const Array<T>& xa, const R& y, F fcn)
00089 {
00090 octave_idx_type len = xa.numel ();
00091
00092 const R *x = xa.data ();
00093
00094 Array<U> result (xa.dims ());
00095 U *p = result.fortran_vec ();
00096
00097 octave_idx_type i;
00098 for (i = 0; i < len - 3; i += 4)
00099 {
00100 octave_quit ();
00101
00102 p[i] = fcn (x[i], y);
00103 p[i+1] = fcn (x[i+1], y);
00104 p[i+2] = fcn (x[i+2], y);
00105 p[i+3] = fcn (x[i+3], y);
00106 }
00107
00108 octave_quit ();
00109
00110 for (; i < len; i++)
00111 p[i] = fcn (x[i], y);
00112
00113 return result;
00114 }
00115
00116
00117 template <class U, class T, class R, class F>
00118 Array<U>
00119 binmap (const Array<T>& xa, const Array<R>& ya, F fcn, const char *name)
00120 {
00121 if (xa.numel () == 1)
00122 return binmap<U, T, R, F> (xa(0), ya, fcn);
00123 else if (ya.numel () == 1)
00124 return binmap<U, T, R, F> (xa, ya(0), fcn);
00125 else if (xa.dims () != ya.dims ())
00126 gripe_nonconformant (name, xa.dims (), ya.dims ());
00127
00128 octave_idx_type len = xa.numel ();
00129
00130 const T *x = xa.data ();
00131 const T *y = ya.data ();
00132
00133 Array<U> result (xa.dims ());
00134 U *p = result.fortran_vec ();
00135
00136 octave_idx_type i;
00137 for (i = 0; i < len - 3; i += 4)
00138 {
00139 octave_quit ();
00140
00141 p[i] = fcn (x[i], y[i]);
00142 p[i+1] = fcn (x[i+1], y[i+1]);
00143 p[i+2] = fcn (x[i+2], y[i+2]);
00144 p[i+3] = fcn (x[i+3], y[i+3]);
00145 }
00146
00147 octave_quit ();
00148
00149 for (; i < len; i++)
00150 p[i] = fcn (x[i], y[i]);
00151
00152 return result;
00153 }
00154
00155
00156 template <class U, class T, class R, class F>
00157 Sparse<U>
00158 binmap (const T& x, const Sparse<R>& ys, F fcn)
00159 {
00160 octave_idx_type nz = ys.nnz ();
00161 Sparse<U> retval (ys.rows (), ys.cols (), nz);
00162 for (octave_idx_type i = 0; i < nz; i++)
00163 {
00164 octave_quit ();
00165 retval.xdata(i) = fcn (x, ys.data(i));
00166 }
00167
00168 octave_quit ();
00169 retval.maybe_compress ();
00170 return retval;
00171 }
00172
00173
00174 template <class U, class T, class R, class F>
00175 Sparse<U>
00176 binmap (const Sparse<T>& xs, const R& y, F fcn)
00177 {
00178 octave_idx_type nz = xs.nnz ();
00179 Sparse<U> retval (xs.rows (), xs.cols (), nz);
00180 for (octave_idx_type i = 0; i < nz; i++)
00181 {
00182 octave_quit ();
00183 retval.xdata(i) = fcn (xs.data(i), y);
00184 }
00185
00186 octave_quit ();
00187 retval.maybe_compress ();
00188 return retval;
00189 }
00190
00191
00192 template <class U, class T, class R, class F>
00193 Sparse<U>
00194 binmap (const Sparse<T>& xs, const Sparse<R>& ys, F fcn, const char *name)
00195 {
00196 if (xs.rows () == 1 && xs.cols () == 1)
00197 return binmap<U, T, R, F> (xs(0,0), ys, fcn);
00198 else if (ys.rows () == 1 && ys.cols () == 1)
00199 return binmap<U, T, R, F> (xs, ys(0,0), fcn);
00200 else if (xs.dims () != ys.dims ())
00201 gripe_nonconformant (name, xs.dims (), ys.dims ());
00202
00203 T xzero = T ();
00204 R yzero = R ();
00205
00206 U fz = fcn (xzero, yzero);
00207 if (fz == U())
00208 {
00209
00210 octave_idx_type nr = xs.rows (), nc = xs.cols ();
00211 Sparse<T> retval (nr, nc);
00212
00213 octave_idx_type nz = 0;
00214
00215 for (octave_idx_type j = 0; j < nc; j++)
00216 {
00217 octave_quit ();
00218 octave_idx_type ix = xs.cidx(j), iy = ys.cidx(j);
00219 octave_idx_type ux = xs.cidx(j+1), uy = ys.cidx(j+1);
00220 while (ix != ux || iy != uy)
00221 {
00222 octave_idx_type rx = xs.ridx(ix), ry = ys.ridx(ix);
00223 ix += rx <= ry;
00224 iy += ry <= rx;
00225 nz++;
00226 }
00227
00228 retval.xcidx(j+1) = nz;
00229 }
00230
00231
00232 retval.change_capacity (retval.xcidx(nc));
00233
00234
00235 nz = 0;
00236 for (octave_idx_type j = 0; j < nc; j++)
00237 {
00238 octave_quit ();
00239 octave_idx_type ix = xs.cidx(j), iy = ys.cidx(j);
00240 octave_idx_type ux = xs.cidx(j+1), uy = ys.cidx(j+1);
00241 while (ix != ux || iy != uy)
00242 {
00243 octave_idx_type rx = xs.ridx(ix), ry = ys.ridx(ix);
00244 if (rx == ry)
00245 {
00246 retval.xridx(nz) = rx;
00247 retval.xdata(nz) = fcn (xs.data(ix), ys.data(iy));
00248 ix++;
00249 iy++;
00250 }
00251 else if (rx < ry)
00252 {
00253 retval.xridx(nz) = rx;
00254 retval.xdata(nz) = fcn (xs.data(ix), yzero);
00255 ix++;
00256 }
00257 else if (ry < rx)
00258 {
00259 retval.xridx(nz) = ry;
00260 retval.xdata(nz) = fcn (xzero, ys.data(iy));
00261 iy++;
00262 }
00263
00264 nz++;
00265 }
00266 }
00267
00268 retval.maybe_compress ();
00269 return retval;
00270 }
00271 else
00272 return Sparse<U> (binmap<U, T, R, F> (xs.array_value (), ys.array_value (),
00273 fcn, name));
00274 }
00275
00276
00277
00278
00279
00280 template <class U, class T, class R>
00281 inline Array<U>
00282 binmap (const Array<T>& xa, const Array<R>& ya, U (&fcn) (T, R), const char *name)
00283 { return binmap<U, T, R, U (&) (T, R)> (xa, ya, fcn, name); }
00284
00285 template <class U, class T, class R>
00286 inline Array<U>
00287 binmap (const T& x, const Array<R>& ya, U (&fcn) (T, R))
00288 { return binmap<U, T, R, U (&) (T, R)> (x, ya, fcn); }
00289
00290 template <class U, class T, class R>
00291 inline Array<U>
00292 binmap (const Array<T>& xa, const R& y, U (&fcn) (T, R))
00293 { return binmap<U, T, R, U (&) (T, R)> (xa, y, fcn); }
00294
00295 template <class U, class T, class R>
00296 inline Sparse<U>
00297 binmap (const Sparse<T>& xa, const Sparse<R>& ya, U (&fcn) (T, R), const char *name)
00298 { return binmap<U, T, R, U (&) (T, R)> (xa, ya, fcn, name); }
00299
00300 template <class U, class T, class R>
00301 inline Sparse<U>
00302 binmap (const T& x, const Sparse<R>& ya, U (&fcn) (T, R))
00303 { return binmap<U, T, R, U (&) (T, R)> (x, ya, fcn); }
00304
00305 template <class U, class T, class R>
00306 inline Sparse<U>
00307 binmap (const Sparse<T>& xa, const R& y, U (&fcn) (T, R))
00308 { return binmap<U, T, R, U (&) (T, R)> (xa, y, fcn); }
00309
00310
00311
00312 template <class U, class T, class R>
00313 inline Array<U>
00314 binmap (const Array<T>& xa, const Array<R>& ya, U (&fcn) (const T&, const R&), const char *name)
00315 { return binmap<U, T, R, U (&) (const T&, const R&)> (xa, ya, fcn, name); }
00316
00317 template <class U, class T, class R>
00318 inline Array<U>
00319 binmap (const T& x, const Array<R>& ya, U (&fcn) (const T&, const R&))
00320 { return binmap<U, T, R, U (&) (const T&, const R&)> (x, ya, fcn); }
00321
00322 template <class U, class T, class R>
00323 inline Array<U>
00324 binmap (const Array<T>& xa, const R& y, U (&fcn) (const T&, const R&))
00325 { return binmap<U, T, R, U (&) (const T&, const R&)> (xa, y, fcn); }
00326
00327 template <class U, class T, class R>
00328 inline Sparse<U>
00329 binmap (const Sparse<T>& xa, const Sparse<R>& ya, U (&fcn) (const T&, const R&), const char *name)
00330 { return binmap<U, T, R, U (&) (const T&, const R&)> (xa, ya, fcn, name); }
00331
00332 template <class U, class T, class R>
00333 inline Sparse<U>
00334 binmap (const T& x, const Sparse<R>& ya, U (&fcn) (const T&, const R&))
00335 { return binmap<U, T, R, U (&) (const T&, const R&)> (x, ya, fcn); }
00336
00337 template <class U, class T, class R>
00338 inline Sparse<U>
00339 binmap (const Sparse<T>& xa, const R& y, U (&fcn) (const T&, const R&))
00340 { return binmap<U, T, R, U (&) (const T&, const R&)> (xa, y, fcn); }
00341
00342
00343
00344 template <class U, class T, class R>
00345 inline Array<U>
00346 binmap (const Array<T>& xa, const Array<R>& ya, U (&fcn) (const T&, R), const char *name)
00347 { return binmap<U, T, R, U (&) (const T&, R)> (xa, ya, fcn, name); }
00348
00349 template <class U, class T, class R>
00350 inline Array<U>
00351 binmap (const T& x, const Array<R>& ya, U (&fcn) (const T&, R))
00352 { return binmap<U, T, R, U (&) (const T&, R)> (x, ya, fcn); }
00353
00354 template <class U, class T, class R>
00355 inline Array<U>
00356 binmap (const Array<T>& xa, const R& y, U (&fcn) (const T&, R))
00357 { return binmap<U, T, R, U (&) (const T&, R)> (xa, y, fcn); }
00358
00359 template <class U, class T, class R>
00360 inline Sparse<U>
00361 binmap (const Sparse<T>& xa, const Sparse<R>& ya, U (&fcn) (const T&, R), const char *name)
00362 { return binmap<U, T, R, U (&) (const T&, R)> (xa, ya, fcn, name); }
00363
00364 template <class U, class T, class R>
00365 inline Sparse<U>
00366 binmap (const T& x, const Sparse<R>& ya, U (&fcn) (const T&, R))
00367 { return binmap<U, T, R, U (&) (const T&, R)> (x, ya, fcn); }
00368
00369 template <class U, class T, class R>
00370 inline Sparse<U>
00371 binmap (const Sparse<T>& xa, const R& y, U (&fcn) (const T&, R))
00372 { return binmap<U, T, R, U (&) (const T&, R)> (xa, y, fcn); }
00373
00374
00375
00376 template <class U, class T, class R>
00377 inline Array<U>
00378 binmap (const Array<T>& xa, const Array<R>& ya, U (&fcn) (T, const R&), const char *name)
00379 { return binmap<U, T, R, U (&) (T, const R&)> (xa, ya, fcn, name); }
00380
00381 template <class U, class T, class R>
00382 inline Array<U>
00383 binmap (const T& x, const Array<R>& ya, U (&fcn) (T, const R&))
00384 { return binmap<U, T, R, U (&) (T, const R&)> (x, ya, fcn); }
00385
00386 template <class U, class T, class R>
00387 inline Array<U>
00388 binmap (const Array<T>& xa, const R& y, U (&fcn) (T, const R&))
00389 { return binmap<U, T, R, U (&) (T, const R&)> (xa, y, fcn); }
00390
00391 template <class U, class T, class R>
00392 inline Sparse<U>
00393 binmap (const Sparse<T>& xa, const Sparse<R>& ya, U (&fcn) (T, const R&), const char *name)
00394 { return binmap<U, T, R, U (&) (T, const R&)> (xa, ya, fcn, name); }
00395
00396 template <class U, class T, class R>
00397 inline Sparse<U>
00398 binmap (const T& x, const Sparse<R>& ya, U (&fcn) (T, const R&))
00399 { return binmap<U, T, R, U (&) (T, const R&)> (x, ya, fcn); }
00400
00401 template <class U, class T, class R>
00402 inline Sparse<U>
00403 binmap (const Sparse<T>& xa, const R& y, U (&fcn) (T, const R&))
00404 { return binmap<U, T, R, U (&) (T, const R&)> (xa, y, fcn); }
00405
00406 #endif