Mercurial > hg > octave-lyh
annotate liboctave/mx-op-defs.h @ 8920:eb63fbe60fab
update copyright notices
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Sat, 07 Mar 2009 10:41:27 -0500 |
| parents | b756ce0002db |
| children | dc6bda6f9994 |
| rev | line source |
|---|---|
| 2829 | 1 /* |
| 2 | |
| 8920 | 3 Copyright (C) 2008, 2009 Jaroslav Hajek |
| 7017 | 4 Copyright (C) 1996, 1997, 1998, 2000, 2001, 2003, 2004, 2005, 2006, |
| 5 2007 John W. Eaton | |
| 2829 | 6 |
| 7 This file is part of Octave. | |
| 8 | |
| 9 Octave is free software; you can redistribute it and/or modify it | |
| 10 under the terms of the GNU General Public License as published by the | |
| 7016 | 11 Free Software Foundation; either version 3 of the License, or (at your |
| 12 option) any later version. | |
| 2829 | 13 |
| 14 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 17 for more details. | |
| 18 | |
| 19 You should have received a copy of the GNU General Public License | |
| 7016 | 20 along with Octave; see the file COPYING. If not, see |
| 21 <http://www.gnu.org/licenses/>. | |
| 2829 | 22 |
| 23 */ | |
| 24 | |
| 25 #if !defined (octave_mx_op_defs_h) | |
| 26 #define octave_mx_op_defs_h 1 | |
| 27 | |
|
8774
b756ce0002db
split implementation and interface in mx-op-defs and MArray-defs
Jaroslav Hajek <highegg@gmail.com>
parents:
8397
diff
changeset
|
28 #include "mx-op-decl.h" |
| 2829 | 29 #include "mx-inlines.cc" |
| 30 | |
| 2870 | 31 // vector by scalar operations. |
| 32 | |
| 33 #define VS_BIN_OP(R, F, OP, V, S) \ | |
| 34 R \ | |
| 35 F (const V& v, const S& s) \ | |
| 36 { \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
37 octave_idx_type len = v.length (); \ |
| 2870 | 38 \ |
| 39 R r (len); \ | |
| 40 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
41 for (octave_idx_type i = 0; i < len; i++) \ |
| 2870 | 42 r.elem(i) = v.elem(i) OP s; \ |
| 43 \ | |
| 44 return r; \ | |
| 45 } | |
| 46 | |
| 47 #define VS_BIN_OPS(R, V, S) \ | |
| 48 VS_BIN_OP (R, operator +, +, V, S) \ | |
| 49 VS_BIN_OP (R, operator -, -, V, S) \ | |
| 50 VS_BIN_OP (R, operator *, *, V, S) \ | |
| 51 VS_BIN_OP (R, operator /, /, V, S) | |
| 52 | |
| 53 // scalar by vector by operations. | |
| 54 | |
| 55 #define SV_BIN_OP(R, F, OP, S, V) \ | |
| 56 R \ | |
| 57 F (const S& s, const V& v) \ | |
| 58 { \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
59 octave_idx_type len = v.length (); \ |
| 2870 | 60 \ |
| 61 R r (len); \ | |
| 62 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
63 for (octave_idx_type i = 0; i < len; i++) \ |
| 2870 | 64 r.elem(i) = s OP v.elem(i); \ |
| 65 \ | |
| 66 return r; \ | |
| 67 } | |
| 68 | |
| 69 #define SV_BIN_OPS(R, S, V) \ | |
| 70 SV_BIN_OP (R, operator +, +, S, V) \ | |
| 71 SV_BIN_OP (R, operator -, -, S, V) \ | |
| 72 SV_BIN_OP (R, operator *, *, S, V) \ | |
| 73 SV_BIN_OP (R, operator /, /, S, V) | |
| 74 | |
| 75 // vector by vector operations. | |
| 76 | |
| 77 #define VV_BIN_OP(R, F, OP, V1, V2) \ | |
| 78 R \ | |
| 79 F (const V1& v1, const V2& v2) \ | |
| 80 { \ | |
| 81 R r; \ | |
| 82 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
83 octave_idx_type v1_len = v1.length (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
84 octave_idx_type v2_len = v2.length (); \ |
| 2870 | 85 \ |
| 86 if (v1_len != v2_len) \ | |
| 87 gripe_nonconformant (#OP, v1_len, v2_len); \ | |
| 88 else \ | |
| 89 { \ | |
| 90 r.resize (v1_len); \ | |
| 91 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
92 for (octave_idx_type i = 0; i < v1_len; i++) \ |
| 2870 | 93 r.elem(i) = v1.elem(i) OP v2.elem(i); \ |
| 94 } \ | |
| 95 \ | |
| 96 return r; \ | |
| 97 } | |
| 98 | |
| 99 #define VV_BIN_OPS(R, V1, V2) \ | |
| 100 VV_BIN_OP (R, operator +, +, V1, V2) \ | |
| 101 VV_BIN_OP (R, operator -, -, V1, V2) \ | |
| 102 VV_BIN_OP (R, product, *, V1, V2) \ | |
| 103 VV_BIN_OP (R, quotient, /, V1, V2) | |
| 104 | |
| 105 // matrix by scalar operations. | |
| 106 | |
| 107 #define MS_BIN_OP(R, OP, M, S, F) \ | |
| 2829 | 108 R \ |
| 109 OP (const M& m, const S& s) \ | |
| 110 { \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
111 octave_idx_type nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
112 octave_idx_type nc = m.cols (); \ |
| 2829 | 113 \ |
| 114 R r (nr, nc); \ | |
| 115 \ | |
| 116 if (nr > 0 && nc > 0) \ | |
| 117 F ## _vs (r.fortran_vec (), m.data (), nr * nc, s); \ | |
| 118 \ | |
| 119 return r; \ | |
| 120 } | |
| 121 | |
| 2870 | 122 #define MS_BIN_OPS(R, M, S) \ |
| 3769 | 123 MS_BIN_OP (R, operator +, M, S, mx_inline_add) \ |
| 124 MS_BIN_OP (R, operator -, M, S, mx_inline_subtract) \ | |
| 125 MS_BIN_OP (R, operator *, M, S, mx_inline_multiply) \ | |
| 126 MS_BIN_OP (R, operator /, M, S, mx_inline_divide) | |
| 2870 | 127 |
| 4826 | 128 #define MS_CMP_OP(F, OP, M, MC, S, SC) \ |
| 2870 | 129 boolMatrix \ |
| 130 F (const M& m, const S& s) \ | |
| 131 { \ | |
| 132 boolMatrix r; \ | |
| 133 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
134 octave_idx_type nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
135 octave_idx_type nc = m.cols (); \ |
| 2870 | 136 \ |
| 4826 | 137 r.resize (nr, nc); \ |
| 138 \ | |
| 139 if (nr > 0 && nc > 0) \ | |
| 2870 | 140 { \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
141 for (octave_idx_type j = 0; j < nc; j++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
142 for (octave_idx_type i = 0; i < nr; i++) \ |
| 2870 | 143 r.elem(i, j) = MC (m.elem(i, j)) OP SC (s); \ |
| 144 } \ | |
| 145 \ | |
| 146 return r; \ | |
| 147 } | |
| 2829 | 148 |
| 2870 | 149 #define MS_CMP_OPS(M, CM, S, CS) \ |
| 4826 | 150 MS_CMP_OP (mx_el_lt, <, M, CM, S, CS) \ |
| 151 MS_CMP_OP (mx_el_le, <=, M, CM, S, CS) \ | |
| 152 MS_CMP_OP (mx_el_ge, >=, M, CM, S, CS) \ | |
| 153 MS_CMP_OP (mx_el_gt, >, M, CM, S, CS) \ | |
| 154 MS_CMP_OP (mx_el_eq, ==, M, , S, ) \ | |
| 155 MS_CMP_OP (mx_el_ne, !=, M, , S, ) | |
| 2870 | 156 |
| 5030 | 157 #define MS_BOOL_OP(F, OP, M, S, LHS_ZERO, RHS_ZERO) \ |
| 2870 | 158 boolMatrix \ |
| 159 F (const M& m, const S& s) \ | |
| 160 { \ | |
| 161 boolMatrix r; \ | |
| 162 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
163 octave_idx_type nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
164 octave_idx_type nc = m.cols (); \ |
| 2870 | 165 \ |
| 166 if (nr != 0 && nc != 0) \ | |
| 167 { \ | |
| 168 r.resize (nr, nc); \ | |
| 169 \ | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
170 if (xisnan (s)) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
171 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
172 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
173 { \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
174 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
175 for (octave_idx_type j = 0; j < nc; j++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
176 for (octave_idx_type i = 0; i < nr; i++) \ |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
177 if (xisnan (m.elem(i, j))) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
178 { \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
179 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
180 return r; \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
181 } \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
182 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
183 r.elem(i, j) = (m.elem(i, j) != LHS_ZERO) OP (s != RHS_ZERO); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
184 } \ |
| 2870 | 185 } \ |
| 186 \ | |
| 187 return r; \ | |
| 188 } | |
| 189 | |
| 5030 | 190 #define MS_BOOL_OPS2(M, S, LHS_ZERO, RHS_ZERO) \ |
| 191 MS_BOOL_OP (mx_el_and, &&, M, S, LHS_ZERO, RHS_ZERO) \ | |
| 192 MS_BOOL_OP (mx_el_or, ||, M, S, LHS_ZERO, RHS_ZERO) | |
| 193 | |
| 3504 | 194 #define MS_BOOL_OPS(M, S, ZERO) \ |
| 5030 | 195 MS_BOOL_OPS2(M, S, ZERO, ZERO) |
| 2870 | 196 |
| 197 // scalar by matrix operations. | |
| 198 | |
| 199 #define SM_BIN_OP(R, OP, S, M, F) \ | |
| 2829 | 200 R \ |
| 201 OP (const S& s, const M& m) \ | |
| 202 { \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
203 octave_idx_type nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
204 octave_idx_type nc = m.cols (); \ |
| 2829 | 205 \ |
| 206 R r (nr, nc); \ | |
| 207 \ | |
| 208 if (nr > 0 && nc > 0) \ | |
| 209 F ## _sv (r.fortran_vec (), s, m.data (), nr * nc); \ | |
| 210 \ | |
| 211 return r; \ | |
| 212 } | |
| 213 | |
| 2870 | 214 #define SM_BIN_OPS(R, S, M) \ |
| 3769 | 215 SM_BIN_OP (R, operator +, S, M, mx_inline_add) \ |
| 216 SM_BIN_OP (R, operator -, S, M, mx_inline_subtract) \ | |
| 217 SM_BIN_OP (R, operator *, S, M, mx_inline_multiply) \ | |
| 218 SM_BIN_OP (R, operator /, S, M, mx_inline_divide) | |
| 2870 | 219 |
| 4826 | 220 #define SM_CMP_OP(F, OP, S, SC, M, MC) \ |
| 2870 | 221 boolMatrix \ |
| 222 F (const S& s, const M& m) \ | |
| 223 { \ | |
| 224 boolMatrix r; \ | |
| 225 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
226 octave_idx_type nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
227 octave_idx_type nc = m.cols (); \ |
| 2870 | 228 \ |
| 4826 | 229 r.resize (nr, nc); \ |
| 230 \ | |
| 231 if (nr > 0 && nc > 0) \ | |
| 2870 | 232 { \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
233 for (octave_idx_type j = 0; j < nc; j++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
234 for (octave_idx_type i = 0; i < nr; i++) \ |
| 2870 | 235 r.elem(i, j) = SC (s) OP MC (m.elem(i, j)); \ |
| 236 } \ | |
| 237 \ | |
| 238 return r; \ | |
| 239 } | |
| 2829 | 240 |
| 2870 | 241 #define SM_CMP_OPS(S, CS, M, CM) \ |
| 4826 | 242 SM_CMP_OP (mx_el_lt, <, S, CS, M, CM) \ |
| 243 SM_CMP_OP (mx_el_le, <=, S, CS, M, CM) \ | |
| 244 SM_CMP_OP (mx_el_ge, >=, S, CS, M, CM) \ | |
| 245 SM_CMP_OP (mx_el_gt, >, S, CS, M, CM) \ | |
| 246 SM_CMP_OP (mx_el_eq, ==, S, , M, ) \ | |
| 247 SM_CMP_OP (mx_el_ne, !=, S, , M, ) | |
| 2870 | 248 |
| 5030 | 249 #define SM_BOOL_OP(F, OP, S, M, LHS_ZERO, RHS_ZERO) \ |
| 2870 | 250 boolMatrix \ |
| 251 F (const S& s, const M& m) \ | |
| 252 { \ | |
| 253 boolMatrix r; \ | |
| 254 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
255 octave_idx_type nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
256 octave_idx_type nc = m.cols (); \ |
| 2870 | 257 \ |
| 258 if (nr != 0 && nc != 0) \ | |
| 259 { \ | |
| 260 r.resize (nr, nc); \ | |
| 261 \ | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
262 if (xisnan (s)) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
263 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
264 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
265 { \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
266 for (octave_idx_type j = 0; j < nc; j++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
267 for (octave_idx_type i = 0; i < nr; i++) \ |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
268 if (xisnan (m.elem(i, j))) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
269 { \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
270 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
271 return r; \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
272 } \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
273 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
274 r.elem(i, j) = (s != LHS_ZERO) OP (m.elem(i, j) != RHS_ZERO); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
275 } \ |
| 2870 | 276 } \ |
| 277 \ | |
| 278 return r; \ | |
| 279 } | |
| 280 | |
| 5030 | 281 #define SM_BOOL_OPS2(S, M, LHS_ZERO, RHS_ZERO) \ |
| 282 SM_BOOL_OP (mx_el_and, &&, S, M, LHS_ZERO, RHS_ZERO) \ | |
| 283 SM_BOOL_OP (mx_el_or, ||, S, M, LHS_ZERO, RHS_ZERO) | |
| 284 | |
| 3504 | 285 #define SM_BOOL_OPS(S, M, ZERO) \ |
| 5030 | 286 SM_BOOL_OPS2(S, M, ZERO, ZERO) |
| 2870 | 287 |
| 288 // matrix by matrix operations. | |
| 289 | |
| 290 #define MM_BIN_OP(R, OP, M1, M2, F) \ | |
| 2829 | 291 R \ |
| 292 OP (const M1& m1, const M2& m2) \ | |
| 293 { \ | |
| 294 R r; \ | |
| 295 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
296 octave_idx_type m1_nr = m1.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
297 octave_idx_type m1_nc = m1.cols (); \ |
| 2829 | 298 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
299 octave_idx_type m2_nr = m2.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
300 octave_idx_type m2_nc = m2.cols (); \ |
| 2829 | 301 \ |
| 302 if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 303 gripe_nonconformant (#OP, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 304 else \ | |
| 305 { \ | |
| 306 r.resize (m1_nr, m1_nc); \ | |
| 307 \ | |
| 308 if (m1_nr > 0 && m1_nc > 0) \ | |
| 309 F ## _vv (r.fortran_vec (), m1.data (), m2.data (), m1_nr * m1_nc); \ | |
| 310 } \ | |
| 311 \ | |
| 312 return r; \ | |
| 313 } | |
| 314 | |
| 2870 | 315 #define MM_BIN_OPS(R, M1, M2) \ |
| 3769 | 316 MM_BIN_OP (R, operator +, M1, M2, mx_inline_add) \ |
| 317 MM_BIN_OP (R, operator -, M1, M2, mx_inline_subtract) \ | |
| 318 MM_BIN_OP (R, product, M1, M2, mx_inline_multiply) \ | |
| 319 MM_BIN_OP (R, quotient, M1, M2, mx_inline_divide) | |
| 2870 | 320 |
| 4826 | 321 #define MM_CMP_OP(F, OP, M1, C1, M2, C2) \ |
| 2870 | 322 boolMatrix \ |
| 323 F (const M1& m1, const M2& m2) \ | |
| 324 { \ | |
| 325 boolMatrix r; \ | |
| 326 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
327 octave_idx_type m1_nr = m1.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
328 octave_idx_type m1_nc = m1.cols (); \ |
| 2870 | 329 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
330 octave_idx_type m2_nr = m2.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
331 octave_idx_type m2_nc = m2.cols (); \ |
| 2870 | 332 \ |
| 333 if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 334 { \ | |
| 4826 | 335 r.resize (m1_nr, m1_nc); \ |
| 2870 | 336 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
337 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
338 for (octave_idx_type i = 0; i < m1_nr; i++) \ |
| 4826 | 339 r.elem(i, j) = C1 (m1.elem(i, j)) OP C2 (m2.elem(i, j)); \ |
| 2870 | 340 } \ |
| 341 else \ | |
| 4826 | 342 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 2870 | 343 \ |
| 344 return r; \ | |
| 345 } | |
| 2829 | 346 |
| 2870 | 347 #define MM_CMP_OPS(M1, C1, M2, C2) \ |
| 4826 | 348 MM_CMP_OP (mx_el_lt, <, M1, C1, M2, C2) \ |
| 349 MM_CMP_OP (mx_el_le, <=, M1, C1, M2, C2) \ | |
| 350 MM_CMP_OP (mx_el_ge, >=, M1, C1, M2, C2) \ | |
| 351 MM_CMP_OP (mx_el_gt, >, M1, C1, M2, C2) \ | |
| 352 MM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \ | |
| 353 MM_CMP_OP (mx_el_ne, !=, M1, , M2, ) | |
| 2870 | 354 |
| 5030 | 355 #define MM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO) \ |
| 2870 | 356 boolMatrix \ |
| 357 F (const M1& m1, const M2& m2) \ | |
| 358 { \ | |
| 359 boolMatrix r; \ | |
| 360 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
361 octave_idx_type m1_nr = m1.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
362 octave_idx_type m1_nc = m1.cols (); \ |
| 2870 | 363 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
364 octave_idx_type m2_nr = m2.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
365 octave_idx_type m2_nc = m2.cols (); \ |
| 2870 | 366 \ |
| 367 if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 368 { \ | |
| 369 if (m1_nr != 0 || m1_nc != 0) \ | |
| 370 { \ | |
| 371 r.resize (m1_nr, m1_nc); \ | |
| 372 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
373 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
374 for (octave_idx_type i = 0; i < m1_nr; i++) \ |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
375 if (xisnan (m1.elem(i, j)) || xisnan (m2.elem(i, j))) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
376 { \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
377 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
378 return r; \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
379 } \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
380 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
381 r.elem(i, j) = (m1.elem(i, j) != LHS_ZERO) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
382 OP (m2.elem(i, j) != RHS_ZERO); \ |
| 2870 | 383 } \ |
| 384 } \ | |
| 385 else \ | |
| 386 { \ | |
| 387 if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \ | |
| 388 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 389 } \ | |
| 390 \ | |
| 391 return r; \ | |
| 392 } | |
| 393 | |
| 5030 | 394 #define MM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO) \ |
| 395 MM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 396 MM_BOOL_OP (mx_el_or, ||, M1, M2, LHS_ZERO, RHS_ZERO) | |
| 397 | |
| 3504 | 398 #define MM_BOOL_OPS(M1, M2, ZERO) \ |
| 5030 | 399 MM_BOOL_OPS2(M1, M2, ZERO, ZERO) |
| 2870 | 400 |
| 4543 | 401 // N-d matrix by scalar operations. |
| 402 | |
| 403 #define NDS_BIN_OP(R, OP, ND, S, F) \ | |
| 404 R \ | |
| 405 OP (const ND& m, const S& s) \ | |
| 406 { \ | |
| 407 R r (m.dims ()); \ | |
| 408 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
409 octave_idx_type len = m.length (); \ |
| 4543 | 410 \ |
| 411 if (len > 0) \ | |
| 412 F ## _vs (r.fortran_vec (), m.data (), len, s); \ | |
| 413 \ | |
| 414 return r; \ | |
| 415 } | |
| 416 | |
| 417 #define NDS_BIN_OPS(R, ND, S) \ | |
| 418 NDS_BIN_OP (R, operator +, ND, S, mx_inline_add) \ | |
| 419 NDS_BIN_OP (R, operator -, ND, S, mx_inline_subtract) \ | |
| 420 NDS_BIN_OP (R, operator *, ND, S, mx_inline_multiply) \ | |
| 421 NDS_BIN_OP (R, operator /, ND, S, mx_inline_divide) | |
| 422 | |
| 4826 | 423 #define NDS_CMP_OP(F, OP, ND, NDC, S, SC) \ |
| 4543 | 424 boolNDArray \ |
| 425 F (const ND& m, const S& s) \ | |
| 426 { \ | |
| 427 boolNDArray r; \ | |
| 428 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
429 octave_idx_type len = m.length (); \ |
| 4543 | 430 \ |
| 4826 | 431 r.resize (m.dims ()); \ |
| 4543 | 432 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
433 for (octave_idx_type i = 0; i < len; i++) \ |
| 4826 | 434 r.elem(i) = NDC (m.elem(i)) OP SC (s); \ |
| 4543 | 435 \ |
| 436 return r; \ | |
| 437 } | |
| 438 | |
| 439 #define NDS_CMP_OPS(ND, NDC, S, SC) \ | |
| 4826 | 440 NDS_CMP_OP (mx_el_lt, <, ND, NDC, S, SC) \ |
| 441 NDS_CMP_OP (mx_el_le, <=, ND, NDC, S, SC) \ | |
| 442 NDS_CMP_OP (mx_el_ge, >=, ND, NDC, S, SC) \ | |
| 443 NDS_CMP_OP (mx_el_gt, >, ND, NDC, S, SC) \ | |
| 444 NDS_CMP_OP (mx_el_eq, ==, ND, , S, ) \ | |
| 445 NDS_CMP_OP (mx_el_ne, !=, ND, , S, ) | |
| 4543 | 446 |
| 6119 | 447 #define NDS_CMP_OP1(F, OP, ND, NDC, S, SC, SPEC) \ |
| 448 boolNDArray \ | |
| 449 F (const ND& m, const S& s) \ | |
| 450 { \ | |
| 451 boolNDArray r; \ | |
| 452 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
453 octave_idx_type len = m.length (); \ |
| 6119 | 454 \ |
| 455 r.resize (m.dims ()); \ | |
| 456 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
457 for (octave_idx_type i = 0; i < len; i++) \ |
| 6119 | 458 r.elem(i) = operator OP <SPEC> (NDC (m.elem(i)), SC (s)); \ |
| 459 \ | |
| 460 return r; \ | |
| 461 } | |
| 462 | |
| 463 #define NDS_CMP_OPS1(ND, NDC, S, SC, SPEC) \ | |
| 464 NDS_CMP_OP1 (mx_el_lt, <, ND, NDC, S, SC, SPEC) \ | |
| 465 NDS_CMP_OP1 (mx_el_le, <=, ND, NDC, S, SC, SPEC) \ | |
| 466 NDS_CMP_OP1 (mx_el_ge, >=, ND, NDC, S, SC, SPEC) \ | |
| 467 NDS_CMP_OP1 (mx_el_gt, >, ND, NDC, S, SC, SPEC) \ | |
| 468 NDS_CMP_OP1 (mx_el_eq, ==, ND, , S, , SPEC) \ | |
| 469 NDS_CMP_OP1 (mx_el_ne, !=, ND, , S, , SPEC) | |
| 470 | |
| 471 #define NDS_CMP_OP2(F, OP, ND, NDC, S, SC, SPEC1, SPEC2) \ | |
| 472 boolNDArray \ | |
| 473 F (const ND& m, const S& s) \ | |
| 474 { \ | |
| 475 boolNDArray r; \ | |
| 476 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
477 octave_idx_type len = m.length (); \ |
| 6119 | 478 \ |
| 479 r.resize (m.dims ()); \ | |
| 480 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
481 for (octave_idx_type i = 0; i < len; i++) \ |
| 6119 | 482 r.elem(i) = operator OP <SPEC1,SPEC2> (NDC (m.elem(i)), SC (s)); \ |
| 483 \ | |
| 484 return r; \ | |
| 485 } | |
| 486 | |
| 487 #define NDS_CMP_OPS2(ND, NDC, S, SC, SPEC1, SPEC2) \ | |
| 488 NDS_CMP_OP2 (mx_el_lt, <, ND, NDC, S, SC, SPEC1, SPEC2) \ | |
| 489 NDS_CMP_OP2 (mx_el_le, <=, ND, NDC, S, SC, SPEC1, SPEC2) \ | |
| 490 NDS_CMP_OP2 (mx_el_ge, >=, ND, NDC, S, SC, SPEC1, SPEC2) \ | |
| 491 NDS_CMP_OP2 (mx_el_gt, >, ND, NDC, S, SC, SPEC1, SPEC2) \ | |
| 492 NDS_CMP_OP2 (mx_el_eq, ==, ND, , S, , SPEC1, SPEC2) \ | |
| 493 NDS_CMP_OP2 (mx_el_ne, !=, ND, , S, , SPEC1, SPEC2) | |
| 494 | |
| 5030 | 495 #define NDS_BOOL_OP(F, OP, ND, S, LHS_ZERO, RHS_ZERO) \ |
| 4543 | 496 boolNDArray \ |
| 497 F (const ND& m, const S& s) \ | |
| 498 { \ | |
| 499 boolNDArray r; \ | |
| 500 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
501 octave_idx_type len = m.length (); \ |
| 4543 | 502 \ |
| 503 if (len > 0) \ | |
| 504 { \ | |
| 505 r.resize (m.dims ()); \ | |
| 506 \ | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
507 if (xisnan (s)) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
508 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
509 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
510 { \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
511 for (octave_idx_type i = 0; i < len; i++) \ |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
512 if (xisnan (m.elem(i))) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
513 { \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
514 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
515 return r; \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
516 } \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
517 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
518 r.elem(i) = (m.elem(i) != LHS_ZERO) OP (s != RHS_ZERO); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
519 } \ |
| 4543 | 520 } \ |
| 521 \ | |
| 522 return r; \ | |
| 523 } | |
| 524 | |
| 5030 | 525 #define NDS_BOOL_OPS2(ND, S, LHS_ZERO, RHS_ZERO) \ |
| 526 NDS_BOOL_OP (mx_el_and, &&, ND, S, LHS_ZERO, RHS_ZERO) \ | |
| 527 NDS_BOOL_OP (mx_el_or, ||, ND, S, LHS_ZERO, RHS_ZERO) | |
| 528 | |
| 4543 | 529 #define NDS_BOOL_OPS(ND, S, ZERO) \ |
| 5030 | 530 NDS_BOOL_OPS2(ND, S, ZERO, ZERO) |
| 4543 | 531 |
| 532 // scalar by N-d matrix operations. | |
| 533 | |
| 534 #define SND_BIN_OP(R, OP, S, ND, F) \ | |
| 535 R \ | |
| 536 OP (const S& s, const ND& m) \ | |
| 537 { \ | |
| 538 R r (m.dims ()); \ | |
| 539 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
540 octave_idx_type len = m.length (); \ |
| 4543 | 541 \ |
| 542 if (len > 0) \ | |
| 543 F ## _sv (r.fortran_vec (), s, m.data (), len); \ | |
| 544 \ | |
| 545 return r; \ | |
| 546 } | |
| 547 | |
| 548 #define SND_BIN_OPS(R, S, ND) \ | |
| 549 SND_BIN_OP (R, operator +, S, ND, mx_inline_add) \ | |
| 550 SND_BIN_OP (R, operator -, S, ND, mx_inline_subtract) \ | |
| 551 SND_BIN_OP (R, operator *, S, ND, mx_inline_multiply) \ | |
| 552 SND_BIN_OP (R, operator /, S, ND, mx_inline_divide) | |
| 553 | |
| 4826 | 554 #define SND_CMP_OP(F, OP, S, SC, ND, NDC) \ |
| 4543 | 555 boolNDArray \ |
| 556 F (const S& s, const ND& m) \ | |
| 557 { \ | |
| 558 boolNDArray r; \ | |
| 559 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
560 octave_idx_type len = m.length (); \ |
| 4543 | 561 \ |
| 4826 | 562 r.resize (m.dims ()); \ |
| 4543 | 563 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
564 for (octave_idx_type i = 0; i < len; i++) \ |
| 4826 | 565 r.elem(i) = SC (s) OP NDC (m.elem(i)); \ |
| 4543 | 566 \ |
| 567 return r; \ | |
| 568 } | |
| 569 | |
| 570 #define SND_CMP_OPS(S, CS, ND, CND) \ | |
| 4826 | 571 SND_CMP_OP (mx_el_lt, <, S, CS, ND, CND) \ |
| 572 SND_CMP_OP (mx_el_le, <=, S, CS, ND, CND) \ | |
| 573 SND_CMP_OP (mx_el_ge, >=, S, CS, ND, CND) \ | |
| 574 SND_CMP_OP (mx_el_gt, >, S, CS, ND, CND) \ | |
| 575 SND_CMP_OP (mx_el_eq, ==, S, , ND, ) \ | |
| 576 SND_CMP_OP (mx_el_ne, !=, S, , ND, ) | |
| 4543 | 577 |
| 6119 | 578 #define SND_CMP_OP1(F, OP, S, SC, ND, NDC, SPEC) \ |
| 579 boolNDArray \ | |
| 580 F (const S& s, const ND& m) \ | |
| 581 { \ | |
| 582 boolNDArray r; \ | |
| 583 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
584 octave_idx_type len = m.length (); \ |
| 6119 | 585 \ |
| 586 r.resize (m.dims ()); \ | |
| 587 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
588 for (octave_idx_type i = 0; i < len; i++) \ |
| 6119 | 589 r.elem(i) = operator OP <SPEC> (SC (s), NDC (m.elem(i))); \ |
| 590 \ | |
| 591 return r; \ | |
| 592 } | |
| 593 | |
| 594 #define SND_CMP_OPS1(S, CS, ND, CND, SPEC) \ | |
| 595 SND_CMP_OP1 (mx_el_lt, <, S, CS, ND, CND, SPEC) \ | |
| 596 SND_CMP_OP1 (mx_el_le, <=, S, CS, ND, CND, SPEC) \ | |
| 597 SND_CMP_OP1 (mx_el_ge, >=, S, CS, ND, CND, SPEC) \ | |
| 598 SND_CMP_OP1 (mx_el_gt, >, S, CS, ND, CND, SPEC) \ | |
| 599 SND_CMP_OP1 (mx_el_eq, ==, S, , ND, , SPEC) \ | |
| 600 SND_CMP_OP1 (mx_el_ne, !=, S, , ND, , SPEC) | |
| 601 | |
| 602 #define SND_CMP_OP2(F, OP, S, SC, ND, NDC, SPEC1, SPEC2) \ | |
| 603 boolNDArray \ | |
| 604 F (const S& s, const ND& m) \ | |
| 605 { \ | |
| 606 boolNDArray r; \ | |
| 607 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
608 octave_idx_type len = m.length (); \ |
| 6119 | 609 \ |
| 610 r.resize (m.dims ()); \ | |
| 611 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
612 for (octave_idx_type i = 0; i < len; i++) \ |
| 6119 | 613 r.elem(i) = operator OP <SPEC1, SPEC2> (SC (s), NDC (m.elem(i))); \ |
| 614 \ | |
| 615 return r; \ | |
| 616 } | |
| 617 | |
| 618 #define SND_CMP_OPS2(S, CS, ND, CND, SPEC1, SPEC2) \ | |
| 619 SND_CMP_OP2 (mx_el_lt, <, S, CS, ND, CND, SPEC1, SPEC2) \ | |
| 620 SND_CMP_OP2 (mx_el_le, <=, S, CS, ND, CND, SPEC1, SPEC2) \ | |
| 621 SND_CMP_OP2 (mx_el_ge, >=, S, CS, ND, CND, SPEC1, SPEC2) \ | |
| 622 SND_CMP_OP2 (mx_el_gt, >, S, CS, ND, CND, SPEC1, SPEC2) \ | |
| 623 SND_CMP_OP2 (mx_el_eq, ==, S, , ND, , SPEC1, SPEC2) \ | |
| 624 SND_CMP_OP2 (mx_el_ne, !=, S, , ND, , SPEC1, SPEC2) | |
| 625 | |
| 5030 | 626 #define SND_BOOL_OP(F, OP, S, ND, LHS_ZERO, RHS_ZERO) \ |
| 4543 | 627 boolNDArray \ |
| 628 F (const S& s, const ND& m) \ | |
| 629 { \ | |
| 630 boolNDArray r; \ | |
| 631 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
632 octave_idx_type len = m.length (); \ |
| 4543 | 633 \ |
| 634 if (len > 0) \ | |
| 635 { \ | |
| 636 r.resize (m.dims ()); \ | |
| 637 \ | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
638 if (xisnan (s)) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
639 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
640 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
641 { \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
642 for (octave_idx_type i = 0; i < len; i++) \ |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
643 if (xisnan (m.elem(i))) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
644 { \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
645 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
646 return r; \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
647 } \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
648 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
649 r.elem(i) = (s != LHS_ZERO) OP (m.elem(i) != RHS_ZERO); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
650 } \ |
| 4543 | 651 } \ |
| 652 \ | |
| 653 return r; \ | |
| 654 } | |
| 655 | |
| 5030 | 656 #define SND_BOOL_OPS2(S, ND, LHS_ZERO, RHS_ZERO) \ |
| 657 SND_BOOL_OP (mx_el_and, &&, S, ND, LHS_ZERO, RHS_ZERO) \ | |
| 658 SND_BOOL_OP (mx_el_or, ||, S, ND, LHS_ZERO, RHS_ZERO) | |
| 659 | |
| 4543 | 660 #define SND_BOOL_OPS(S, ND, ZERO) \ |
| 5030 | 661 SND_BOOL_OPS2(S, ND, ZERO, ZERO) |
| 4543 | 662 |
| 663 // N-d matrix by N-d matrix operations. | |
| 664 | |
| 665 #define NDND_BIN_OP(R, OP, ND1, ND2, F) \ | |
| 666 R \ | |
| 667 OP (const ND1& m1, const ND2& m2) \ | |
| 668 { \ | |
| 669 R r; \ | |
| 670 \ | |
| 671 dim_vector m1_dims = m1.dims (); \ | |
| 672 dim_vector m2_dims = m2.dims (); \ | |
| 673 \ | |
| 674 if (m1_dims != m2_dims) \ | |
| 675 gripe_nonconformant (#OP, m1_dims, m2_dims); \ | |
| 676 else \ | |
| 677 { \ | |
| 678 r.resize (m1_dims); \ | |
| 679 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
680 octave_idx_type len = m1.length (); \ |
| 4543 | 681 \ |
| 682 if (len > 0) \ | |
| 683 F ## _vv (r.fortran_vec (), m1.data (), m2.data (), len); \ | |
| 684 } \ | |
| 685 \ | |
| 686 return r; \ | |
| 687 } | |
| 688 | |
| 689 #define NDND_BIN_OPS(R, ND1, ND2) \ | |
| 690 NDND_BIN_OP (R, operator +, ND1, ND2, mx_inline_add) \ | |
| 691 NDND_BIN_OP (R, operator -, ND1, ND2, mx_inline_subtract) \ | |
| 692 NDND_BIN_OP (R, product, ND1, ND2, mx_inline_multiply) \ | |
| 693 NDND_BIN_OP (R, quotient, ND1, ND2, mx_inline_divide) | |
| 694 | |
| 4826 | 695 #define NDND_CMP_OP(F, OP, ND1, C1, ND2, C2) \ |
| 4543 | 696 boolNDArray \ |
| 697 F (const ND1& m1, const ND2& m2) \ | |
| 698 { \ | |
| 699 boolNDArray r; \ | |
| 700 \ | |
| 701 dim_vector m1_dims = m1.dims (); \ | |
| 702 dim_vector m2_dims = m2.dims (); \ | |
| 703 \ | |
| 704 if (m1_dims == m2_dims) \ | |
| 705 { \ | |
| 4826 | 706 r.resize (m1_dims); \ |
| 4543 | 707 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
708 for (octave_idx_type i = 0; i < m1.length (); i++) \ |
| 4826 | 709 r.elem(i) = C1 (m1.elem(i)) OP C2 (m2.elem(i)); \ |
| 4543 | 710 } \ |
| 711 else \ | |
| 4826 | 712 gripe_nonconformant (#F, m1_dims, m2_dims); \ |
| 4543 | 713 \ |
| 714 return r; \ | |
| 715 } | |
| 716 | |
| 717 #define NDND_CMP_OPS(ND1, C1, ND2, C2) \ | |
| 4826 | 718 NDND_CMP_OP (mx_el_lt, <, ND1, C1, ND2, C2) \ |
| 719 NDND_CMP_OP (mx_el_le, <=, ND1, C1, ND2, C2) \ | |
| 720 NDND_CMP_OP (mx_el_ge, >=, ND1, C1, ND2, C2) \ | |
| 721 NDND_CMP_OP (mx_el_gt, >, ND1, C1, ND2, C2) \ | |
| 722 NDND_CMP_OP (mx_el_eq, ==, ND1, , ND2, ) \ | |
| 723 NDND_CMP_OP (mx_el_ne, !=, ND1, , ND2, ) | |
| 4543 | 724 |
| 5030 | 725 #define NDND_BOOL_OP(F, OP, ND1, ND2, LHS_ZERO, RHS_ZERO) \ |
| 4543 | 726 boolNDArray \ |
| 727 F (const ND1& m1, const ND2& m2) \ | |
| 728 { \ | |
| 729 boolNDArray r; \ | |
| 730 \ | |
| 731 dim_vector m1_dims = m1.dims (); \ | |
| 732 dim_vector m2_dims = m2.dims (); \ | |
| 733 \ | |
| 734 if (m1_dims == m2_dims) \ | |
| 735 { \ | |
| 736 if (! m1_dims.all_zero ()) \ | |
| 737 { \ | |
| 738 r.resize (m1_dims); \ | |
| 739 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
740 for (octave_idx_type i = 0; i < m1.length (); i++) \ |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
741 if (xisnan (m1.elem(i)) || xisnan (m2.elem(i))) \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
742 { \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
743 gripe_nan_to_logical_conversion (); \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
744 return r; \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
745 } \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
746 else \ |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
747 r.elem(i) = (m1.elem(i) != LHS_ZERO) OP (m2.elem(i) != RHS_ZERO); \ |
| 4543 | 748 } \ |
| 749 } \ | |
| 750 else \ | |
| 751 gripe_nonconformant (#F, m1_dims, m2_dims); \ | |
| 752 \ | |
| 753 return r; \ | |
| 754 } | |
| 755 | |
| 5030 | 756 #define NDND_BOOL_OPS2(ND1, ND2, LHS_ZERO, RHS_ZERO) \ |
| 757 NDND_BOOL_OP (mx_el_and, &&, ND1, ND2, LHS_ZERO, RHS_ZERO) \ | |
| 758 NDND_BOOL_OP (mx_el_or, ||, ND1, ND2, LHS_ZERO, RHS_ZERO) | |
| 759 | |
| 4543 | 760 #define NDND_BOOL_OPS(ND1, ND2, ZERO) \ |
| 5030 | 761 NDND_BOOL_OPS2(ND1, ND2, ZERO, ZERO) |
| 4543 | 762 |
| 2870 | 763 // scalar by diagonal matrix operations. |
| 764 | |
| 765 #define SDM_BIN_OP(R, OP, S, DM, OPEQ) \ | |
| 2829 | 766 R \ |
| 767 OP (const S& s, const DM& dm) \ | |
| 768 { \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
769 octave_idx_type nr = dm.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
770 octave_idx_type nc = dm.cols (); \ |
| 2829 | 771 \ |
| 772 R r (nr, nc, s); \ | |
| 773 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
774 for (octave_idx_type i = 0; i < dm.length (); i++) \ |
| 2870 | 775 r.elem(i, i) OPEQ dm.elem(i, i); \ |
| 2829 | 776 \ |
| 777 return r; \ | |
| 778 } | |
| 779 | |
| 2870 | 780 #define SDM_BIN_OPS(R, S, DM) \ |
| 781 SDM_BIN_OP (R, operator +, S, DM, +=) \ | |
| 782 SDM_BIN_OP (R, operator -, S, DM, -=) | |
| 783 | |
| 784 // diagonal matrix by scalar operations. | |
| 785 | |
| 786 #define DMS_BIN_OP(R, OP, DM, S, SGN) \ | |
| 2829 | 787 R \ |
| 788 OP (const DM& dm, const S& s) \ | |
| 789 { \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
790 octave_idx_type nr = dm.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
791 octave_idx_type nc = dm.cols (); \ |
| 2829 | 792 \ |
| 793 R r (nr, nc, SGN s); \ | |
| 794 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
795 for (octave_idx_type i = 0; i < dm.length (); i++) \ |
| 2870 | 796 r.elem(i, i) += dm.elem(i, i); \ |
| 2829 | 797 \ |
| 798 return r; \ | |
| 799 } | |
| 800 | |
| 2870 | 801 #define DMS_BIN_OPS(R, DM, S) \ |
| 802 DMS_BIN_OP (R, operator +, DM, S, ) \ | |
| 803 DMS_BIN_OP (R, operator -, DM, S, -) | |
| 804 | |
| 805 // matrix by diagonal matrix operations. | |
| 806 | |
| 807 #define MDM_BIN_OP(R, OP, M, DM, OPEQ) \ | |
| 2829 | 808 R \ |
| 809 OP (const M& m, const DM& dm) \ | |
| 810 { \ | |
| 811 R r; \ | |
| 812 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
813 octave_idx_type m_nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
814 octave_idx_type m_nc = m.cols (); \ |
| 2829 | 815 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
816 octave_idx_type dm_nr = dm.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
817 octave_idx_type dm_nc = dm.cols (); \ |
| 2829 | 818 \ |
| 819 if (m_nr != dm_nr || m_nc != dm_nc) \ | |
| 820 gripe_nonconformant (#OP, m_nr, m_nc, dm_nr, dm_nc); \ | |
| 821 else \ | |
| 822 { \ | |
| 823 r.resize (m_nr, m_nc); \ | |
| 824 \ | |
| 825 if (m_nr > 0 && m_nc > 0) \ | |
| 826 { \ | |
| 3585 | 827 r = R (m); \ |
| 2829 | 828 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
829 octave_idx_type len = dm.length (); \ |
| 2829 | 830 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
831 for (octave_idx_type i = 0; i < len; i++) \ |
| 2870 | 832 r.elem(i, i) OPEQ dm.elem(i, i); \ |
| 2829 | 833 } \ |
| 834 } \ | |
| 835 \ | |
| 836 return r; \ | |
| 837 } | |
| 838 | |
| 5030 | 839 #define MDM_MULTIPLY_OP(R, M, DM, R_ZERO) \ |
| 2829 | 840 R \ |
| 841 operator * (const M& m, const DM& dm) \ | |
| 842 { \ | |
| 843 R r; \ | |
| 844 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
845 octave_idx_type m_nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
846 octave_idx_type m_nc = m.cols (); \ |
| 2829 | 847 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
848 octave_idx_type dm_nr = dm.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
849 octave_idx_type dm_nc = dm.cols (); \ |
| 2829 | 850 \ |
| 851 if (m_nc != dm_nr) \ | |
| 852 gripe_nonconformant ("operator *", m_nr, m_nc, dm_nr, dm_nc); \ | |
| 853 else \ | |
| 854 { \ | |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
855 r = R (m_nr, dm_nc); \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
856 R::element_type *rd = r.fortran_vec (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
857 const M::element_type *md = m.data (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
858 const DM::element_type *dd = dm.data (); \ |
| 4543 | 859 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
860 octave_idx_type len = dm.length (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
861 for (octave_idx_type i = 0; i < len; i++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
862 { \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
863 mx_inline_multiply_vs (rd, md, m_nr, dd[i]); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
864 rd += m_nr; md += m_nr; \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
865 } \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
866 mx_inline_fill_vs (rd, m_nr * (dm_nc - len), R_ZERO); \ |
| 2829 | 867 } \ |
| 868 \ | |
| 869 return r; \ | |
| 870 } | |
| 871 | |
| 5030 | 872 #define MDM_BIN_OPS(R, M, DM, R_ZERO) \ |
| 2870 | 873 MDM_BIN_OP (R, operator +, M, DM, +=) \ |
| 874 MDM_BIN_OP (R, operator -, M, DM, -=) \ | |
| 5030 | 875 MDM_MULTIPLY_OP (R, M, DM, R_ZERO) |
| 2829 | 876 |
| 2870 | 877 // diagonal matrix by matrix operations. |
| 878 | |
| 3585 | 879 #define DMM_BIN_OP(R, OP, DM, M, OPEQ, PREOP) \ |
| 2829 | 880 R \ |
| 881 OP (const DM& dm, const M& m) \ | |
| 882 { \ | |
| 883 R r; \ | |
| 884 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
885 octave_idx_type dm_nr = dm.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
886 octave_idx_type dm_nc = dm.cols (); \ |
| 2829 | 887 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
888 octave_idx_type m_nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
889 octave_idx_type m_nc = m.cols (); \ |
| 2829 | 890 \ |
| 891 if (dm_nr != m_nr || dm_nc != m_nc) \ | |
| 892 gripe_nonconformant (#OP, dm_nr, dm_nc, m_nr, m_nc); \ | |
| 893 else \ | |
| 894 { \ | |
| 895 if (m_nr > 0 && m_nc > 0) \ | |
| 896 { \ | |
| 3585 | 897 r = R (PREOP m); \ |
| 2829 | 898 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
899 octave_idx_type len = dm.length (); \ |
| 2829 | 900 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
901 for (octave_idx_type i = 0; i < len; i++) \ |
| 2870 | 902 r.elem(i, i) OPEQ dm.elem(i, i); \ |
| 2829 | 903 } \ |
| 904 else \ | |
| 905 r.resize (m_nr, m_nc); \ | |
| 906 } \ | |
| 907 \ | |
| 908 return r; \ | |
| 909 } | |
| 910 | |
| 5030 | 911 #define DMM_MULTIPLY_OP(R, DM, M, R_ZERO) \ |
| 2829 | 912 R \ |
| 913 operator * (const DM& dm, const M& m) \ | |
| 914 { \ | |
| 915 R r; \ | |
| 916 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
917 octave_idx_type dm_nr = dm.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
918 octave_idx_type dm_nc = dm.cols (); \ |
| 2829 | 919 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
920 octave_idx_type m_nr = m.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
921 octave_idx_type m_nc = m.cols (); \ |
| 2829 | 922 \ |
| 923 if (dm_nc != m_nr) \ | |
| 924 gripe_nonconformant ("operator *", dm_nr, dm_nc, m_nr, m_nc); \ | |
| 925 else \ | |
| 926 { \ | |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
927 r = R (dm_nr, m_nc); \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
928 R::element_type *rd = r.fortran_vec (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
929 const M::element_type *md = m.data (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
930 const DM::element_type *dd = dm.data (); \ |
| 4543 | 931 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
932 octave_idx_type len = dm.length (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
933 for (octave_idx_type i = 0; i < m_nc; i++) \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
934 { \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
935 mx_inline_multiply_vv (rd, md, dd, len); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
936 rd += len; md += m_nr; \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
937 mx_inline_fill_vs (rd, dm_nr - len, R_ZERO); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
938 rd += dm_nr - len; \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
939 } \ |
| 2829 | 940 } \ |
| 941 \ | |
| 942 return r; \ | |
| 943 } | |
| 944 | |
| 5030 | 945 #define DMM_BIN_OPS(R, DM, M, R_ZERO) \ |
| 3585 | 946 DMM_BIN_OP (R, operator +, DM, M, +=, ) \ |
| 947 DMM_BIN_OP (R, operator -, DM, M, +=, -) \ | |
| 5030 | 948 DMM_MULTIPLY_OP (R, DM, M, R_ZERO) |
| 2829 | 949 |
| 2870 | 950 // diagonal matrix by diagonal matrix operations. |
| 2829 | 951 |
| 2870 | 952 #define DMDM_BIN_OP(R, OP, DM1, DM2, F) \ |
| 2829 | 953 R \ |
| 954 OP (const DM1& dm1, const DM2& dm2) \ | |
| 955 { \ | |
| 956 R r; \ | |
| 957 \ | |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
958 octave_idx_type dm1_nr = dm1.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
959 octave_idx_type dm1_nc = dm1.cols (); \ |
| 2829 | 960 \ |
|
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
961 octave_idx_type dm2_nr = dm2.rows (); \ |
|
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
962 octave_idx_type dm2_nc = dm2.cols (); \ |
| 2829 | 963 \ |
| 964 if (dm1_nr != dm2_nr || dm1_nc != dm2_nc) \ | |
| 965 gripe_nonconformant (#OP, dm1_nr, dm1_nc, dm2_nr, dm2_nc); \ | |
| 966 else \ | |
| 967 { \ | |
| 968 r.resize (dm1_nr, dm1_nc); \ | |
| 969 \ | |
| 970 if (dm1_nr > 0 && dm1_nc > 0) \ | |
| 971 F ## _vv (r.fortran_vec (), dm1.data (), dm2.data (), \ | |
| 8397 | 972 dm1.length ()); \ |
| 2829 | 973 } \ |
| 974 \ | |
| 975 return r; \ | |
| 976 } | |
| 977 | |
| 2870 | 978 #define DMDM_BIN_OPS(R, DM1, DM2) \ |
| 3769 | 979 DMDM_BIN_OP (R, operator +, DM1, DM2, mx_inline_add) \ |
| 980 DMDM_BIN_OP (R, operator -, DM1, DM2, mx_inline_subtract) \ | |
| 981 DMDM_BIN_OP (R, product, DM1, DM2, mx_inline_multiply) | |
| 2870 | 982 |
|
8774
b756ce0002db
split implementation and interface in mx-op-defs and MArray-defs
Jaroslav Hajek <highegg@gmail.com>
parents:
8397
diff
changeset
|
983 // scalar by N-d array min/max ops |
| 3582 | 984 |
| 7189 | 985 #define SND_MINMAX_FCN(FCN, OP, T) \ |
| 986 T ## NDArray \ | |
| 987 FCN (octave_ ## T d, const T ## NDArray& m) \ | |
| 988 { \ | |
| 989 dim_vector dv = m.dims (); \ | |
| 990 octave_idx_type nel = dv.numel (); \ | |
| 991 \ | |
| 992 if (nel == 0) \ | |
| 993 return T ## NDArray (dv); \ | |
| 994 \ | |
| 995 T ## NDArray result (dv); \ | |
| 996 \ | |
| 997 for (octave_idx_type i = 0; i < nel; i++) \ | |
| 998 { \ | |
| 999 OCTAVE_QUIT; \ | |
| 1000 result (i) = d OP m (i) ? d : m(i); \ | |
| 1001 } \ | |
| 1002 \ | |
| 1003 return result; \ | |
| 1004 } | |
| 1005 | |
| 1006 #define NDS_MINMAX_FCN(FCN, OP, T) \ | |
| 1007 T ## NDArray \ | |
| 1008 FCN (const T ## NDArray& m, octave_ ## T d) \ | |
| 1009 { \ | |
| 1010 dim_vector dv = m.dims (); \ | |
| 1011 octave_idx_type nel = dv.numel (); \ | |
| 1012 \ | |
| 1013 if (nel == 0) \ | |
| 1014 return T ## NDArray (dv); \ | |
| 1015 \ | |
| 1016 T ## NDArray result (dv); \ | |
| 1017 \ | |
| 1018 for (octave_idx_type i = 0; i < nel; i++) \ | |
| 1019 { \ | |
| 1020 OCTAVE_QUIT; \ | |
| 1021 result (i) = m (i) OP d ? m(i) : d; \ | |
| 1022 } \ | |
| 1023 \ | |
| 1024 return result; \ | |
| 1025 } | |
| 1026 | |
| 1027 #define NDND_MINMAX_FCN(FCN, OP, T) \ | |
| 1028 T ## NDArray \ | |
| 1029 FCN (const T ## NDArray& a, const T ## NDArray& b) \ | |
| 1030 { \ | |
| 1031 dim_vector dv = a.dims (); \ | |
| 1032 octave_idx_type nel = dv.numel (); \ | |
| 1033 \ | |
| 1034 if (dv != b.dims ()) \ | |
| 1035 { \ | |
| 1036 (*current_liboctave_error_handler) \ | |
| 1037 ("two-arg min expecting args of same size"); \ | |
| 1038 return T ## NDArray (); \ | |
| 1039 } \ | |
| 1040 \ | |
| 1041 if (nel == 0) \ | |
| 1042 return T ## NDArray (dv); \ | |
| 1043 \ | |
| 1044 T ## NDArray result (dv); \ | |
| 1045 \ | |
| 1046 for (octave_idx_type i = 0; i < nel; i++) \ | |
| 1047 { \ | |
| 1048 OCTAVE_QUIT; \ | |
| 1049 result (i) = a(i) OP b(i) ? a(i) : b(i); \ | |
| 1050 } \ | |
| 1051 \ | |
| 1052 return result; \ | |
| 1053 } | |
| 1054 | |
| 1055 #define MINMAX_FCNS(T) \ | |
| 1056 SND_MINMAX_FCN (min, <, T) \ | |
| 1057 NDS_MINMAX_FCN (min, <, T) \ | |
| 1058 NDND_MINMAX_FCN (min, <, T) \ | |
| 1059 SND_MINMAX_FCN (max, >, T) \ | |
| 1060 NDS_MINMAX_FCN (max, >, T) \ | |
| 1061 NDND_MINMAX_FCN (max, >, T) | |
| 1062 | |
|
8774
b756ce0002db
split implementation and interface in mx-op-defs and MArray-defs
Jaroslav Hajek <highegg@gmail.com>
parents:
8397
diff
changeset
|
1063 // permutation matrix by matrix ops and vice versa |
| 7189 | 1064 |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1065 #define PMM_MULTIPLY_OP(PM, M) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1066 M operator * (const PM& p, const M& x) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1067 { \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1068 octave_idx_type nr = x.rows (), nc = x.columns (); \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1069 M result; \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1070 if (p.columns () != nr) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1071 gripe_nonconformant ("operator *", p.rows (), p.columns (), nr, nc); \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1072 else \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1073 { \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1074 if (p.is_col_perm ()) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1075 { \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1076 result = M (nr, nc); \ |
|
8375
e3c9102431a9
fix design problems of diag & perm matrix classes
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1077 result.assign (p.pvec (), idx_vector::colon, x); \ |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1078 } \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1079 else \ |
|
8375
e3c9102431a9
fix design problems of diag & perm matrix classes
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1080 result = x.index (p.pvec (), idx_vector::colon); \ |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1081 } \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1082 \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1083 return result; \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1084 } |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1085 |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1086 #define MPM_MULTIPLY_OP(M, PM) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1087 M operator * (const M& x, const PM& p) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1088 { \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1089 octave_idx_type nr = x.rows (), nc = x.columns (); \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1090 M result; \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1091 if (p.rows () != nc) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1092 gripe_nonconformant ("operator *", nr, nc, p.rows (), p.columns ()); \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1093 else \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1094 { \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1095 if (p.is_col_perm ()) \ |
|
8375
e3c9102431a9
fix design problems of diag & perm matrix classes
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1096 result = x.index (idx_vector::colon, p.pvec ()); \ |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1097 else \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1098 { \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1099 result = M (nr, nc); \ |
|
8375
e3c9102431a9
fix design problems of diag & perm matrix classes
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1100 result.assign (idx_vector::colon, p.pvec (), x); \ |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1101 } \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1102 } \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1103 \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1104 return result; \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1105 } |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1106 |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1107 #define PMM_BIN_OPS(R, PM, M) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1108 PMM_MULTIPLY_OP(PM, M); |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1109 |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1110 #define MPM_BIN_OPS(R, M, PM) \ |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1111 MPM_MULTIPLY_OP(M, PM); |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
1112 |
|
8774
b756ce0002db
split implementation and interface in mx-op-defs and MArray-defs
Jaroslav Hajek <highegg@gmail.com>
parents:
8397
diff
changeset
|
1113 #endif |
|
b756ce0002db
split implementation and interface in mx-op-defs and MArray-defs
Jaroslav Hajek <highegg@gmail.com>
parents:
8397
diff
changeset
|
1114 |
| 7189 | 1115 |
| 2829 | 1116 /* |
| 1117 ;;; Local Variables: *** | |
| 1118 ;;; mode: C++ *** | |
| 1119 ;;; End: *** | |
| 1120 */ |