Mercurial > octave-nkf
annotate liboctave/mx-inlines.cc @ 8736:53b4fdeacc2e
improve reduction functions
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Fri, 13 Feb 2009 21:04:50 +0100 |
| parents | a1ae2aae903e |
| children | 1bd918cfb6e2 |
| rev | line source |
|---|---|
| 3 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, |
| 4 2003, 2004, 2005, 2006, 2007 John W. Eaton | |
| 3 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 3 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 3 | 21 |
| 22 */ | |
| 23 | |
| 2828 | 24 #if !defined (octave_mx_inlines_h) |
| 25 #define octave_mx_inlines_h 1 | |
| 2804 | 26 |
| 27 #include <cstddef> | |
|
8650
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
28 #include <cmath> |
| 2804 | 29 |
| 5525 | 30 #include "quit.h" |
| 31 | |
| 1650 | 32 #include "oct-cmplx.h" |
| 461 | 33 |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
34 template <class R, class S> |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
35 inline void |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
36 mx_inline_fill_vs (R *r, size_t n, S s) |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
37 { |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
38 for (size_t i = 0; i < n; i++) |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
39 r[i] = s; |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
40 } |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
41 |
| 2811 | 42 #define VS_OP_FCN(F, OP) \ |
| 43 template <class R, class V, class S> \ | |
| 3262 | 44 inline void \ |
| 2811 | 45 F ## _vs (R *r, const V *v, size_t n, S s) \ |
| 46 { \ | |
| 47 for (size_t i = 0; i < n; i++) \ | |
| 48 r[i] = v[i] OP s; \ | |
| 49 } | |
| 50 | |
| 3769 | 51 VS_OP_FCN (mx_inline_add, +) |
| 52 VS_OP_FCN (mx_inline_subtract, -) | |
| 53 VS_OP_FCN (mx_inline_multiply, *) | |
| 54 VS_OP_FCN (mx_inline_divide, /) | |
| 3 | 55 |
| 2804 | 56 #define VS_OP(F, OP, R, V, S) \ |
| 57 static inline R * \ | |
| 58 F (const V *v, size_t n, S s) \ | |
| 59 { \ | |
| 60 R *r = 0; \ | |
| 61 if (n > 0) \ | |
| 62 { \ | |
| 63 r = new R [n]; \ | |
| 2811 | 64 F ## _vs (r, v, n, s); \ |
| 2804 | 65 } \ |
| 66 return r; \ | |
| 67 } | |
| 3 | 68 |
| 2804 | 69 #define VS_OPS(R, V, S) \ |
| 3769 | 70 VS_OP (mx_inline_add, +, R, V, S) \ |
| 71 VS_OP (mx_inline_subtract, -, R, V, S) \ | |
| 72 VS_OP (mx_inline_multiply, *, R, V, S) \ | |
| 73 VS_OP (mx_inline_divide, /, R, V, S) | |
| 3 | 74 |
| 2804 | 75 VS_OPS (double, double, double) |
| 76 VS_OPS (Complex, double, Complex) | |
| 77 VS_OPS (Complex, Complex, double) | |
| 78 VS_OPS (Complex, Complex, Complex) | |
| 3 | 79 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
80 VS_OPS (float, float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
81 VS_OPS (FloatComplex, float, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
82 VS_OPS (FloatComplex, FloatComplex, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
83 VS_OPS (FloatComplex, FloatComplex, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
84 |
| 2811 | 85 #define SV_OP_FCN(F, OP) \ |
| 86 template <class R, class S, class V> \ | |
| 3262 | 87 inline void \ |
| 2811 | 88 F ## _sv (R *r, S s, const V *v, size_t n) \ |
| 89 { \ | |
| 90 for (size_t i = 0; i < n; i++) \ | |
| 91 r[i] = s OP v[i]; \ | |
| 92 } \ | |
| 93 | |
| 3769 | 94 SV_OP_FCN (mx_inline_add, +) |
| 95 SV_OP_FCN (mx_inline_subtract, -) | |
| 96 SV_OP_FCN (mx_inline_multiply, *) | |
| 97 SV_OP_FCN (mx_inline_divide, /) | |
| 2811 | 98 |
| 2804 | 99 #define SV_OP(F, OP, R, S, V) \ |
| 100 static inline R * \ | |
| 101 F (S s, const V *v, size_t n) \ | |
| 102 { \ | |
| 103 R *r = 0; \ | |
| 104 if (n > 0) \ | |
| 105 { \ | |
| 106 r = new R [n]; \ | |
| 2811 | 107 F ## _sv (r, s, v, n); \ |
| 2804 | 108 } \ |
| 109 return r; \ | |
| 110 } | |
| 3 | 111 |
| 2804 | 112 #define SV_OPS(R, S, V) \ |
| 3769 | 113 SV_OP (mx_inline_add, +, R, S, V) \ |
| 114 SV_OP (mx_inline_subtract, -, R, S, V) \ | |
| 115 SV_OP (mx_inline_multiply, *, R, S, V) \ | |
| 116 SV_OP (mx_inline_divide, /, R, S, V) | |
| 3 | 117 |
| 2804 | 118 SV_OPS (double, double, double) |
| 119 SV_OPS (Complex, double, Complex) | |
| 120 SV_OPS (Complex, Complex, double) | |
| 121 SV_OPS (Complex, Complex, Complex) | |
| 3 | 122 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
123 SV_OPS (float, float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
124 SV_OPS (FloatComplex, float, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
125 SV_OPS (FloatComplex, FloatComplex, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
126 SV_OPS (FloatComplex, FloatComplex, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
127 |
| 2811 | 128 #define VV_OP_FCN(F, OP) \ |
| 129 template <class R, class T1, class T2> \ | |
| 3262 | 130 inline void \ |
| 2811 | 131 F ## _vv (R *r, const T1 *v1, const T2 *v2, size_t n) \ |
| 132 { \ | |
| 133 for (size_t i = 0; i < n; i++) \ | |
| 134 r[i] = v1[i] OP v2[i]; \ | |
| 135 } \ | |
| 136 | |
| 3769 | 137 VV_OP_FCN (mx_inline_add, +) |
| 138 VV_OP_FCN (mx_inline_subtract, -) | |
| 139 VV_OP_FCN (mx_inline_multiply, *) | |
| 140 VV_OP_FCN (mx_inline_divide, /) | |
| 2811 | 141 |
| 2804 | 142 #define VV_OP(F, OP, R, T1, T2) \ |
| 143 static inline R * \ | |
| 144 F (const T1 *v1, const T2 *v2, size_t n) \ | |
| 145 { \ | |
| 146 R *r = 0; \ | |
| 147 if (n > 0) \ | |
| 148 { \ | |
| 149 r = new R [n]; \ | |
| 2811 | 150 F ## _vv (r, v1, v2, n); \ |
| 2804 | 151 } \ |
| 152 return r; \ | |
| 153 } | |
| 3 | 154 |
| 2804 | 155 #define VV_OPS(R, T1, T2) \ |
| 3769 | 156 VV_OP (mx_inline_add, +, R, T1, T2) \ |
| 157 VV_OP (mx_inline_subtract, -, R, T1, T2) \ | |
| 158 VV_OP (mx_inline_multiply, *, R, T1, T2) \ | |
| 159 VV_OP (mx_inline_divide, /, R, T1, T2) | |
| 3 | 160 |
| 2804 | 161 VV_OPS (double, double, double) |
| 162 VV_OPS (Complex, double, Complex) | |
| 163 VV_OPS (Complex, Complex, double) | |
| 164 VV_OPS (Complex, Complex, Complex) | |
| 3 | 165 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
166 VV_OPS (float, float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
167 VV_OPS (FloatComplex, float, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
168 VV_OPS (FloatComplex, FloatComplex, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
169 VV_OPS (FloatComplex, FloatComplex, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
170 |
| 2804 | 171 #define VS_OP2(F, OP, V, S) \ |
| 172 static inline V * \ | |
| 173 F (V *v, size_t n, S s) \ | |
| 174 { \ | |
| 175 for (size_t i = 0; i < n; i++) \ | |
| 176 v[i] OP s; \ | |
| 177 return v; \ | |
| 178 } | |
| 3 | 179 |
| 2804 | 180 #define VS_OP2S(V, S) \ |
| 3769 | 181 VS_OP2 (mx_inline_add2, +=, V, S) \ |
| 182 VS_OP2 (mx_inline_subtract2, -=, V, S) \ | |
| 183 VS_OP2 (mx_inline_multiply2, *=, V, S) \ | |
| 184 VS_OP2 (mx_inline_divide2, /=, V, S) \ | |
| 185 VS_OP2 (mx_inline_copy, =, V, S) | |
| 3 | 186 |
| 2804 | 187 VS_OP2S (double, double) |
| 188 VS_OP2S (Complex, double) | |
| 189 VS_OP2S (Complex, Complex) | |
| 3 | 190 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
191 VS_OP2S (float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
192 VS_OP2S (FloatComplex, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
193 VS_OP2S (FloatComplex, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
194 |
| 2804 | 195 #define VV_OP2(F, OP, T1, T2) \ |
| 196 static inline T1 * \ | |
| 197 F (T1 *v1, const T2 *v2, size_t n) \ | |
| 198 { \ | |
| 199 for (size_t i = 0; i < n; i++) \ | |
| 200 v1[i] OP v2[i]; \ | |
| 201 return v1; \ | |
| 202 } | |
| 3 | 203 |
| 2804 | 204 #define VV_OP2S(T1, T2) \ |
| 3769 | 205 VV_OP2 (mx_inline_add2, +=, T1, T2) \ |
| 206 VV_OP2 (mx_inline_subtract2, -=, T1, T2) \ | |
| 207 VV_OP2 (mx_inline_multiply2, *=, T1, T2) \ | |
| 208 VV_OP2 (mx_inline_divide2, /=, T1, T2) \ | |
| 209 VV_OP2 (mx_inline_copy, =, T1, T2) | |
| 3 | 210 |
| 2804 | 211 VV_OP2S (double, double) |
| 212 VV_OP2S (Complex, double) | |
| 213 VV_OP2S (Complex, Complex) | |
| 3 | 214 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
215 VV_OP2S (float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
216 VV_OP2S (FloatComplex, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
217 VV_OP2S (FloatComplex, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
218 |
| 2804 | 219 #define OP_EQ_FCN(T1, T2) \ |
| 220 static inline bool \ | |
| 3769 | 221 mx_inline_equal (const T1 *x, const T2 *y, size_t n) \ |
| 2804 | 222 { \ |
| 223 for (size_t i = 0; i < n; i++) \ | |
| 224 if (x[i] != y[i]) \ | |
| 225 return false; \ | |
| 226 return true; \ | |
| 227 } | |
| 3 | 228 |
| 2828 | 229 OP_EQ_FCN (bool, bool) |
| 2804 | 230 OP_EQ_FCN (char, char) |
| 231 OP_EQ_FCN (double, double) | |
| 232 OP_EQ_FCN (Complex, Complex) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
233 OP_EQ_FCN (float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
234 OP_EQ_FCN (FloatComplex, FloatComplex) |
| 3 | 235 |
| 2804 | 236 #define OP_DUP_FCN(OP, F, R, T) \ |
| 237 static inline R * \ | |
| 238 F (const T *x, size_t n) \ | |
| 239 { \ | |
| 240 R *r = 0; \ | |
| 241 if (n > 0) \ | |
| 242 { \ | |
| 243 r = new R [n]; \ | |
| 244 for (size_t i = 0; i < n; i++) \ | |
| 245 r[i] = OP (x[i]); \ | |
| 246 } \ | |
| 247 return r; \ | |
| 248 } | |
| 3 | 249 |
| 3769 | 250 OP_DUP_FCN (, mx_inline_dup, double, double) |
| 251 OP_DUP_FCN (, mx_inline_dup, Complex, Complex) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
252 OP_DUP_FCN (, mx_inline_dup, float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
253 OP_DUP_FCN (, mx_inline_dup, FloatComplex, FloatComplex) |
| 3 | 254 |
| 2804 | 255 // These should really return a bool *. Also, they should probably be |
| 256 // in with a collection of other element-by-element boolean ops. | |
| 3769 | 257 OP_DUP_FCN (0.0 ==, mx_inline_not, double, double) |
| 258 OP_DUP_FCN (0.0 ==, mx_inline_not, double, Complex) | |
| 3 | 259 |
| 3769 | 260 OP_DUP_FCN (, mx_inline_make_complex, Complex, double) |
| 2804 | 261 |
| 3769 | 262 OP_DUP_FCN (-, mx_inline_change_sign, double, double) |
| 263 OP_DUP_FCN (-, mx_inline_change_sign, Complex, Complex) | |
| 3 | 264 |
|
8650
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
265 OP_DUP_FCN (std::abs, mx_inline_fabs_dup, double, double) |
|
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
266 OP_DUP_FCN (std::abs, mx_inline_cabs_dup, double, Complex) |
| 3769 | 267 OP_DUP_FCN (real, mx_inline_real_dup, double, Complex) |
| 268 OP_DUP_FCN (imag, mx_inline_imag_dup, double, Complex) | |
| 269 OP_DUP_FCN (conj, mx_inline_conj_dup, Complex, Complex) | |
| 3 | 270 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
271 OP_DUP_FCN (0.0 ==, mx_inline_not, float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
272 OP_DUP_FCN (static_cast<float>(0.0) ==, mx_inline_not, float, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
273 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
274 OP_DUP_FCN (, mx_inline_make_complex, FloatComplex, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
275 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
276 OP_DUP_FCN (-, mx_inline_change_sign, float, float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
277 OP_DUP_FCN (-, mx_inline_change_sign, FloatComplex, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
278 |
|
8650
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
279 OP_DUP_FCN (std::abs, mx_inline_fabs_dup, float, float) |
|
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
280 OP_DUP_FCN (std::abs, mx_inline_cabs_dup, float, FloatComplex) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
281 OP_DUP_FCN (real, mx_inline_real_dup, float, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
282 OP_DUP_FCN (imag, mx_inline_imag_dup, float, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
283 OP_DUP_FCN (conj, mx_inline_conj_dup, FloatComplex, FloatComplex) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
284 |
|
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
285 // NOTE: std::norm is NOT equivalent |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
286 template <class T> |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
287 T cabsq (const std::complex<T>& c) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
288 { return c.real () * c.real () + c.imag () * c.imag (); } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
289 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
290 #define OP_RED_SUM(ac, el) ac += el |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
291 #define OP_RED_PROD(ac, el) ac *= el |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
292 #define OP_RED_SUMSQ(ac, el) ac += el*el |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
293 #define OP_RED_SUMSQC(ac, el) ac += cabsq (el) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
294 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
295 #define OP_RED_FCN(F, TSRC, OP, ZERO) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
296 template <class T> \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
297 inline T \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
298 F (const TSRC* v, octave_idx_type n) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
299 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
300 T ac = ZERO; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
301 for (octave_idx_type i = 0; i < n; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
302 OP(ac, v[i]); \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
303 return ac; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
304 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
305 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
306 OP_RED_FCN (mx_inline_sum, T, OP_RED_SUM, 0) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
307 OP_RED_FCN (mx_inline_prod, T, OP_RED_PROD, 1) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
308 OP_RED_FCN (mx_inline_sumsq, T, OP_RED_SUMSQ, 0) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
309 OP_RED_FCN (mx_inline_sumsq, std::complex<T>, OP_RED_SUMSQC, 0) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
310 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
311 #define OP_RED_FCN2(F, TSRC, OP, ZERO) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
312 template <class T> \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
313 inline void \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
314 F (const TSRC* v, T *r, octave_idx_type m, octave_idx_type n) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
315 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
316 for (octave_idx_type i = 0; i < m; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
317 r[i] = ZERO; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
318 for (octave_idx_type j = 0; j < n; j++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
319 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
320 for (octave_idx_type i = 0; i < m; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
321 OP(r[i], v[i]); \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
322 v += m; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
323 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
324 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
325 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
326 OP_RED_FCN2 (mx_inline_sum, T, OP_RED_SUM, 0) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
327 OP_RED_FCN2 (mx_inline_prod, T, OP_RED_PROD, 1) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
328 OP_RED_FCN2 (mx_inline_sumsq, T, OP_RED_SUMSQ, 0) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
329 OP_RED_FCN2 (mx_inline_sumsq, std::complex<T>, OP_RED_SUMSQC, 0) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
330 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
331 #define OP_RED_FCNN(F, TSRC) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
332 template <class T> \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
333 inline void \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
334 F (const TSRC *v, T *r, octave_idx_type l, \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
335 octave_idx_type n, octave_idx_type u) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
336 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
337 if (l == 1) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
338 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
339 for (octave_idx_type i = 0; i < u; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
340 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
341 r[i] = F (v, n); \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
342 v += n; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
343 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
344 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
345 else \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
346 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
347 for (octave_idx_type i = 0; i < u; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
348 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
349 F (v, r, l, n); \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
350 v += l*n; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
351 r += l; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
352 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
353 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
354 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
355 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
356 OP_RED_FCNN (mx_inline_sum, T) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
357 OP_RED_FCNN (mx_inline_prod, T) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
358 OP_RED_FCNN (mx_inline_sumsq, T) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
359 OP_RED_FCNN (mx_inline_sumsq, std::complex<T>) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
360 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
361 #define OP_CUM_FCN(F, OP) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
362 template <class T> \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
363 inline void \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
364 F (const T *v, T *r, octave_idx_type n) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
365 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
366 if (n) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
367 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
368 T t = r[0] = v[0]; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
369 for (octave_idx_type i = 1; i < n; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
370 r[i] = t = t OP v[i]; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
371 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
372 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
373 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
374 OP_CUM_FCN (mx_inline_cumsum, +) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
375 OP_CUM_FCN (mx_inline_cumprod, *) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
376 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
377 #define OP_CUM_FCN2(F, OP) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
378 template <class T> \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
379 inline void \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
380 F (const T *v, T *r, octave_idx_type m, octave_idx_type n) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
381 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
382 if (n) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
383 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
384 for (octave_idx_type i = 0; i < m; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
385 r[i] = v[i]; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
386 const T *r0 = r; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
387 for (octave_idx_type j = 1; j < n; j++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
388 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
389 r += m; v += m; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
390 for (octave_idx_type i = 0; i < m; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
391 r[i] = v[i] OP r0[i]; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
392 r0 += m; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
393 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
394 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
395 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
396 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
397 OP_CUM_FCN2 (mx_inline_cumsum, +) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
398 OP_CUM_FCN2 (mx_inline_cumprod, *) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
399 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
400 #define OP_CUM_FCNN(F) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
401 template <class T> \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
402 inline void \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
403 F (const T *v, T *r, octave_idx_type l, \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
404 octave_idx_type n, octave_idx_type u) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
405 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
406 if (l == 1) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
407 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
408 for (octave_idx_type i = 0; i < u; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
409 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
410 F (v, r, n); \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
411 v += n; r += n; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
412 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
413 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
414 else \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
415 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
416 for (octave_idx_type i = 0; i < u; i++) \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
417 { \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
418 F (v, r, l, n); \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
419 v += l*n; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
420 r += l*n; \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
421 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
422 } \ |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
423 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
424 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
425 OP_CUM_FCNN (mx_inline_cumsum) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
426 OP_CUM_FCNN (mx_inline_cumprod) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
427 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
428 // Assistant function |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
429 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
430 inline void |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
431 get_extent_triplet (const dim_vector& dims, int& dim, |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
432 octave_idx_type& l, octave_idx_type& n, |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
433 octave_idx_type& u) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
434 { |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
435 octave_idx_type ndims = dims.length (); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
436 if (dim >= ndims) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
437 { |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
438 l = dims.numel (); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
439 n = 1; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
440 u = 1; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
441 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
442 else |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
443 { |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
444 if (dim < 0) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
445 { |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
446 // find first non-singleton dim |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
447 for (dim = 0; dims(dim) == 1 && dim < ndims - 1; dim++) ; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
448 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
449 // calculate extent triplet. |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
450 l = 1, n = dims(dim), u = 1; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
451 for (octave_idx_type i = 0; i < dim; i++) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
452 l *= dims (i); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
453 for (octave_idx_type i = dim + 1; i < ndims; i++) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
454 u *= dims (i); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
455 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
456 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
457 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
458 // Appliers. |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
459 // FIXME: is this the best design? C++ gives a lot of options here... |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
460 // maybe it can be done without an explicit parameter? |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
461 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
462 template <class ArrayType, class T> |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
463 inline ArrayType |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
464 do_mx_red_op (const Array<T>& src, int dim, |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
465 void (*mx_red_op) (const T *, typename ArrayType::element_type *, |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
466 octave_idx_type, octave_idx_type, octave_idx_type)) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
467 { |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
468 octave_idx_type l, n, u; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
469 dim_vector dims = src.dims (); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
470 get_extent_triplet (dims, dim, l, n, u); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
471 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
472 // Reduction operation reduces the array size. |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
473 if (dim < dims.length ()) dims(dim) = 1; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
474 dims.chop_trailing_singletons (); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
475 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
476 ArrayType ret (dims); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
477 mx_red_op (src.data (), ret.fortran_vec (), l, n, u); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
478 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
479 return ret; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
480 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
481 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
482 template <class ArrayType, class T> |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
483 inline ArrayType |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
484 do_mx_cum_op (const Array<T>& src, int dim, |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
485 void (*mx_cum_op) (const T *, typename ArrayType::element_type *, |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
486 octave_idx_type, octave_idx_type, octave_idx_type)) |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
487 { |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
488 octave_idx_type l, n, u; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
489 dim_vector dims = src.dims (); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
490 get_extent_triplet (dims, dim, l, n, u); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
491 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
492 // Cumulative operation doesn't reduce the array size. |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
493 ArrayType ret (dims); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
494 mx_cum_op (src.data (), ret.fortran_vec (), l, n, u); |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
495 |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
496 return ret; |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
497 } |
|
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
498 |
| 3864 | 499 // Avoid some code duplication. Maybe we should use templates. |
| 500 | |
| 4015 | 501 #define MX_CUMULATIVE_OP(RET_TYPE, ELT_TYPE, OP) \ |
| 3864 | 502 \ |
| 5275 | 503 octave_idx_type nr = rows (); \ |
| 504 octave_idx_type nc = cols (); \ | |
| 3864 | 505 \ |
| 506 RET_TYPE retval (nr, nc); \ | |
| 507 \ | |
| 508 if (nr > 0 && nc > 0) \ | |
| 509 { \ | |
| 510 if ((nr == 1 && dim == -1) || dim == 1) \ | |
| 511 { \ | |
| 5275 | 512 for (octave_idx_type i = 0; i < nr; i++) \ |
| 3864 | 513 { \ |
| 514 ELT_TYPE t = elem (i, 0); \ | |
| 5275 | 515 for (octave_idx_type j = 0; j < nc; j++) \ |
| 3864 | 516 { \ |
| 517 retval.elem (i, j) = t; \ | |
| 518 if (j < nc - 1) \ | |
| 519 t OP elem (i, j+1); \ | |
| 520 } \ | |
| 521 } \ | |
| 522 } \ | |
| 523 else \ | |
| 524 { \ | |
| 5275 | 525 for (octave_idx_type j = 0; j < nc; j++) \ |
| 3864 | 526 { \ |
| 527 ELT_TYPE t = elem (0, j); \ | |
| 5275 | 528 for (octave_idx_type i = 0; i < nr; i++) \ |
| 3864 | 529 { \ |
| 530 retval.elem (i, j) = t; \ | |
| 531 if (i < nr - 1) \ | |
| 532 t OP elem (i+1, j); \ | |
| 533 } \ | |
| 534 } \ | |
| 535 } \ | |
| 536 } \ | |
| 537 \ | |
| 538 return retval | |
| 539 | |
| 540 #define MX_BASE_REDUCTION_OP(RET_TYPE, ROW_EXPR, COL_EXPR, INIT_VAL, \ | |
| 541 MT_RESULT) \ | |
| 542 \ | |
| 5275 | 543 octave_idx_type nr = rows (); \ |
| 544 octave_idx_type nc = cols (); \ | |
| 3864 | 545 \ |
| 546 RET_TYPE retval; \ | |
| 547 \ | |
| 548 if (nr > 0 && nc > 0) \ | |
| 549 { \ | |
| 550 if ((nr == 1 && dim == -1) || dim == 1) \ | |
| 551 { \ | |
| 552 retval.resize (nr, 1); \ | |
| 5275 | 553 for (octave_idx_type i = 0; i < nr; i++) \ |
| 3864 | 554 { \ |
| 555 retval.elem (i, 0) = INIT_VAL; \ | |
| 5275 | 556 for (octave_idx_type j = 0; j < nc; j++) \ |
| 3864 | 557 { \ |
| 558 ROW_EXPR; \ | |
| 559 } \ | |
| 560 } \ | |
| 561 } \ | |
| 562 else \ | |
| 563 { \ | |
| 564 retval.resize (1, nc); \ | |
| 5275 | 565 for (octave_idx_type j = 0; j < nc; j++) \ |
| 3864 | 566 { \ |
| 567 retval.elem (0, j) = INIT_VAL; \ | |
| 5275 | 568 for (octave_idx_type i = 0; i < nr; i++) \ |
| 3864 | 569 { \ |
| 570 COL_EXPR; \ | |
| 571 } \ | |
| 572 } \ | |
| 573 } \ | |
| 574 } \ | |
| 4139 | 575 else if (nc == 0 && (nr == 0 || (nr == 1 && dim == -1))) \ |
| 576 retval.resize (1, 1, MT_RESULT); \ | |
| 4015 | 577 else if (nr == 0 && (dim == 0 || dim == -1)) \ |
| 578 retval.resize (1, nc, MT_RESULT); \ | |
| 579 else if (nc == 0 && dim == 1) \ | |
| 580 retval.resize (nr, 1, MT_RESULT); \ | |
| 581 else \ | |
| 4139 | 582 retval.resize (nr > 0, nc > 0); \ |
| 3864 | 583 \ |
| 584 return retval | |
| 585 | |
| 586 #define MX_REDUCTION_OP_ROW_EXPR(OP) \ | |
| 587 retval.elem (i, 0) OP elem (i, j) | |
| 588 | |
| 589 #define MX_REDUCTION_OP_COL_EXPR(OP) \ | |
| 590 retval.elem (0, j) OP elem (i, j) | |
| 591 | |
| 592 #define MX_REDUCTION_OP(RET_TYPE, OP, INIT_VAL, MT_RESULT) \ | |
| 593 MX_BASE_REDUCTION_OP (RET_TYPE, \ | |
| 594 MX_REDUCTION_OP_ROW_EXPR (OP), \ | |
| 595 MX_REDUCTION_OP_COL_EXPR (OP), \ | |
| 596 INIT_VAL, MT_RESULT) | |
| 4015 | 597 |
| 598 #define MX_ANY_ALL_OP_ROW_CODE(TEST_OP, TEST_TRUE_VAL) \ | |
| 599 if (elem (i, j) TEST_OP 0.0) \ | |
| 600 { \ | |
| 601 retval.elem (i, 0) = TEST_TRUE_VAL; \ | |
| 602 break; \ | |
| 603 } | |
| 604 | |
| 605 #define MX_ANY_ALL_OP_COL_CODE(TEST_OP, TEST_TRUE_VAL) \ | |
| 606 if (elem (i, j) TEST_OP 0.0) \ | |
| 607 { \ | |
| 608 retval.elem (0, j) = TEST_TRUE_VAL; \ | |
| 609 break; \ | |
| 610 } | |
| 611 | |
| 612 #define MX_ANY_ALL_OP(DIM, INIT_VAL, TEST_OP, TEST_TRUE_VAL) \ | |
| 613 MX_BASE_REDUCTION_OP (boolMatrix, \ | |
| 614 MX_ANY_ALL_OP_ROW_CODE (TEST_OP, TEST_TRUE_VAL), \ | |
| 615 MX_ANY_ALL_OP_COL_CODE (TEST_OP, TEST_TRUE_VAL), \ | |
| 616 INIT_VAL, INIT_VAL) | |
| 617 | |
| 618 #define MX_ALL_OP(DIM) MX_ANY_ALL_OP (DIM, true, ==, false) | |
| 619 | |
| 620 #define MX_ANY_OP(DIM) MX_ANY_ALL_OP (DIM, false, !=, true) | |
| 621 | |
| 4563 | 622 #define MX_ND_ALL_EXPR elem (iter_idx) == 0 |
| 4556 | 623 |
| 4563 | 624 #define MX_ND_ANY_EXPR elem (iter_idx) != 0 |
| 4556 | 625 |
| 626 #define MX_ND_ALL_EVAL(TEST_EXPR) \ | |
| 5520 | 627 if (retval(result_idx) && (TEST_EXPR)) \ |
| 628 retval(result_idx) = 0; | |
| 4556 | 629 |
| 630 #define MX_ND_ANY_EVAL(TEST_EXPR) \ | |
| 5520 | 631 if (retval(result_idx) || (TEST_EXPR)) \ |
| 632 retval(result_idx) = 1; | |
| 4569 | 633 |
| 5520 | 634 #define MX_ND_REDUCTION(EVAL_EXPR, INIT_VAL, RET_TYPE) \ |
| 4556 | 635 \ |
| 4569 | 636 RET_TYPE retval; \ |
| 4556 | 637 \ |
| 4932 | 638 dim_vector dv = this->dims (); \ |
| 5520 | 639 int nd = this->ndims (); \ |
| 4563 | 640 \ |
| 5955 | 641 int empty = false; \ |
| 4563 | 642 \ |
| 5520 | 643 for (int i = 0; i < nd; i++) \ |
| 4563 | 644 { \ |
| 5955 | 645 if (dv(i) == 0) \ |
| 4563 | 646 { \ |
| 5955 | 647 empty = true; \ |
| 4563 | 648 break; \ |
| 649 } \ | |
| 650 } \ | |
| 651 \ | |
| 5972 | 652 if (nd == 2 && dv(0) == 0 && dv(1) == 0) \ |
| 653 { \ | |
| 654 retval.resize (dim_vector (1, 1), INIT_VAL); \ | |
| 655 return retval; \ | |
| 656 } \ | |
| 657 \ | |
| 5520 | 658 /* We need to find first non-singleton dim. */ \ |
| 659 \ | |
| 660 if (dim == -1) \ | |
| 4556 | 661 { \ |
| 5520 | 662 dim = 0; \ |
| 663 \ | |
| 664 for (int i = 0; i < nd; i++) \ | |
| 4563 | 665 { \ |
| 5520 | 666 if (dv(i) != 1) \ |
| 4563 | 667 { \ |
| 668 dim = i; \ | |
| 669 break; \ | |
| 670 } \ | |
| 671 } \ | |
| 672 } \ | |
| 5520 | 673 else if (dim >= nd) \ |
| 4563 | 674 { \ |
| 5520 | 675 dim = nd++; \ |
| 676 dv.resize (nd, 1); \ | |
| 4563 | 677 } \ |
| 678 \ | |
| 5523 | 679 /* R = op (A, DIM) \ |
| 4563 | 680 \ |
| 5523 | 681 The strategy here is to access the elements of A along the \ |
| 682 dimension specified by DIM. This means that we loop over each \ | |
| 5615 | 683 element of R and adjust the index into A as needed. Store the \ |
| 684 cummulative product of all dimensions of A in CP_SZ. The last \ | |
| 685 element of CP_SZ is the total number of elements of A. */ \ | |
| 4563 | 686 \ |
| 5615 | 687 Array<octave_idx_type> cp_sz (nd+1, 1); \ |
| 688 for (int i = 1; i <= nd; i++) \ | |
| 5523 | 689 cp_sz(i) = cp_sz(i-1)*dv(i-1); \ |
| 5520 | 690 \ |
| 5523 | 691 octave_idx_type reset_at = cp_sz(dim); \ |
| 692 octave_idx_type base_incr = cp_sz(dim+1); \ | |
| 693 octave_idx_type incr = cp_sz(dim); \ | |
| 694 octave_idx_type base = 0; \ | |
| 695 octave_idx_type next_base = base + base_incr; \ | |
| 696 octave_idx_type iter_idx = base; \ | |
| 697 octave_idx_type n_elts = dv(dim); \ | |
| 4556 | 698 \ |
| 5520 | 699 dv(dim) = 1; \ |
| 4556 | 700 \ |
| 5520 | 701 retval.resize (dv, INIT_VAL); \ |
| 4556 | 702 \ |
| 5955 | 703 if (! empty) \ |
| 4556 | 704 { \ |
| 5955 | 705 octave_idx_type nel = dv.numel (); \ |
| 5523 | 706 \ |
| 5955 | 707 octave_idx_type k = 1; \ |
| 708 \ | |
| 709 for (octave_idx_type result_idx = 0; result_idx < nel; result_idx++) \ | |
| 5523 | 710 { \ |
| 5955 | 711 OCTAVE_QUIT; \ |
| 5523 | 712 \ |
| 5955 | 713 for (octave_idx_type j = 0; j < n_elts; j++) \ |
| 714 { \ | |
| 715 OCTAVE_QUIT; \ | |
| 716 \ | |
| 717 EVAL_EXPR; \ | |
| 5520 | 718 \ |
| 5955 | 719 iter_idx += incr; \ |
| 720 } \ | |
| 5523 | 721 \ |
| 5955 | 722 if (k == reset_at) \ |
| 723 { \ | |
| 724 base = next_base; \ | |
| 725 next_base += base_incr; \ | |
| 726 iter_idx = base; \ | |
| 727 k = 1; \ | |
| 728 } \ | |
| 729 else \ | |
| 730 { \ | |
| 731 base++; \ | |
| 732 iter_idx = base; \ | |
| 733 k++; \ | |
| 734 } \ | |
| 735 } \ | |
| 4556 | 736 } \ |
| 737 \ | |
| 4871 | 738 retval.chop_trailing_singletons (); \ |
| 739 \ | |
| 4556 | 740 return retval |
| 4569 | 741 |
| 742 #define MX_ND_REAL_OP_REDUCTION(ASN_EXPR, INIT_VAL) \ | |
| 5520 | 743 MX_ND_REDUCTION (retval(result_idx) ASN_EXPR, INIT_VAL, NDArray) |
| 4569 | 744 |
| 745 #define MX_ND_COMPLEX_OP_REDUCTION(ASN_EXPR, INIT_VAL) \ | |
| 5520 | 746 MX_ND_REDUCTION (retval(result_idx) ASN_EXPR, INIT_VAL, ComplexNDArray) |
| 4569 | 747 |
| 748 #define MX_ND_ANY_ALL_REDUCTION(EVAL_EXPR, VAL) \ | |
| 5520 | 749 MX_ND_REDUCTION (EVAL_EXPR, VAL, boolNDArray) |
| 4556 | 750 |
| 5523 | 751 #define MX_ND_CUMULATIVE_OP(RET_TYPE, ACC_TYPE, INIT_VAL, OP) \ |
| 752 \ | |
| 4584 | 753 RET_TYPE retval; \ |
| 754 \ | |
| 4932 | 755 dim_vector dv = this->dims (); \ |
| 5523 | 756 int nd = this->ndims (); \ |
| 4584 | 757 \ |
| 5955 | 758 bool empty = false; \ |
| 4584 | 759 \ |
| 5523 | 760 for (int i = 0; i < nd; i++) \ |
| 4584 | 761 { \ |
| 5955 | 762 if (dv(i) == 0) \ |
| 4584 | 763 { \ |
| 5955 | 764 empty = true; \ |
| 4584 | 765 break; \ |
| 766 } \ | |
| 767 } \ | |
| 768 \ | |
| 5523 | 769 /* We need to find first non-singleton dim. */ \ |
| 770 \ | |
| 4584 | 771 if (dim == -1) \ |
| 772 { \ | |
| 5523 | 773 dim = 0; \ |
| 774 \ | |
| 775 for (int i = 0; i < nd; i++) \ | |
| 4584 | 776 { \ |
| 5523 | 777 if (dv(i) != 1) \ |
| 4584 | 778 { \ |
| 779 dim = i; \ | |
| 780 break; \ | |
| 781 } \ | |
| 782 } \ | |
| 783 } \ | |
| 5523 | 784 else if (dim >= nd) \ |
| 4584 | 785 { \ |
| 5523 | 786 dim = nd++; \ |
| 787 dv.resize (nd, 1); \ | |
| 4584 | 788 } \ |
| 789 \ | |
| 5523 | 790 /* R = op (A, DIM) \ |
| 4584 | 791 \ |
| 5523 | 792 The strategy here is to access the elements of A along the \ |
| 793 dimension specified by DIM. This means that we loop over each \ | |
| 5611 | 794 element of R and adjust the index into A as needed. Store the \ |
| 5614 | 795 cummulative product of all dimensions of A in CP_SZ. The last \ |
| 796 element of CP_SZ is the total number of elements of A. */ \ | |
| 4584 | 797 \ |
| 5611 | 798 Array<octave_idx_type> cp_sz (nd+1, 1); \ |
| 799 for (int i = 1; i <= nd; i++) \ | |
| 5523 | 800 cp_sz(i) = cp_sz(i-1)*dv(i-1); \ |
| 4584 | 801 \ |
| 5523 | 802 octave_idx_type reset_at = cp_sz(dim); \ |
| 803 octave_idx_type base_incr = cp_sz(dim+1); \ | |
| 804 octave_idx_type incr = cp_sz(dim); \ | |
| 805 octave_idx_type base = 0; \ | |
| 806 octave_idx_type next_base = base + base_incr; \ | |
| 807 octave_idx_type iter_idx = base; \ | |
| 808 octave_idx_type n_elts = dv(dim); \ | |
| 4584 | 809 \ |
| 5523 | 810 retval.resize (dv, INIT_VAL); \ |
| 811 \ | |
| 5955 | 812 if (! empty) \ |
| 813 { \ | |
| 814 octave_idx_type nel = dv.numel () / n_elts; \ | |
| 5523 | 815 \ |
| 5955 | 816 octave_idx_type k = 1; \ |
| 4584 | 817 \ |
| 5955 | 818 for (octave_idx_type i = 0; i < nel; i++) \ |
| 819 { \ | |
| 820 OCTAVE_QUIT; \ | |
| 821 \ | |
| 822 ACC_TYPE prev_val = INIT_VAL; \ | |
| 823 \ | |
| 824 for (octave_idx_type j = 0; j < n_elts; j++) \ | |
| 825 { \ | |
| 826 OCTAVE_QUIT; \ | |
| 5523 | 827 \ |
| 5955 | 828 if (j == 0) \ |
| 829 { \ | |
| 830 retval(iter_idx) = elem (iter_idx); \ | |
| 831 prev_val = retval(iter_idx); \ | |
| 832 } \ | |
| 833 else \ | |
| 834 { \ | |
| 835 prev_val = prev_val OP elem (iter_idx); \ | |
| 836 retval(iter_idx) = prev_val; \ | |
| 837 } \ | |
| 5523 | 838 \ |
| 5955 | 839 iter_idx += incr; \ |
| 840 } \ | |
| 4584 | 841 \ |
| 5955 | 842 if (k == reset_at) \ |
| 5523 | 843 { \ |
| 5955 | 844 base = next_base; \ |
| 845 next_base += base_incr; \ | |
| 846 iter_idx = base; \ | |
| 847 k = 1; \ | |
| 4584 | 848 } \ |
| 849 else \ | |
| 5523 | 850 { \ |
| 5955 | 851 base++; \ |
| 852 iter_idx = base; \ | |
| 853 k++; \ | |
| 854 } \ | |
| 4584 | 855 } \ |
| 5523 | 856 } \ |
| 4584 | 857 \ |
| 5523 | 858 retval.chop_trailing_singletons (); \ |
| 859 \ | |
| 4584 | 860 return retval |
| 861 | |
| 2804 | 862 #endif |
| 3 | 863 |
| 864 /* | |
| 865 ;;; Local Variables: *** | |
| 866 ;;; mode: C++ *** | |
| 867 ;;; End: *** | |
| 868 */ |