Mercurial > octave-nkf
annotate liboctave/Sparse-op-defs.h @ 9578:7dafdb8b062f
refactor comparison ops implementations
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Thu, 27 Aug 2009 11:19:33 +0200 |
| parents | 5d46c4a894e8 |
| children | 829e69ec3110 |
| rev | line source |
|---|---|
| 5164 | 1 /* |
| 2 | |
| 7344 | 3 Copyright (C) 2004, 2005, 2006, 2007, 2008 David Bateman |
| 7016 | 4 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Andy Adler |
| 7803 | 5 Copyright (C) 2008 Jaroslav Hajek |
| 7016 | 6 |
| 7 This file is part of Octave. | |
| 5164 | 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. | |
| 5164 | 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/>. | |
| 5164 | 22 |
| 23 */ | |
| 24 | |
| 25 #if !defined (octave_sparse_op_defs_h) | |
| 26 #define octave_sparse_op_defs_h 1 | |
| 27 | |
| 28 #include "Array-util.h" | |
| 6221 | 29 #include "mx-ops.h" |
|
8377
25bc2d31e1bf
improve OCTAVE_LOCAL_BUFFER
Jaroslav Hajek <highegg@gmail.com>
parents:
8198
diff
changeset
|
30 #include "oct-locbuf.h" |
| 5164 | 31 |
| 6708 | 32 #define SPARSE_BIN_OP_DECL(R, OP, X, Y, API) \ |
| 33 extern API R OP (const X&, const Y&) | |
| 5164 | 34 |
| 6708 | 35 #define SPARSE_CMP_OP_DECL(OP, X, Y, API) \ |
| 36 extern API SparseBoolMatrix OP (const X&, const Y&) | |
| 5164 | 37 |
| 6708 | 38 #define SPARSE_BOOL_OP_DECL(OP, X, Y, API) \ |
| 39 extern API SparseBoolMatrix OP (const X&, const Y&) | |
| 5164 | 40 |
| 41 // matrix by scalar operations. | |
| 42 | |
| 6708 | 43 #define SPARSE_SMS_BIN_OP_DECLS(R1, R2, M, S, API) \ |
| 44 SPARSE_BIN_OP_DECL (R1, operator +, M, S, API); \ | |
| 45 SPARSE_BIN_OP_DECL (R1, operator -, M, S, API); \ | |
| 46 SPARSE_BIN_OP_DECL (R2, operator *, M, S, API); \ | |
| 47 SPARSE_BIN_OP_DECL (R2, operator /, M, S, API); | |
| 5164 | 48 |
| 49 #define SPARSE_SMS_BIN_OP_1(R, F, OP, M, S) \ | |
| 50 R \ | |
| 51 F (const M& m, const S& s) \ | |
| 52 { \ | |
| 5275 | 53 octave_idx_type nr = m.rows (); \ |
| 54 octave_idx_type nc = m.cols (); \ | |
| 5164 | 55 \ |
| 56 R r (nr, nc, (0.0 OP s)); \ | |
| 57 \ | |
| 5275 | 58 for (octave_idx_type j = 0; j < nc; j++) \ |
| 59 for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++) \ | |
| 5164 | 60 r.elem (m.ridx (i), j) = m.data (i) OP s; \ |
| 61 return r; \ | |
| 62 } | |
| 63 | |
| 64 #define SPARSE_SMS_BIN_OP_2(R, F, OP, M, S) \ | |
| 65 R \ | |
| 66 F (const M& m, const S& s) \ | |
| 67 { \ | |
| 5275 | 68 octave_idx_type nr = m.rows (); \ |
| 69 octave_idx_type nc = m.cols (); \ | |
| 5681 | 70 octave_idx_type nz = m.nnz (); \ |
| 5164 | 71 \ |
| 72 R r (nr, nc, nz); \ | |
| 73 \ | |
| 5275 | 74 for (octave_idx_type i = 0; i < nz; i++) \ |
| 5164 | 75 { \ |
| 76 r.data(i) = m.data(i) OP s; \ | |
| 77 r.ridx(i) = m.ridx(i); \ | |
| 78 } \ | |
| 5275 | 79 for (octave_idx_type i = 0; i < nc + 1; i++) \ |
| 5164 | 80 r.cidx(i) = m.cidx(i); \ |
| 81 \ | |
| 82 r.maybe_compress (true); \ | |
| 83 return r; \ | |
| 84 } | |
| 85 | |
| 86 #define SPARSE_SMS_BIN_OPS(R1, R2, M, S) \ | |
| 87 SPARSE_SMS_BIN_OP_1 (R1, operator +, +, M, S) \ | |
| 88 SPARSE_SMS_BIN_OP_1 (R1, operator -, -, M, S) \ | |
| 89 SPARSE_SMS_BIN_OP_2 (R2, operator *, *, M, S) \ | |
| 90 SPARSE_SMS_BIN_OP_2 (R2, operator /, /, M, S) | |
| 91 | |
| 6708 | 92 #define SPARSE_SMS_CMP_OP_DECLS(M, S, API) \ |
| 93 SPARSE_CMP_OP_DECL (mx_el_lt, M, S, API); \ | |
| 94 SPARSE_CMP_OP_DECL (mx_el_le, M, S, API); \ | |
| 95 SPARSE_CMP_OP_DECL (mx_el_ge, M, S, API); \ | |
| 96 SPARSE_CMP_OP_DECL (mx_el_gt, M, S, API); \ | |
| 97 SPARSE_CMP_OP_DECL (mx_el_eq, M, S, API); \ | |
| 98 SPARSE_CMP_OP_DECL (mx_el_ne, M, S, API); | |
| 5164 | 99 |
| 6708 | 100 #define SPARSE_SMS_EQNE_OP_DECLS(M, S, API) \ |
| 101 SPARSE_CMP_OP_DECL (mx_el_eq, M, S, API); \ | |
| 102 SPARSE_CMP_OP_DECL (mx_el_ne, M, S, API); | |
| 5164 | 103 |
| 104 #define SPARSE_SMS_CMP_OP(F, OP, M, MZ, MC, S, SZ, SC) \ | |
| 105 SparseBoolMatrix \ | |
| 106 F (const M& m, const S& s) \ | |
| 107 { \ | |
| 5275 | 108 octave_idx_type nr = m.rows (); \ |
| 109 octave_idx_type nc = m.cols (); \ | |
| 7269 | 110 SparseBoolMatrix r; \ |
| 5164 | 111 \ |
| 7269 | 112 if (MC (MZ) OP SC (s)) \ |
| 113 { \ | |
| 114 r = SparseBoolMatrix (nr, nc, true); \ | |
| 115 for (octave_idx_type j = 0; j < nc; j++) \ | |
| 116 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ | |
| 117 if (! (MC (m.data (i)) OP SC (s))) \ | |
| 118 r.data (m.ridx (i) + j * nr) = false; \ | |
| 119 r.maybe_compress (true); \ | |
| 120 } \ | |
| 121 else \ | |
| 5164 | 122 { \ |
| 7269 | 123 r = SparseBoolMatrix (nr, nc, m.nnz ()); \ |
| 124 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 125 octave_idx_type nel = 0; \ | |
| 126 for (octave_idx_type j = 0; j < nc; j++) \ | |
| 127 { \ | |
| 128 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ | |
| 129 if (MC (m.data (i)) OP SC (s)) \ | |
| 130 { \ | |
| 131 r.ridx (nel) = m.ridx (i); \ | |
| 132 r.data (nel++) = true; \ | |
| 133 } \ | |
| 134 r.cidx (j + 1) = nel; \ | |
| 135 } \ | |
| 136 r.maybe_compress (false); \ | |
| 137 } \ | |
| 5164 | 138 return r; \ |
| 139 } | |
| 140 | |
| 141 #define SPARSE_SMS_CMP_OPS(M, MZ, CM, S, SZ, CS) \ | |
|
9578
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
142 SPARSE_SMS_CMP_OP (mx_el_lt, <, M, MZ, , S, SZ, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
143 SPARSE_SMS_CMP_OP (mx_el_le, <=, M, MZ, , S, SZ, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
144 SPARSE_SMS_CMP_OP (mx_el_ge, >=, M, MZ, , S, SZ, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
145 SPARSE_SMS_CMP_OP (mx_el_gt, >, M, MZ, , S, SZ, ) \ |
| 5164 | 146 SPARSE_SMS_CMP_OP (mx_el_eq, ==, M, MZ, , S, SZ, ) \ |
| 147 SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, MZ, , S, SZ, ) | |
| 148 | |
| 149 #define SPARSE_SMS_EQNE_OPS(M, MZ, CM, S, SZ, CS) \ | |
| 150 SPARSE_SMS_CMP_OP (mx_el_eq, ==, M, MZ, , S, SZ, ) \ | |
| 151 SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, MZ, , S, SZ, ) | |
| 152 | |
| 6708 | 153 #define SPARSE_SMS_BOOL_OP_DECLS(M, S, API) \ |
| 154 SPARSE_BOOL_OP_DECL (mx_el_and, M, S, API); \ | |
| 155 SPARSE_BOOL_OP_DECL (mx_el_or, M, S, API); | |
| 5164 | 156 |
| 157 #define SPARSE_SMS_BOOL_OP(F, OP, M, S, LHS_ZERO, RHS_ZERO) \ | |
| 158 SparseBoolMatrix \ | |
| 159 F (const M& m, const S& s) \ | |
| 160 { \ | |
| 5275 | 161 octave_idx_type nr = m.rows (); \ |
| 162 octave_idx_type nc = m.cols (); \ | |
| 7269 | 163 SparseBoolMatrix r; \ |
| 5164 | 164 \ |
| 165 if (nr > 0 && nc > 0) \ | |
| 166 { \ | |
| 167 if (LHS_ZERO OP (s != RHS_ZERO)) \ | |
| 168 { \ | |
| 7269 | 169 r = SparseBoolMatrix (nr, nc, true); \ |
| 5275 | 170 for (octave_idx_type j = 0; j < nc; j++) \ |
| 7269 | 171 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ |
| 172 if (! ((m.data(i) != LHS_ZERO) OP (s != RHS_ZERO))) \ | |
| 173 r.data (m.ridx (i) + j * nr) = false; \ | |
| 174 r.maybe_compress (true); \ | |
| 175 } \ | |
| 5164 | 176 else \ |
| 177 { \ | |
| 7269 | 178 r = SparseBoolMatrix (nr, nc, m.nnz ()); \ |
| 179 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 180 octave_idx_type nel = 0; \ | |
| 5275 | 181 for (octave_idx_type j = 0; j < nc; j++) \ |
| 7269 | 182 { \ |
| 183 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ | |
| 184 if ((m.data(i) != LHS_ZERO) OP (s != RHS_ZERO)) \ | |
| 185 { \ | |
| 186 r.ridx (nel) = m.ridx (i); \ | |
| 187 r.data (nel++) = true; \ | |
| 188 } \ | |
| 189 r.cidx (j + 1) = nel; \ | |
| 190 } \ | |
| 191 r.maybe_compress (false); \ | |
| 192 } \ | |
| 5164 | 193 } \ |
| 194 return r; \ | |
| 195 } | |
| 196 | |
| 197 #define SPARSE_SMS_BOOL_OPS2(M, S, LHS_ZERO, RHS_ZERO) \ | |
| 198 SPARSE_SMS_BOOL_OP (mx_el_and, &&, M, S, LHS_ZERO, RHS_ZERO) \ | |
| 199 SPARSE_SMS_BOOL_OP (mx_el_or, ||, M, S, LHS_ZERO, RHS_ZERO) | |
| 200 | |
| 201 #define SPARSE_SMS_BOOL_OPS(M, S, ZERO) \ | |
| 202 SPARSE_SMS_BOOL_OPS2(M, S, ZERO, ZERO) | |
| 203 | |
| 6708 | 204 #define SPARSE_SMS_OP_DECLS(R1, R2, M, S, API) \ |
| 205 SPARSE_SMS_BIN_OP_DECLS (R1, R2, M, S, API) \ | |
| 206 SPARSE_SMS_CMP_OP_DECLS (M, S, API) \ | |
| 207 SPARSE_SMS_BOOL_OP_DECLS (M, S, API) | |
| 5164 | 208 |
| 209 // scalar by matrix operations. | |
| 210 | |
| 6708 | 211 #define SPARSE_SSM_BIN_OP_DECLS(R1, R2, S, M, API) \ |
| 212 SPARSE_BIN_OP_DECL (R1, operator +, S, M, API); \ | |
| 213 SPARSE_BIN_OP_DECL (R1, operator -, S, M, API); \ | |
| 214 SPARSE_BIN_OP_DECL (R2, operator *, S, M, API); \ | |
| 215 SPARSE_BIN_OP_DECL (R2, operator /, S, M, API); | |
| 5164 | 216 |
| 217 #define SPARSE_SSM_BIN_OP_1(R, F, OP, S, M) \ | |
| 218 R \ | |
| 219 F (const S& s, const M& m) \ | |
| 220 { \ | |
| 5275 | 221 octave_idx_type nr = m.rows (); \ |
| 222 octave_idx_type nc = m.cols (); \ | |
| 5164 | 223 \ |
| 224 R r (nr, nc, (s OP 0.0)); \ | |
| 225 \ | |
| 5275 | 226 for (octave_idx_type j = 0; j < nc; j++) \ |
| 227 for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++) \ | |
| 5164 | 228 r.elem (m.ridx (i), j) = s OP m.data (i); \ |
| 229 \ | |
| 230 return r; \ | |
| 231 } | |
| 232 | |
| 233 #define SPARSE_SSM_BIN_OP_2(R, F, OP, S, M) \ | |
| 234 R \ | |
| 235 F (const S& s, const M& m) \ | |
| 236 { \ | |
| 5275 | 237 octave_idx_type nr = m.rows (); \ |
| 238 octave_idx_type nc = m.cols (); \ | |
| 5681 | 239 octave_idx_type nz = m.nnz (); \ |
| 5164 | 240 \ |
| 241 R r (nr, nc, nz); \ | |
| 242 \ | |
| 5275 | 243 for (octave_idx_type i = 0; i < nz; i++) \ |
| 5164 | 244 { \ |
| 245 r.data(i) = s OP m.data(i); \ | |
| 246 r.ridx(i) = m.ridx(i); \ | |
| 247 } \ | |
| 5275 | 248 for (octave_idx_type i = 0; i < nc + 1; i++) \ |
| 5164 | 249 r.cidx(i) = m.cidx(i); \ |
| 250 \ | |
| 251 r.maybe_compress(true); \ | |
| 252 return r; \ | |
| 253 } | |
| 254 | |
| 255 #define SPARSE_SSM_BIN_OPS(R1, R2, S, M) \ | |
| 256 SPARSE_SSM_BIN_OP_1 (R1, operator +, +, S, M) \ | |
| 257 SPARSE_SSM_BIN_OP_1 (R1, operator -, -, S, M) \ | |
| 258 SPARSE_SSM_BIN_OP_2 (R2, operator *, *, S, M) \ | |
| 259 SPARSE_SSM_BIN_OP_2 (R2, operator /, /, S, M) | |
| 260 | |
| 6708 | 261 #define SPARSE_SSM_CMP_OP_DECLS(S, M, API) \ |
| 262 SPARSE_CMP_OP_DECL (mx_el_lt, S, M, API); \ | |
| 263 SPARSE_CMP_OP_DECL (mx_el_le, S, M, API); \ | |
| 264 SPARSE_CMP_OP_DECL (mx_el_ge, S, M, API); \ | |
| 265 SPARSE_CMP_OP_DECL (mx_el_gt, S, M, API); \ | |
| 266 SPARSE_CMP_OP_DECL (mx_el_eq, S, M, API); \ | |
| 267 SPARSE_CMP_OP_DECL (mx_el_ne, S, M, API); | |
| 5164 | 268 |
| 6708 | 269 #define SPARSE_SSM_EQNE_OP_DECLS(S, M, API) \ |
| 270 SPARSE_CMP_OP_DECL (mx_el_eq, S, M, API); \ | |
| 271 SPARSE_CMP_OP_DECL (mx_el_ne, S, M, API); | |
| 5164 | 272 |
| 273 #define SPARSE_SSM_CMP_OP(F, OP, S, SZ, SC, M, MZ, MC) \ | |
| 274 SparseBoolMatrix \ | |
| 275 F (const S& s, const M& m) \ | |
| 276 { \ | |
| 5275 | 277 octave_idx_type nr = m.rows (); \ |
| 278 octave_idx_type nc = m.cols (); \ | |
| 7269 | 279 SparseBoolMatrix r; \ |
| 5164 | 280 \ |
| 7269 | 281 if (SC (s) OP SC (MZ)) \ |
| 282 { \ | |
| 283 r = SparseBoolMatrix (nr, nc, true); \ | |
| 284 for (octave_idx_type j = 0; j < nc; j++) \ | |
| 285 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ | |
| 286 if (! (SC (s) OP MC (m.data (i)))) \ | |
| 287 r.data (m.ridx (i) + j * nr) = false; \ | |
| 288 r.maybe_compress (true); \ | |
| 289 } \ | |
| 290 else \ | |
| 5164 | 291 { \ |
| 7269 | 292 r = SparseBoolMatrix (nr, nc, m.nnz ()); \ |
| 293 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 294 octave_idx_type nel = 0; \ | |
| 295 for (octave_idx_type j = 0; j < nc; j++) \ | |
| 296 { \ | |
| 297 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ | |
| 298 if (SC (s) OP MC (m.data (i))) \ | |
| 299 { \ | |
| 300 r.ridx (nel) = m.ridx (i); \ | |
| 301 r.data (nel++) = true; \ | |
| 302 } \ | |
| 303 r.cidx (j + 1) = nel; \ | |
| 304 } \ | |
| 305 r.maybe_compress (false); \ | |
| 306 } \ | |
| 5164 | 307 return r; \ |
| 308 } | |
| 309 | |
| 310 #define SPARSE_SSM_CMP_OPS(S, SZ, SC, M, MZ, MC) \ | |
|
9578
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
311 SPARSE_SSM_CMP_OP (mx_el_lt, <, S, SZ, , M, MZ, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
312 SPARSE_SSM_CMP_OP (mx_el_le, <=, S, SZ, , M, MZ, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
313 SPARSE_SSM_CMP_OP (mx_el_ge, >=, S, SZ, , M, MZ, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
314 SPARSE_SSM_CMP_OP (mx_el_gt, >, S, SZ, , M, MZ, ) \ |
| 5164 | 315 SPARSE_SSM_CMP_OP (mx_el_eq, ==, S, SZ, , M, MZ, ) \ |
| 316 SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, SZ, , M, MZ, ) | |
| 317 | |
| 318 #define SPARSE_SSM_EQNE_OPS(S, SZ, SC, M, MZ, MC) \ | |
| 319 SPARSE_SSM_CMP_OP (mx_el_eq, ==, S, SZ, , M, MZ, ) \ | |
| 320 SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, SZ, , M, MZ, ) | |
| 321 | |
| 6708 | 322 #define SPARSE_SSM_BOOL_OP_DECLS(S, M, API) \ |
| 323 SPARSE_BOOL_OP_DECL (mx_el_and, S, M, API); \ | |
| 324 SPARSE_BOOL_OP_DECL (mx_el_or, S, M, API); \ | |
| 5164 | 325 |
| 326 #define SPARSE_SSM_BOOL_OP(F, OP, S, M, LHS_ZERO, RHS_ZERO) \ | |
| 327 SparseBoolMatrix \ | |
| 328 F (const S& s, const M& m) \ | |
| 329 { \ | |
| 5275 | 330 octave_idx_type nr = m.rows (); \ |
| 331 octave_idx_type nc = m.cols (); \ | |
| 7269 | 332 SparseBoolMatrix r; \ |
| 5164 | 333 \ |
| 334 if (nr > 0 && nc > 0) \ | |
| 335 { \ | |
| 336 if ((s != LHS_ZERO) OP RHS_ZERO) \ | |
| 337 { \ | |
| 7269 | 338 r = SparseBoolMatrix (nr, nc, true); \ |
| 5275 | 339 for (octave_idx_type j = 0; j < nc; j++) \ |
| 7269 | 340 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ |
| 341 if (! ((s != LHS_ZERO) OP (m.data(i) != RHS_ZERO))) \ | |
| 342 r.data (m.ridx (i) + j * nr) = false; \ | |
| 343 r.maybe_compress (true); \ | |
| 344 } \ | |
| 5164 | 345 else \ |
| 346 { \ | |
| 7269 | 347 r = SparseBoolMatrix (nr, nc, m.nnz ()); \ |
| 348 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 349 octave_idx_type nel = 0; \ | |
| 5275 | 350 for (octave_idx_type j = 0; j < nc; j++) \ |
| 7269 | 351 { \ |
| 352 for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++) \ | |
| 353 if ((s != LHS_ZERO) OP (m.data(i) != RHS_ZERO)) \ | |
| 354 { \ | |
| 355 r.ridx (nel) = m.ridx (i); \ | |
| 356 r.data (nel++) = true; \ | |
| 357 } \ | |
| 358 r.cidx (j + 1) = nel; \ | |
| 359 } \ | |
| 360 r.maybe_compress (false); \ | |
| 361 } \ | |
| 5164 | 362 } \ |
| 363 return r; \ | |
| 364 } | |
| 365 | |
| 366 #define SPARSE_SSM_BOOL_OPS2(S, M, LHS_ZERO, RHS_ZERO) \ | |
| 367 SPARSE_SSM_BOOL_OP (mx_el_and, &&, S, M, LHS_ZERO, RHS_ZERO) \ | |
| 368 SPARSE_SSM_BOOL_OP (mx_el_or, ||, S, M, LHS_ZERO, RHS_ZERO) | |
| 369 | |
| 370 #define SPARSE_SSM_BOOL_OPS(S, M, ZERO) \ | |
| 371 SPARSE_SSM_BOOL_OPS2(S, M, ZERO, ZERO) | |
| 372 | |
| 6708 | 373 #define SPARSE_SSM_OP_DECLS(R1, R2, S, M, API) \ |
| 374 SPARSE_SSM_BIN_OP_DECLS (R1, R2, S, M, API) \ | |
| 375 SPARSE_SSM_CMP_OP_DECLS (S, M, API) \ | |
| 376 SPARSE_SSM_BOOL_OP_DECLS (S, M, API) \ | |
| 5164 | 377 |
| 378 // matrix by matrix operations. | |
| 379 | |
| 6708 | 380 #define SPARSE_SMSM_BIN_OP_DECLS(R1, R2, M1, M2, API) \ |
| 381 SPARSE_BIN_OP_DECL (R1, operator +, M1, M2, API); \ | |
| 382 SPARSE_BIN_OP_DECL (R1, operator -, M1, M2, API); \ | |
| 383 SPARSE_BIN_OP_DECL (R2, product, M1, M2, API); \ | |
| 384 SPARSE_BIN_OP_DECL (R2, quotient, M1, M2, API); | |
| 5164 | 385 |
| 386 #define SPARSE_SMSM_BIN_OP_1(R, F, OP, M1, M2) \ | |
| 387 R \ | |
| 388 F (const M1& m1, const M2& m2) \ | |
| 389 { \ | |
| 390 R r; \ | |
| 391 \ | |
| 5275 | 392 octave_idx_type m1_nr = m1.rows (); \ |
| 393 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 394 \ |
| 5275 | 395 octave_idx_type m2_nr = m2.rows (); \ |
| 396 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 397 \ |
| 6221 | 398 if (m1_nr == 1 && m1_nc == 1) \ |
| 399 { \ | |
| 400 if (m1.elem(0,0) == 0.) \ | |
| 7342 | 401 r = OP R (m2); \ |
| 6221 | 402 else \ |
| 403 { \ | |
| 404 r = R (m2_nr, m2_nc, m1.data(0) OP 0.); \ | |
| 405 \ | |
| 406 for (octave_idx_type j = 0 ; j < m2_nc ; j++) \ | |
| 407 { \ | |
| 408 OCTAVE_QUIT; \ | |
| 409 octave_idx_type idxj = j * m2_nr; \ | |
| 410 for (octave_idx_type i = m2.cidx(j) ; i < m2.cidx(j+1) ; i++) \ | |
| 411 { \ | |
| 412 OCTAVE_QUIT; \ | |
| 413 r.data(idxj + m2.ridx(i)) = m1.data(0) OP m2.data(i); \ | |
| 414 } \ | |
| 415 } \ | |
| 416 r.maybe_compress (); \ | |
| 417 } \ | |
| 418 } \ | |
| 419 else if (m2_nr == 1 && m2_nc == 1) \ | |
| 420 { \ | |
| 421 if (m2.elem(0,0) == 0.) \ | |
| 422 r = R (m1); \ | |
| 423 else \ | |
| 424 { \ | |
| 425 r = R (m1_nr, m1_nc, 0. OP m2.data(0)); \ | |
| 426 \ | |
| 427 for (octave_idx_type j = 0 ; j < m1_nc ; j++) \ | |
| 428 { \ | |
| 429 OCTAVE_QUIT; \ | |
| 430 octave_idx_type idxj = j * m1_nr; \ | |
| 431 for (octave_idx_type i = m1.cidx(j) ; i < m1.cidx(j+1) ; i++) \ | |
| 432 { \ | |
| 433 OCTAVE_QUIT; \ | |
| 434 r.data(idxj + m1.ridx(i)) = m1.data(i) OP m2.data(0); \ | |
| 435 } \ | |
| 436 } \ | |
| 437 r.maybe_compress (); \ | |
| 438 } \ | |
| 439 } \ | |
| 440 else if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 5164 | 441 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 442 else \ | |
| 443 { \ | |
| 5681 | 444 r = R (m1_nr, m1_nc, (m1.nnz () + m2.nnz ())); \ |
| 5164 | 445 \ |
| 5275 | 446 octave_idx_type jx = 0; \ |
| 5164 | 447 r.cidx (0) = 0; \ |
| 5275 | 448 for (octave_idx_type i = 0 ; i < m1_nc ; i++) \ |
| 5164 | 449 { \ |
| 5275 | 450 octave_idx_type ja = m1.cidx(i); \ |
| 451 octave_idx_type ja_max = m1.cidx(i+1); \ | |
| 5164 | 452 bool ja_lt_max= ja < ja_max; \ |
| 453 \ | |
| 5275 | 454 octave_idx_type jb = m2.cidx(i); \ |
| 455 octave_idx_type jb_max = m2.cidx(i+1); \ | |
| 5164 | 456 bool jb_lt_max = jb < jb_max; \ |
| 457 \ | |
| 458 while (ja_lt_max || jb_lt_max ) \ | |
| 459 { \ | |
| 460 OCTAVE_QUIT; \ | |
| 461 if ((! jb_lt_max) || \ | |
| 462 (ja_lt_max && (m1.ridx(ja) < m2.ridx(jb)))) \ | |
| 463 { \ | |
| 464 r.ridx(jx) = m1.ridx(ja); \ | |
| 465 r.data(jx) = m1.data(ja) OP 0.; \ | |
| 466 jx++; \ | |
| 467 ja++; \ | |
| 468 ja_lt_max= ja < ja_max; \ | |
| 469 } \ | |
| 470 else if (( !ja_lt_max ) || \ | |
| 471 (jb_lt_max && (m2.ridx(jb) < m1.ridx(ja)) ) ) \ | |
| 472 { \ | |
| 473 r.ridx(jx) = m2.ridx(jb); \ | |
| 474 r.data(jx) = 0. OP m2.data(jb); \ | |
| 475 jx++; \ | |
| 476 jb++; \ | |
| 477 jb_lt_max= jb < jb_max; \ | |
| 478 } \ | |
| 479 else \ | |
| 480 { \ | |
| 481 if ((m1.data(ja) OP m2.data(jb)) != 0.) \ | |
| 482 { \ | |
| 483 r.data(jx) = m1.data(ja) OP m2.data(jb); \ | |
| 484 r.ridx(jx) = m1.ridx(ja); \ | |
| 485 jx++; \ | |
| 486 } \ | |
| 487 ja++; \ | |
| 488 ja_lt_max= ja < ja_max; \ | |
| 489 jb++; \ | |
| 490 jb_lt_max= jb < jb_max; \ | |
| 491 } \ | |
| 492 } \ | |
| 493 r.cidx(i+1) = jx; \ | |
| 494 } \ | |
| 495 \ | |
| 496 r.maybe_compress (); \ | |
| 497 } \ | |
| 498 \ | |
| 499 return r; \ | |
| 500 } | |
| 501 | |
| 502 #define SPARSE_SMSM_BIN_OP_2(R, F, OP, M1, M2) \ | |
| 503 R \ | |
| 504 F (const M1& m1, const M2& m2) \ | |
| 505 { \ | |
| 506 R r; \ | |
| 507 \ | |
| 5275 | 508 octave_idx_type m1_nr = m1.rows (); \ |
| 509 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 510 \ |
| 5275 | 511 octave_idx_type m2_nr = m2.rows (); \ |
| 512 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 513 \ |
| 6221 | 514 if (m1_nr == 1 && m1_nc == 1) \ |
| 515 { \ | |
| 516 if (m1.elem(0,0) == 0.) \ | |
| 517 r = R (m2_nr, m2_nc); \ | |
| 518 else \ | |
| 519 { \ | |
| 520 r = R (m2); \ | |
| 521 octave_idx_type m2_nnz = m2.nnz(); \ | |
| 522 \ | |
| 523 for (octave_idx_type i = 0 ; i < m2_nnz ; i++) \ | |
| 524 { \ | |
| 525 OCTAVE_QUIT; \ | |
| 526 r.data (i) = m1.data(0) OP r.data(i); \ | |
| 527 } \ | |
| 528 r.maybe_compress (); \ | |
| 529 } \ | |
| 530 } \ | |
| 531 else if (m2_nr == 1 && m2_nc == 1) \ | |
| 532 { \ | |
| 533 if (m2.elem(0,0) == 0.) \ | |
| 534 r = R (m1_nr, m1_nc); \ | |
| 535 else \ | |
| 536 { \ | |
| 537 r = R (m1); \ | |
| 538 octave_idx_type m1_nnz = m1.nnz(); \ | |
| 539 \ | |
| 540 for (octave_idx_type i = 0 ; i < m1_nnz ; i++) \ | |
| 541 { \ | |
| 542 OCTAVE_QUIT; \ | |
| 543 r.data (i) = r.data(i) OP m2.data(0); \ | |
| 544 } \ | |
| 545 r.maybe_compress (); \ | |
| 546 } \ | |
| 547 } \ | |
| 548 else if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 5164 | 549 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 550 else \ | |
| 551 { \ | |
| 5681 | 552 r = R (m1_nr, m1_nc, (m1.nnz () > m2.nnz () ? m1.nnz () : m2.nnz ())); \ |
| 5164 | 553 \ |
| 5275 | 554 octave_idx_type jx = 0; \ |
| 5164 | 555 r.cidx (0) = 0; \ |
| 5275 | 556 for (octave_idx_type i = 0 ; i < m1_nc ; i++) \ |
| 5164 | 557 { \ |
| 5275 | 558 octave_idx_type ja = m1.cidx(i); \ |
| 559 octave_idx_type ja_max = m1.cidx(i+1); \ | |
| 5164 | 560 bool ja_lt_max= ja < ja_max; \ |
| 561 \ | |
| 5275 | 562 octave_idx_type jb = m2.cidx(i); \ |
| 563 octave_idx_type jb_max = m2.cidx(i+1); \ | |
| 5164 | 564 bool jb_lt_max = jb < jb_max; \ |
| 565 \ | |
| 566 while (ja_lt_max || jb_lt_max ) \ | |
| 567 { \ | |
| 568 OCTAVE_QUIT; \ | |
| 569 if ((! jb_lt_max) || \ | |
| 570 (ja_lt_max && (m1.ridx(ja) < m2.ridx(jb)))) \ | |
| 571 { \ | |
| 572 ja++; ja_lt_max= ja < ja_max; \ | |
| 573 } \ | |
| 574 else if (( !ja_lt_max ) || \ | |
| 575 (jb_lt_max && (m2.ridx(jb) < m1.ridx(ja)) ) ) \ | |
| 576 { \ | |
| 577 jb++; jb_lt_max= jb < jb_max; \ | |
| 578 } \ | |
| 579 else \ | |
| 580 { \ | |
| 581 if ((m1.data(ja) OP m2.data(jb)) != 0.) \ | |
| 582 { \ | |
| 583 r.data(jx) = m1.data(ja) OP m2.data(jb); \ | |
| 584 r.ridx(jx) = m1.ridx(ja); \ | |
| 585 jx++; \ | |
| 586 } \ | |
| 587 ja++; ja_lt_max= ja < ja_max; \ | |
| 588 jb++; jb_lt_max= jb < jb_max; \ | |
| 589 } \ | |
| 590 } \ | |
| 591 r.cidx(i+1) = jx; \ | |
| 592 } \ | |
| 593 \ | |
| 594 r.maybe_compress (); \ | |
| 595 } \ | |
| 596 \ | |
| 597 return r; \ | |
| 598 } | |
| 599 | |
| 600 #define SPARSE_SMSM_BIN_OP_3(R, F, OP, M1, M2) \ | |
| 601 R \ | |
| 602 F (const M1& m1, const M2& m2) \ | |
| 603 { \ | |
| 604 R r; \ | |
| 605 \ | |
| 5275 | 606 octave_idx_type m1_nr = m1.rows (); \ |
| 607 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 608 \ |
| 5275 | 609 octave_idx_type m2_nr = m2.rows (); \ |
| 610 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 611 \ |
| 6221 | 612 if (m1_nr == 1 && m1_nc == 1) \ |
| 613 { \ | |
| 614 if ((m1.elem (0,0) OP Complex()) == Complex()) \ | |
| 615 { \ | |
| 616 octave_idx_type m2_nnz = m2.nnz(); \ | |
| 617 r = R (m2); \ | |
| 618 for (octave_idx_type i = 0 ; i < m2_nnz ; i++) \ | |
| 619 r.data (i) = m1.elem(0,0) OP r.data(i); \ | |
| 620 r.maybe_compress (); \ | |
| 621 } \ | |
| 622 else \ | |
| 623 { \ | |
| 624 r = R (m2_nr, m2_nc, m1.elem(0,0) OP Complex ()); \ | |
| 625 for (octave_idx_type j = 0 ; j < m2_nc ; j++) \ | |
| 626 { \ | |
| 627 OCTAVE_QUIT; \ | |
| 628 octave_idx_type idxj = j * m2_nr; \ | |
| 629 for (octave_idx_type i = m2.cidx(j) ; i < m2.cidx(j+1) ; i++) \ | |
| 630 { \ | |
| 631 OCTAVE_QUIT; \ | |
| 632 r.data(idxj + m2.ridx(i)) = m1.elem(0,0) OP m2.data(i); \ | |
| 633 } \ | |
| 634 } \ | |
| 635 r.maybe_compress (); \ | |
| 636 } \ | |
| 637 } \ | |
| 638 else if (m2_nr == 1 && m2_nc == 1) \ | |
| 639 { \ | |
| 640 if ((Complex() OP m1.elem (0,0)) == Complex()) \ | |
| 641 { \ | |
| 642 octave_idx_type m1_nnz = m1.nnz(); \ | |
| 643 r = R (m1); \ | |
| 644 for (octave_idx_type i = 0 ; i < m1_nnz ; i++) \ | |
| 645 r.data (i) = r.data(i) OP m2.elem(0,0); \ | |
| 646 r.maybe_compress (); \ | |
| 647 } \ | |
| 648 else \ | |
| 649 { \ | |
| 650 r = R (m1_nr, m1_nc, Complex() OP m2.elem(0,0)); \ | |
| 651 for (octave_idx_type j = 0 ; j < m1_nc ; j++) \ | |
| 652 { \ | |
| 653 OCTAVE_QUIT; \ | |
| 654 octave_idx_type idxj = j * m1_nr; \ | |
| 655 for (octave_idx_type i = m1.cidx(j) ; i < m1.cidx(j+1) ; i++) \ | |
| 656 { \ | |
| 657 OCTAVE_QUIT; \ | |
| 658 r.data(idxj + m1.ridx(i)) = m1.data(i) OP m2.elem(0,0); \ | |
| 659 } \ | |
| 660 } \ | |
| 661 r.maybe_compress (); \ | |
| 662 } \ | |
| 663 } \ | |
| 664 else if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 5164 | 665 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 666 else \ | |
| 667 { \ | |
| 668 \ | |
| 5775 | 669 /* FIXME Kludge... Always double/Complex, so Complex () */ \ |
| 5164 | 670 r = R (m1_nr, m1_nc, (Complex () OP Complex ())); \ |
| 671 \ | |
| 5275 | 672 for (octave_idx_type i = 0 ; i < m1_nc ; i++) \ |
| 5164 | 673 { \ |
| 5275 | 674 octave_idx_type ja = m1.cidx(i); \ |
| 675 octave_idx_type ja_max = m1.cidx(i+1); \ | |
| 5164 | 676 bool ja_lt_max= ja < ja_max; \ |
| 677 \ | |
| 5275 | 678 octave_idx_type jb = m2.cidx(i); \ |
| 679 octave_idx_type jb_max = m2.cidx(i+1); \ | |
| 5164 | 680 bool jb_lt_max = jb < jb_max; \ |
| 681 \ | |
| 682 while (ja_lt_max || jb_lt_max ) \ | |
| 683 { \ | |
| 684 OCTAVE_QUIT; \ | |
| 685 if ((! jb_lt_max) || \ | |
| 686 (ja_lt_max && (m1.ridx(ja) < m2.ridx(jb)))) \ | |
| 687 { \ | |
| 688 /* keep those kludges coming */ \ | |
| 689 r.elem(m1.ridx(ja),i) = m1.data(ja) OP Complex (); \ | |
| 690 ja++; \ | |
| 691 ja_lt_max= ja < ja_max; \ | |
| 692 } \ | |
| 693 else if (( !ja_lt_max ) || \ | |
| 694 (jb_lt_max && (m2.ridx(jb) < m1.ridx(ja)) ) ) \ | |
| 695 { \ | |
| 696 /* keep those kludges coming */ \ | |
| 697 r.elem(m2.ridx(jb),i) = Complex () OP m2.data(jb); \ | |
| 698 jb++; \ | |
| 699 jb_lt_max= jb < jb_max; \ | |
| 700 } \ | |
| 701 else \ | |
| 702 { \ | |
| 703 r.elem(m1.ridx(ja),i) = m1.data(ja) OP m2.data(jb); \ | |
| 704 ja++; \ | |
| 705 ja_lt_max= ja < ja_max; \ | |
| 706 jb++; \ | |
| 707 jb_lt_max= jb < jb_max; \ | |
| 708 } \ | |
| 709 } \ | |
| 710 } \ | |
| 711 r.maybe_compress (true); \ | |
| 712 } \ | |
| 713 \ | |
| 714 return r; \ | |
| 715 } | |
| 716 | |
| 717 // Note that SM ./ SM needs to take into account the NaN and Inf values | |
| 718 // implied by the division by zero. | |
| 5775 | 719 // FIXME Are the NaNs double(NaN) or Complex(NaN,Nan) in the complex |
| 5164 | 720 // case? |
| 721 #define SPARSE_SMSM_BIN_OPS(R1, R2, M1, M2) \ | |
| 722 SPARSE_SMSM_BIN_OP_1 (R1, operator +, +, M1, M2) \ | |
| 723 SPARSE_SMSM_BIN_OP_1 (R1, operator -, -, M1, M2) \ | |
| 724 SPARSE_SMSM_BIN_OP_2 (R2, product, *, M1, M2) \ | |
| 725 SPARSE_SMSM_BIN_OP_3 (R2, quotient, /, M1, M2) | |
| 726 | |
| 6708 | 727 #define SPARSE_SMSM_CMP_OP_DECLS(M1, M2, API) \ |
| 728 SPARSE_CMP_OP_DECL (mx_el_lt, M1, M2, API); \ | |
| 729 SPARSE_CMP_OP_DECL (mx_el_le, M1, M2, API); \ | |
| 730 SPARSE_CMP_OP_DECL (mx_el_ge, M1, M2, API); \ | |
| 731 SPARSE_CMP_OP_DECL (mx_el_gt, M1, M2, API); \ | |
| 732 SPARSE_CMP_OP_DECL (mx_el_eq, M1, M2, API); \ | |
| 733 SPARSE_CMP_OP_DECL (mx_el_ne, M1, M2, API); | |
| 5164 | 734 |
| 6708 | 735 #define SPARSE_SMSM_EQNE_OP_DECLS(M1, M2, API) \ |
| 736 SPARSE_CMP_OP_DECL (mx_el_eq, M1, M2, API); \ | |
| 737 SPARSE_CMP_OP_DECL (mx_el_ne, M1, M2, API); | |
| 5164 | 738 |
| 8198 | 739 // FIXME -- this macro duplicatest the bodies of the template |
| 740 // functions defined in the SPARSE_SSM_CMP_OP and SPARSE_SMS_CMP_OP | |
| 741 // macros. | |
| 742 | |
| 7269 | 743 #define SPARSE_SMSM_CMP_OP(F, OP, M1, Z1, C1, M2, Z2, C2) \ |
| 5164 | 744 SparseBoolMatrix \ |
| 745 F (const M1& m1, const M2& m2) \ | |
| 746 { \ | |
| 747 SparseBoolMatrix r; \ | |
| 748 \ | |
| 5275 | 749 octave_idx_type m1_nr = m1.rows (); \ |
| 750 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 751 \ |
| 5275 | 752 octave_idx_type m2_nr = m2.rows (); \ |
| 753 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 754 \ |
| 6221 | 755 if (m1_nr == 1 && m1_nc == 1) \ |
| 756 { \ | |
| 8187 | 757 if (C1 (m1.elem(0,0)) OP C2 (Z2)) \ |
| 758 { \ | |
| 759 r = SparseBoolMatrix (m2_nr, m2_nc, true); \ | |
| 760 for (octave_idx_type j = 0; j < m2_nc; j++) \ | |
| 761 for (octave_idx_type i = m2.cidx(j); i < m2.cidx(j+1); i++) \ | |
| 762 if (! (C1 (m1.elem (0,0)) OP C2 (m2.data(i)))) \ | |
| 763 r.data (m2.ridx (i) + j * m2_nr) = false; \ | |
| 764 r.maybe_compress (true); \ | |
| 765 } \ | |
| 766 else \ | |
| 767 { \ | |
| 768 r = SparseBoolMatrix (m2_nr, m2_nc, m2.nnz ()); \ | |
| 769 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 770 octave_idx_type nel = 0; \ | |
| 771 for (octave_idx_type j = 0; j < m2_nc; j++) \ | |
| 772 { \ | |
| 773 for (octave_idx_type i = m2.cidx(j); i < m2.cidx(j+1); i++) \ | |
| 774 if (C1 (m1.elem (0,0)) OP C2 (m2.data(i))) \ | |
| 775 { \ | |
| 776 r.ridx (nel) = m2.ridx (i); \ | |
| 777 r.data (nel++) = true; \ | |
| 778 } \ | |
| 779 r.cidx (j + 1) = nel; \ | |
| 780 } \ | |
| 781 r.maybe_compress (false); \ | |
| 782 } \ | |
| 6221 | 783 } \ |
| 784 else if (m2_nr == 1 && m2_nc == 1) \ | |
| 785 { \ | |
| 8187 | 786 if (C1 (Z1) OP C2 (m2.elem (0,0))) \ |
| 787 { \ | |
| 788 r = SparseBoolMatrix (m1_nr, m1_nc, true); \ | |
| 789 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 790 for (octave_idx_type i = m1.cidx(j); i < m1.cidx(j+1); i++) \ | |
| 791 if (! (C1 (m1.data (i)) OP C2 (m2.elem(0,0)))) \ | |
| 792 r.data (m1.ridx (i) + j * m1_nr) = false; \ | |
| 793 r.maybe_compress (true); \ | |
| 794 } \ | |
| 795 else \ | |
| 796 { \ | |
| 797 r = SparseBoolMatrix (m1_nr, m1_nc, m1.nnz ()); \ | |
| 798 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 799 octave_idx_type nel = 0; \ | |
| 800 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 801 { \ | |
| 802 for (octave_idx_type i = m1.cidx(j); i < m1.cidx(j+1); i++) \ | |
| 803 if (C1 (m1.data (i)) OP C2 (m2.elem(0,0))) \ | |
| 804 { \ | |
| 805 r.ridx (nel) = m1.ridx (i); \ | |
| 806 r.data (nel++) = true; \ | |
| 807 } \ | |
| 808 r.cidx (j + 1) = nel; \ | |
| 809 } \ | |
| 810 r.maybe_compress (false); \ | |
| 811 } \ | |
| 6221 | 812 } \ |
| 813 else if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 5164 | 814 { \ |
| 815 if (m1_nr != 0 || m1_nc != 0) \ | |
| 816 { \ | |
| 7269 | 817 if (C1 (Z1) OP C2 (Z2)) \ |
| 5164 | 818 { \ |
| 7269 | 819 r = SparseBoolMatrix (m1_nr, m1_nc, true); \ |
| 820 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 821 { \ | |
| 822 octave_idx_type i1 = m1.cidx (j); \ | |
| 823 octave_idx_type e1 = m1.cidx (j+1); \ | |
| 824 octave_idx_type i2 = m2.cidx (j); \ | |
| 825 octave_idx_type e2 = m2.cidx (j+1); \ | |
| 826 while (i1 < e1 || i2 < e2) \ | |
| 827 { \ | |
| 828 if (i1 == e1 || (i2 < e2 && m1.ridx(i1) > m2.ridx(i2))) \ | |
| 829 { \ | |
| 830 if (! (C1 (Z1) OP C2 (m2.data (i2)))) \ | |
| 831 r.data (m2.ridx (i2) + j * m1_nr) = false; \ | |
| 832 i2++; \ | |
| 833 } \ | |
| 834 else if (i2 == e2 || m1.ridx(i1) < m2.ridx(i2)) \ | |
| 835 { \ | |
| 836 if (! (C1 (m1.data (i1)) OP C2 (Z2))) \ | |
| 837 r.data (m1.ridx (i1) + j * m1_nr) = false; \ | |
| 838 i1++; \ | |
| 839 } \ | |
| 840 else \ | |
| 841 { \ | |
| 842 if (! (C1 (m1.data (i1)) OP C2 (m2.data (i2)))) \ | |
| 843 r.data (m1.ridx (i1) + j * m1_nr) = false; \ | |
| 844 i1++; \ | |
| 845 i2++; \ | |
| 846 } \ | |
| 847 } \ | |
| 848 } \ | |
| 849 r.maybe_compress (true); \ | |
| 850 } \ | |
| 851 else \ | |
| 852 { \ | |
| 853 r = SparseBoolMatrix (m1_nr, m1_nc, m1.nnz () + m2.nnz ()); \ | |
| 854 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 855 octave_idx_type nel = 0; \ | |
| 856 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 857 { \ | |
| 858 octave_idx_type i1 = m1.cidx (j); \ | |
| 859 octave_idx_type e1 = m1.cidx (j+1); \ | |
| 860 octave_idx_type i2 = m2.cidx (j); \ | |
| 861 octave_idx_type e2 = m2.cidx (j+1); \ | |
| 862 while (i1 < e1 || i2 < e2) \ | |
| 863 { \ | |
| 864 if (i1 == e1 || (i2 < e2 && m1.ridx(i1) > m2.ridx(i2))) \ | |
| 865 { \ | |
| 866 if (C1 (Z1) OP C2 (m2.data (i2))) \ | |
| 867 { \ | |
| 868 r.ridx (nel) = m2.ridx (i2); \ | |
| 869 r.data (nel++) = true; \ | |
| 870 } \ | |
| 871 i2++; \ | |
| 872 } \ | |
| 873 else if (i2 == e2 || m1.ridx(i1) < m2.ridx(i2)) \ | |
| 874 { \ | |
| 875 if (C1 (m1.data (i1)) OP C2 (Z2)) \ | |
| 876 { \ | |
| 877 r.ridx (nel) = m1.ridx (i1); \ | |
| 878 r.data (nel++) = true; \ | |
| 879 } \ | |
| 880 i1++; \ | |
| 881 } \ | |
| 882 else \ | |
| 883 { \ | |
| 884 if (C1 (m1.data (i1)) OP C2 (m2.data (i2))) \ | |
| 885 { \ | |
| 886 r.ridx (nel) = m1.ridx (i1); \ | |
| 887 r.data (nel++) = true; \ | |
| 888 } \ | |
| 889 i1++; \ | |
| 890 i2++; \ | |
| 891 } \ | |
| 892 } \ | |
| 893 r.cidx (j + 1) = nel; \ | |
| 894 } \ | |
| 895 r.maybe_compress (false); \ | |
| 896 } \ | |
| 5164 | 897 } \ |
| 898 } \ | |
| 899 else \ | |
| 900 { \ | |
| 901 if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \ | |
| 902 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 903 } \ | |
| 904 return r; \ | |
| 905 } | |
| 906 | |
| 907 #define SPARSE_SMSM_CMP_OPS(M1, Z1, C1, M2, Z2, C2) \ | |
|
9578
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
908 SPARSE_SMSM_CMP_OP (mx_el_lt, <, M1, Z1, , M2, Z2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
909 SPARSE_SMSM_CMP_OP (mx_el_le, <=, M1, Z1, , M2, Z2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
910 SPARSE_SMSM_CMP_OP (mx_el_ge, >=, M1, Z1, , M2, Z2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
911 SPARSE_SMSM_CMP_OP (mx_el_gt, >, M1, Z1, , M2, Z2, ) \ |
| 7269 | 912 SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, Z1, , M2, Z2, ) \ |
| 913 SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, Z1, , M2, Z2, ) | |
| 5164 | 914 |
| 915 #define SPARSE_SMSM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2) \ | |
| 7269 | 916 SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, Z1, , M2, Z2, ) \ |
| 917 SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, Z1, , M2, Z2, ) | |
| 5164 | 918 |
| 6708 | 919 #define SPARSE_SMSM_BOOL_OP_DECLS(M1, M2, API) \ |
| 920 SPARSE_BOOL_OP_DECL (mx_el_and, M1, M2, API); \ | |
| 921 SPARSE_BOOL_OP_DECL (mx_el_or, M1, M2, API); | |
| 5164 | 922 |
| 8198 | 923 // FIXME -- this macro duplicatest the bodies of the template |
| 924 // functions defined in the SPARSE_SSM_BOOL_OP and SPARSE_SMS_BOOL_OP | |
| 925 // macros. | |
| 926 | |
| 5164 | 927 #define SPARSE_SMSM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO) \ |
| 928 SparseBoolMatrix \ | |
| 929 F (const M1& m1, const M2& m2) \ | |
| 930 { \ | |
| 931 SparseBoolMatrix r; \ | |
| 932 \ | |
| 5275 | 933 octave_idx_type m1_nr = m1.rows (); \ |
| 934 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 935 \ |
| 5275 | 936 octave_idx_type m2_nr = m2.rows (); \ |
| 937 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 938 \ |
| 6221 | 939 if (m1_nr == 1 && m1_nc == 1) \ |
| 940 { \ | |
| 8198 | 941 if (m2_nr > 0 && m2_nc > 0) \ |
| 942 { \ | |
| 943 if ((m1.elem(0,0) != LHS_ZERO) OP RHS_ZERO) \ | |
| 944 { \ | |
| 945 r = SparseBoolMatrix (m2_nr, m2_nc, true); \ | |
| 946 for (octave_idx_type j = 0; j < m2_nc; j++) \ | |
| 947 for (octave_idx_type i = m2.cidx(j); i < m2.cidx(j+1); i++) \ | |
| 948 if (! ((m1.elem(0,0) != LHS_ZERO) OP (m2.data(i) != RHS_ZERO))) \ | |
| 949 r.data (m2.ridx (i) + j * m2_nr) = false; \ | |
| 950 r.maybe_compress (true); \ | |
| 951 } \ | |
| 952 else \ | |
| 953 { \ | |
| 954 r = SparseBoolMatrix (m2_nr, m2_nc, m2.nnz ()); \ | |
| 955 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 956 octave_idx_type nel = 0; \ | |
| 957 for (octave_idx_type j = 0; j < m2_nc; j++) \ | |
| 958 { \ | |
| 959 for (octave_idx_type i = m2.cidx(j); i < m2.cidx(j+1); i++) \ | |
| 960 if ((m1.elem(0,0) != LHS_ZERO) OP (m2.data(i) != RHS_ZERO)) \ | |
| 961 { \ | |
| 962 r.ridx (nel) = m2.ridx (i); \ | |
| 963 r.data (nel++) = true; \ | |
| 964 } \ | |
| 965 r.cidx (j + 1) = nel; \ | |
| 966 } \ | |
| 967 r.maybe_compress (false); \ | |
| 968 } \ | |
| 969 } \ | |
| 6221 | 970 } \ |
| 971 else if (m2_nr == 1 && m2_nc == 1) \ | |
| 972 { \ | |
| 8198 | 973 if (m1_nr > 0 && m1_nc > 0) \ |
| 974 { \ | |
| 975 if (LHS_ZERO OP (m2.elem(0,0) != RHS_ZERO)) \ | |
| 976 { \ | |
| 977 r = SparseBoolMatrix (m1_nr, m1_nc, true); \ | |
| 978 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 979 for (octave_idx_type i = m1.cidx(j); i < m1.cidx(j+1); i++) \ | |
| 980 if (! ((m1.data(i) != LHS_ZERO) OP (m2.elem(0,0) != RHS_ZERO))) \ | |
| 981 r.data (m1.ridx (i) + j * m1_nr) = false; \ | |
| 982 r.maybe_compress (true); \ | |
| 983 } \ | |
| 984 else \ | |
| 985 { \ | |
| 986 r = SparseBoolMatrix (m1_nr, m1_nc, m1.nnz ()); \ | |
| 987 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 988 octave_idx_type nel = 0; \ | |
| 989 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 990 { \ | |
| 991 for (octave_idx_type i = m1.cidx(j); i < m1.cidx(j+1); i++) \ | |
| 992 if ((m1.data(i) != LHS_ZERO) OP (m2.elem(0,0) != RHS_ZERO)) \ | |
| 993 { \ | |
| 994 r.ridx (nel) = m1.ridx (i); \ | |
| 995 r.data (nel++) = true; \ | |
| 996 } \ | |
| 997 r.cidx (j + 1) = nel; \ | |
| 998 } \ | |
| 999 r.maybe_compress (false); \ | |
| 1000 } \ | |
| 1001 } \ | |
| 6221 | 1002 } \ |
| 1003 else if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 5164 | 1004 { \ |
| 1005 if (m1_nr != 0 || m1_nc != 0) \ | |
| 1006 { \ | |
| 7269 | 1007 r = SparseBoolMatrix (m1_nr, m1_nc, m1.nnz () + m2.nnz ()); \ |
| 1008 r.cidx (0) = static_cast<octave_idx_type> (0); \ | |
| 1009 octave_idx_type nel = 0; \ | |
| 5275 | 1010 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
| 7269 | 1011 { \ |
| 1012 octave_idx_type i1 = m1.cidx (j); \ | |
| 1013 octave_idx_type e1 = m1.cidx (j+1); \ | |
| 1014 octave_idx_type i2 = m2.cidx (j); \ | |
| 1015 octave_idx_type e2 = m2.cidx (j+1); \ | |
| 1016 while (i1 < e1 || i2 < e2) \ | |
| 1017 { \ | |
| 1018 if (i1 == e1 || (i2 < e2 && m1.ridx(i1) > m2.ridx(i2))) \ | |
| 1019 { \ | |
| 1020 if (LHS_ZERO OP m2.data (i2) != RHS_ZERO) \ | |
| 1021 { \ | |
| 1022 r.ridx (nel) = m2.ridx (i2); \ | |
| 1023 r.data (nel++) = true; \ | |
| 1024 } \ | |
| 1025 i2++; \ | |
| 1026 } \ | |
| 1027 else if (i2 == e2 || m1.ridx(i1) < m2.ridx(i2)) \ | |
| 1028 { \ | |
| 1029 if (m1.data (i1) != LHS_ZERO OP RHS_ZERO) \ | |
| 1030 { \ | |
| 1031 r.ridx (nel) = m1.ridx (i1); \ | |
| 1032 r.data (nel++) = true; \ | |
| 1033 } \ | |
| 1034 i1++; \ | |
| 1035 } \ | |
| 1036 else \ | |
| 1037 { \ | |
| 1038 if (m1.data (i1) != LHS_ZERO OP m2.data(i2) != RHS_ZERO) \ | |
| 1039 { \ | |
| 1040 r.ridx (nel) = m1.ridx (i1); \ | |
| 1041 r.data (nel++) = true; \ | |
| 1042 } \ | |
| 1043 i1++; \ | |
| 1044 i2++; \ | |
| 1045 } \ | |
| 1046 } \ | |
| 1047 r.cidx (j + 1) = nel; \ | |
| 1048 } \ | |
| 1049 r.maybe_compress (false); \ | |
| 5164 | 1050 } \ |
| 1051 } \ | |
| 1052 else \ | |
| 1053 { \ | |
| 1054 if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \ | |
| 1055 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 1056 } \ | |
| 1057 return r; \ | |
| 1058 } | |
| 1059 | |
| 1060 #define SPARSE_SMSM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1061 SPARSE_SMSM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1062 SPARSE_SMSM_BOOL_OP (mx_el_or, ||, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1063 | |
| 1064 #define SPARSE_SMSM_BOOL_OPS(M1, M2, ZERO) \ | |
| 1065 SPARSE_SMSM_BOOL_OPS2(M1, M2, ZERO, ZERO) | |
| 1066 | |
| 6708 | 1067 #define SPARSE_SMSM_OP_DECLS(R1, R2, M1, M2, API) \ |
| 1068 SPARSE_SMSM_BIN_OP_DECLS (R1, R2, M1, M2, API) \ | |
| 1069 SPARSE_SMSM_CMP_OP_DECLS (M1, M2, API) \ | |
| 1070 SPARSE_SMSM_BOOL_OP_DECLS (M1, M2, API) | |
| 5164 | 1071 |
| 1072 // matrix by matrix operations. | |
| 1073 | |
| 6708 | 1074 #define SPARSE_MSM_BIN_OP_DECLS(R1, R2, M1, M2, API) \ |
| 1075 SPARSE_BIN_OP_DECL (R1, operator +, M1, M2, API); \ | |
| 1076 SPARSE_BIN_OP_DECL (R1, operator -, M1, M2, API); \ | |
| 1077 SPARSE_BIN_OP_DECL (R2, product, M1, M2, API); \ | |
| 1078 SPARSE_BIN_OP_DECL (R2, quotient, M1, M2, API); | |
| 5164 | 1079 |
| 1080 #define SPARSE_MSM_BIN_OP_1(R, F, OP, M1, M2) \ | |
| 1081 R \ | |
| 1082 F (const M1& m1, const M2& m2) \ | |
| 1083 { \ | |
| 1084 R r; \ | |
| 1085 \ | |
| 5275 | 1086 octave_idx_type m1_nr = m1.rows (); \ |
| 1087 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1088 \ |
| 5275 | 1089 octave_idx_type m2_nr = m2.rows (); \ |
| 1090 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1091 \ |
| 6221 | 1092 if (m2_nr == 1 && m2_nc == 1) \ |
| 1093 r = R (m1 OP m2.elem(0,0)); \ | |
| 1094 else if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 5164 | 1095 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 1096 else \ | |
| 1097 { \ | |
| 1098 r = R (m1_nr, m1_nc); \ | |
| 1099 \ | |
| 5275 | 1100 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
| 1101 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1102 r.elem (i, j) = m1.elem (i, j) OP m2.elem (i, j); \ |
| 1103 } \ | |
| 1104 return r; \ | |
| 1105 } | |
| 1106 | |
| 1107 #define SPARSE_MSM_BIN_OP_2(R, F, OP, M1, M2, ZERO) \ | |
| 1108 R \ | |
| 1109 F (const M1& m1, const M2& m2) \ | |
| 1110 { \ | |
| 1111 R r; \ | |
| 1112 \ | |
| 5275 | 1113 octave_idx_type m1_nr = m1.rows (); \ |
| 1114 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1115 \ |
| 5275 | 1116 octave_idx_type m2_nr = m2.rows (); \ |
| 1117 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1118 \ |
| 6221 | 1119 if (m2_nr == 1 && m2_nc == 1) \ |
| 1120 r = R (m1 OP m2.elem(0,0)); \ | |
| 1121 else if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 5164 | 1122 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 1123 else \ | |
| 1124 { \ | |
| 1125 /* Count num of non-zero elements */ \ | |
| 5275 | 1126 octave_idx_type nel = 0; \ |
| 1127 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 1128 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1129 if ((m1.elem(i, j) OP m2.elem(i, j)) != ZERO) \ |
| 1130 nel++; \ | |
| 1131 \ | |
| 1132 r = R (m1_nr, m1_nc, nel); \ | |
| 1133 \ | |
| 5275 | 1134 octave_idx_type ii = 0; \ |
| 5164 | 1135 r.cidx (0) = 0; \ |
| 5275 | 1136 for (octave_idx_type j = 0 ; j < m1_nc ; j++) \ |
| 5164 | 1137 { \ |
| 5275 | 1138 for (octave_idx_type i = 0 ; i < m1_nr ; i++) \ |
| 5164 | 1139 { \ |
| 1140 if ((m1.elem(i, j) OP m2.elem(i, j)) != ZERO) \ | |
| 1141 { \ | |
| 1142 r.data (ii) = m1.elem(i, j) OP m2.elem(i,j); \ | |
| 1143 r.ridx (ii++) = i; \ | |
| 1144 } \ | |
| 1145 } \ | |
| 1146 r.cidx(j+1) = ii; \ | |
| 1147 } \ | |
| 1148 } \ | |
| 1149 \ | |
| 1150 return r; \ | |
| 1151 } | |
| 1152 | |
| 5775 | 1153 // FIXME Pass a specific ZERO value |
| 5164 | 1154 #define SPARSE_MSM_BIN_OPS(R1, R2, M1, M2) \ |
| 1155 SPARSE_MSM_BIN_OP_1 (R1, operator +, +, M1, M2) \ | |
| 1156 SPARSE_MSM_BIN_OP_1 (R1, operator -, -, M1, M2) \ | |
| 1157 SPARSE_MSM_BIN_OP_2 (R2, product, *, M1, M2, 0.0) \ | |
| 1158 SPARSE_MSM_BIN_OP_2 (R2, quotient, /, M1, M2, 0.0) | |
| 1159 | |
| 6708 | 1160 #define SPARSE_MSM_CMP_OP_DECLS(M1, M2, API) \ |
| 1161 SPARSE_CMP_OP_DECL (mx_el_lt, M1, M2, API); \ | |
| 1162 SPARSE_CMP_OP_DECL (mx_el_le, M1, M2, API); \ | |
| 1163 SPARSE_CMP_OP_DECL (mx_el_ge, M1, M2, API); \ | |
| 1164 SPARSE_CMP_OP_DECL (mx_el_gt, M1, M2, API); \ | |
| 1165 SPARSE_CMP_OP_DECL (mx_el_eq, M1, M2, API); \ | |
| 1166 SPARSE_CMP_OP_DECL (mx_el_ne, M1, M2, API); | |
| 5164 | 1167 |
| 6708 | 1168 #define SPARSE_MSM_EQNE_OP_DECLS(M1, M2, API) \ |
| 1169 SPARSE_CMP_OP_DECL (mx_el_eq, M1, M2, API); \ | |
| 1170 SPARSE_CMP_OP_DECL (mx_el_ne, M1, M2, API); | |
| 5164 | 1171 |
| 1172 #define SPARSE_MSM_CMP_OP(F, OP, M1, C1, M2, C2) \ | |
| 1173 SparseBoolMatrix \ | |
| 1174 F (const M1& m1, const M2& m2) \ | |
| 1175 { \ | |
| 1176 SparseBoolMatrix r; \ | |
| 1177 \ | |
| 5275 | 1178 octave_idx_type m1_nr = m1.rows (); \ |
| 1179 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1180 \ |
| 5275 | 1181 octave_idx_type m2_nr = m2.rows (); \ |
| 1182 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1183 \ |
| 6221 | 1184 if (m2_nr == 1 && m2_nc == 1) \ |
| 1185 r = SparseBoolMatrix (F (m1, m2.elem(0,0))); \ | |
| 1186 else if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 5164 | 1187 { \ |
| 1188 if (m1_nr != 0 || m1_nc != 0) \ | |
| 1189 { \ | |
| 1190 /* Count num of non-zero elements */ \ | |
| 5275 | 1191 octave_idx_type nel = 0; \ |
| 1192 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 1193 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1194 if (C1 (m1.elem(i, j)) OP C2 (m2.elem(i, j))) \ |
| 1195 nel++; \ | |
| 1196 \ | |
| 1197 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \ | |
| 1198 \ | |
| 5275 | 1199 octave_idx_type ii = 0; \ |
| 5164 | 1200 r.cidx (0) = 0; \ |
| 5275 | 1201 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
| 5164 | 1202 { \ |
| 5275 | 1203 for (octave_idx_type i = 0; i < m1_nr; i++) \ |
| 5164 | 1204 { \ |
| 1205 bool el = C1 (m1.elem(i, j)) OP C2 (m2.elem(i, j)); \ | |
| 1206 if (el) \ | |
| 1207 { \ | |
| 1208 r.data(ii) = el; \ | |
| 1209 r.ridx(ii++) = i; \ | |
| 1210 } \ | |
| 1211 } \ | |
| 1212 r.cidx(j+1) = ii; \ | |
| 1213 } \ | |
| 1214 } \ | |
| 1215 } \ | |
| 1216 else \ | |
| 1217 { \ | |
| 1218 if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \ | |
| 1219 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 1220 } \ | |
| 1221 return r; \ | |
| 1222 } | |
| 1223 | |
| 1224 #define SPARSE_MSM_CMP_OPS(M1, Z1, C1, M2, Z2, C2) \ | |
|
9578
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1225 SPARSE_MSM_CMP_OP (mx_el_lt, <, M1, , M2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1226 SPARSE_MSM_CMP_OP (mx_el_le, <=, M1, , M2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1227 SPARSE_MSM_CMP_OP (mx_el_ge, >=, M1, , M2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1228 SPARSE_MSM_CMP_OP (mx_el_gt, >, M1, , M2, ) \ |
| 5164 | 1229 SPARSE_MSM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \ |
| 1230 SPARSE_MSM_CMP_OP (mx_el_ne, !=, M1, , M2, ) | |
| 1231 | |
| 1232 #define SPARSE_MSM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2) \ | |
| 1233 SPARSE_MSM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \ | |
| 1234 SPARSE_MSM_CMP_OP (mx_el_ne, !=, M1, , M2, ) | |
| 1235 | |
| 6708 | 1236 #define SPARSE_MSM_BOOL_OP_DECLS(M1, M2, API) \ |
| 1237 SPARSE_BOOL_OP_DECL (mx_el_and, M1, M2, API); \ | |
| 1238 SPARSE_BOOL_OP_DECL (mx_el_or, M1, M2, API); | |
| 5164 | 1239 |
| 1240 #define SPARSE_MSM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1241 SparseBoolMatrix \ | |
| 1242 F (const M1& m1, const M2& m2) \ | |
| 1243 { \ | |
| 1244 SparseBoolMatrix r; \ | |
| 1245 \ | |
| 5275 | 1246 octave_idx_type m1_nr = m1.rows (); \ |
| 1247 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1248 \ |
| 5275 | 1249 octave_idx_type m2_nr = m2.rows (); \ |
| 1250 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1251 \ |
| 6221 | 1252 if (m2_nr == 1 && m2_nc == 1) \ |
| 1253 r = SparseBoolMatrix (F (m1, m2.elem(0,0))); \ | |
| 1254 else if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 5164 | 1255 { \ |
| 1256 if (m1_nr != 0 || m1_nc != 0) \ | |
| 1257 { \ | |
| 1258 /* Count num of non-zero elements */ \ | |
| 5275 | 1259 octave_idx_type nel = 0; \ |
| 1260 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 1261 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1262 if ((m1.elem(i, j) != LHS_ZERO) \ |
| 1263 OP (m2.elem(i, j) != RHS_ZERO)) \ | |
| 1264 nel++; \ | |
| 1265 \ | |
| 1266 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \ | |
| 1267 \ | |
| 5275 | 1268 octave_idx_type ii = 0; \ |
| 5164 | 1269 r.cidx (0) = 0; \ |
| 5275 | 1270 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
| 5164 | 1271 { \ |
| 5275 | 1272 for (octave_idx_type i = 0; i < m1_nr; i++) \ |
| 5164 | 1273 { \ |
| 1274 bool el = (m1.elem(i, j) != LHS_ZERO) \ | |
| 1275 OP (m2.elem(i, j) != RHS_ZERO); \ | |
| 1276 if (el) \ | |
| 1277 { \ | |
| 1278 r.data(ii) = el; \ | |
| 1279 r.ridx(ii++) = i; \ | |
| 1280 } \ | |
| 1281 } \ | |
| 1282 r.cidx(j+1) = ii; \ | |
| 1283 } \ | |
| 1284 } \ | |
| 1285 } \ | |
| 1286 else \ | |
| 1287 { \ | |
| 1288 if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \ | |
| 1289 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 1290 } \ | |
| 1291 return r; \ | |
| 1292 } | |
| 1293 | |
| 1294 #define SPARSE_MSM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1295 SPARSE_MSM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1296 SPARSE_MSM_BOOL_OP (mx_el_or, ||, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1297 | |
| 1298 #define SPARSE_MSM_BOOL_OPS(M1, M2, ZERO) \ | |
| 1299 SPARSE_MSM_BOOL_OPS2(M1, M2, ZERO, ZERO) | |
| 1300 | |
| 6708 | 1301 #define SPARSE_MSM_OP_DECLS(R1, R2, M1, M2, API) \ |
| 1302 SPARSE_MSM_BIN_OP_DECLS (R1, R2, M1, M2, API) \ | |
| 1303 SPARSE_MSM_CMP_OP_DECLS (M1, M2, API) \ | |
| 1304 SPARSE_MSM_BOOL_OP_DECLS (M1, M2, API) | |
| 5164 | 1305 |
| 1306 // matrix by matrix operations. | |
| 1307 | |
| 6708 | 1308 #define SPARSE_SMM_BIN_OP_DECLS(R1, R2, M1, M2, API) \ |
| 1309 SPARSE_BIN_OP_DECL (R1, operator +, M1, M2, API); \ | |
| 1310 SPARSE_BIN_OP_DECL (R1, operator -, M1, M2, API); \ | |
| 1311 SPARSE_BIN_OP_DECL (R2, product, M1, M2, API); \ | |
| 1312 SPARSE_BIN_OP_DECL (R2, quotient, M1, M2, API); | |
| 5164 | 1313 |
| 1314 #define SPARSE_SMM_BIN_OP_1(R, F, OP, M1, M2) \ | |
| 1315 R \ | |
| 1316 F (const M1& m1, const M2& m2) \ | |
| 1317 { \ | |
| 1318 R r; \ | |
| 1319 \ | |
| 5275 | 1320 octave_idx_type m1_nr = m1.rows (); \ |
| 1321 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1322 \ |
| 5275 | 1323 octave_idx_type m2_nr = m2.rows (); \ |
| 1324 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1325 \ |
| 6221 | 1326 if (m1_nr == 1 && m1_nc == 1) \ |
| 1327 r = R (m1.elem(0,0) OP m2); \ | |
| 1328 else if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 5164 | 1329 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 1330 else \ | |
| 1331 { \ | |
| 1332 r = R (m1_nr, m1_nc); \ | |
| 1333 \ | |
| 5275 | 1334 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
| 1335 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1336 r.elem (i, j) = m1.elem (i, j) OP m2.elem (i, j); \ |
| 1337 } \ | |
| 1338 return r; \ | |
| 1339 } | |
| 1340 | |
| 1341 #define SPARSE_SMM_BIN_OP_2(R, F, OP, M1, M2, ZERO) \ | |
| 1342 R \ | |
| 1343 F (const M1& m1, const M2& m2) \ | |
| 1344 { \ | |
| 1345 R r; \ | |
| 1346 \ | |
| 5275 | 1347 octave_idx_type m1_nr = m1.rows (); \ |
| 1348 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1349 \ |
| 5275 | 1350 octave_idx_type m2_nr = m2.rows (); \ |
| 1351 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1352 \ |
| 6221 | 1353 if (m1_nr == 1 && m1_nc == 1) \ |
| 1354 r = R (m1.elem(0,0) OP m2); \ | |
| 1355 else if (m1_nr != m2_nr || m1_nc != m2_nc) \ | |
| 5164 | 1356 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ |
| 1357 else \ | |
| 1358 { \ | |
| 1359 /* Count num of non-zero elements */ \ | |
| 5275 | 1360 octave_idx_type nel = 0; \ |
| 1361 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 1362 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1363 if ((m1.elem(i, j) OP m2.elem(i, j)) != ZERO) \ |
| 1364 nel++; \ | |
| 1365 \ | |
| 1366 r = R (m1_nr, m1_nc, nel); \ | |
| 1367 \ | |
| 5275 | 1368 octave_idx_type ii = 0; \ |
| 5164 | 1369 r.cidx (0) = 0; \ |
| 5275 | 1370 for (octave_idx_type j = 0 ; j < m1_nc ; j++) \ |
| 5164 | 1371 { \ |
| 5275 | 1372 for (octave_idx_type i = 0 ; i < m1_nr ; i++) \ |
| 5164 | 1373 { \ |
| 1374 if ((m1.elem(i, j) OP m2.elem(i, j)) != ZERO) \ | |
| 1375 { \ | |
| 1376 r.data (ii) = m1.elem(i, j) OP m2.elem(i,j); \ | |
| 1377 r.ridx (ii++) = i; \ | |
| 1378 } \ | |
| 1379 } \ | |
| 1380 r.cidx(j+1) = ii; \ | |
| 1381 } \ | |
| 1382 } \ | |
| 1383 \ | |
| 1384 return r; \ | |
| 1385 } | |
| 1386 | |
| 5775 | 1387 // FIXME Pass a specific ZERO value |
| 5164 | 1388 #define SPARSE_SMM_BIN_OPS(R1, R2, M1, M2) \ |
| 1389 SPARSE_SMM_BIN_OP_1 (R1, operator +, +, M1, M2) \ | |
| 1390 SPARSE_SMM_BIN_OP_1 (R1, operator -, -, M1, M2) \ | |
| 1391 SPARSE_SMM_BIN_OP_2 (R2, product, *, M1, M2, 0.0) \ | |
| 1392 SPARSE_SMM_BIN_OP_2 (R2, quotient, /, M1, M2, 0.0) | |
| 1393 | |
| 6708 | 1394 #define SPARSE_SMM_CMP_OP_DECLS(M1, M2, API) \ |
| 1395 SPARSE_CMP_OP_DECL (mx_el_lt, M1, M2, API); \ | |
| 1396 SPARSE_CMP_OP_DECL (mx_el_le, M1, M2, API); \ | |
| 1397 SPARSE_CMP_OP_DECL (mx_el_ge, M1, M2, API); \ | |
| 1398 SPARSE_CMP_OP_DECL (mx_el_gt, M1, M2, API); \ | |
| 1399 SPARSE_CMP_OP_DECL (mx_el_eq, M1, M2, API); \ | |
| 1400 SPARSE_CMP_OP_DECL (mx_el_ne, M1, M2, API); | |
| 5164 | 1401 |
| 6708 | 1402 #define SPARSE_SMM_EQNE_OP_DECLS(M1, M2, API) \ |
| 1403 SPARSE_CMP_OP_DECL (mx_el_eq, M1, M2, API); \ | |
| 1404 SPARSE_CMP_OP_DECL (mx_el_ne, M1, M2, API); | |
| 5164 | 1405 |
| 1406 #define SPARSE_SMM_CMP_OP(F, OP, M1, C1, M2, C2) \ | |
| 1407 SparseBoolMatrix \ | |
| 1408 F (const M1& m1, const M2& m2) \ | |
| 1409 { \ | |
| 1410 SparseBoolMatrix r; \ | |
| 1411 \ | |
| 5275 | 1412 octave_idx_type m1_nr = m1.rows (); \ |
| 1413 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1414 \ |
| 5275 | 1415 octave_idx_type m2_nr = m2.rows (); \ |
| 1416 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1417 \ |
| 6221 | 1418 if (m1_nr == 1 && m1_nc == 1) \ |
| 1419 r = SparseBoolMatrix (F (m1.elem(0,0), m2)); \ | |
| 1420 else if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 5164 | 1421 { \ |
| 1422 if (m1_nr != 0 || m1_nc != 0) \ | |
| 1423 { \ | |
| 1424 /* Count num of non-zero elements */ \ | |
| 5275 | 1425 octave_idx_type nel = 0; \ |
| 1426 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 1427 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1428 if (C1 (m1.elem(i, j)) OP C2 (m2.elem(i, j))) \ |
| 1429 nel++; \ | |
| 1430 \ | |
| 1431 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \ | |
| 1432 \ | |
| 5275 | 1433 octave_idx_type ii = 0; \ |
| 5164 | 1434 r.cidx (0) = 0; \ |
| 5275 | 1435 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
| 5164 | 1436 { \ |
| 5275 | 1437 for (octave_idx_type i = 0; i < m1_nr; i++) \ |
| 5164 | 1438 { \ |
| 1439 bool el = C1 (m1.elem(i, j)) OP C2 (m2.elem(i, j)); \ | |
| 1440 if (el) \ | |
| 1441 { \ | |
| 1442 r.data(ii) = el; \ | |
| 1443 r.ridx(ii++) = i; \ | |
| 1444 } \ | |
| 1445 } \ | |
| 1446 r.cidx(j+1) = ii; \ | |
| 1447 } \ | |
| 1448 } \ | |
| 1449 } \ | |
| 1450 else \ | |
| 1451 { \ | |
| 1452 if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \ | |
| 1453 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 1454 } \ | |
| 1455 return r; \ | |
| 1456 } | |
| 1457 | |
| 1458 #define SPARSE_SMM_CMP_OPS(M1, Z1, C1, M2, Z2, C2) \ | |
|
9578
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1459 SPARSE_SMM_CMP_OP (mx_el_lt, <, M1, , M2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1460 SPARSE_SMM_CMP_OP (mx_el_le, <=, M1, , M2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1461 SPARSE_SMM_CMP_OP (mx_el_ge, >=, M1, , M2, ) \ |
|
7dafdb8b062f
refactor comparison ops implementations
Jaroslav Hajek <highegg@gmail.com>
parents:
9417
diff
changeset
|
1462 SPARSE_SMM_CMP_OP (mx_el_gt, >, M1, , M2, ) \ |
| 5164 | 1463 SPARSE_SMM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \ |
| 1464 SPARSE_SMM_CMP_OP (mx_el_ne, !=, M1, , M2, ) | |
| 1465 | |
| 1466 #define SPARSE_SMM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2) \ | |
| 1467 SPARSE_SMM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \ | |
| 1468 SPARSE_SMM_CMP_OP (mx_el_ne, !=, M1, , M2, ) | |
| 1469 | |
| 6708 | 1470 #define SPARSE_SMM_BOOL_OP_DECLS(M1, M2, API) \ |
| 1471 SPARSE_BOOL_OP_DECL (mx_el_and, M1, M2, API); \ | |
| 1472 SPARSE_BOOL_OP_DECL (mx_el_or, M1, M2, API); | |
| 5164 | 1473 |
| 1474 #define SPARSE_SMM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1475 SparseBoolMatrix \ | |
| 1476 F (const M1& m1, const M2& m2) \ | |
| 1477 { \ | |
| 1478 SparseBoolMatrix r; \ | |
| 1479 \ | |
| 5275 | 1480 octave_idx_type m1_nr = m1.rows (); \ |
| 1481 octave_idx_type m1_nc = m1.cols (); \ | |
| 5164 | 1482 \ |
| 5275 | 1483 octave_idx_type m2_nr = m2.rows (); \ |
| 1484 octave_idx_type m2_nc = m2.cols (); \ | |
| 5164 | 1485 \ |
| 6221 | 1486 if (m1_nr == 1 && m1_nc == 1) \ |
| 1487 r = SparseBoolMatrix (F (m1.elem(0,0), m2)); \ | |
| 1488 else if (m1_nr == m2_nr && m1_nc == m2_nc) \ | |
| 5164 | 1489 { \ |
| 1490 if (m1_nr != 0 || m1_nc != 0) \ | |
| 1491 { \ | |
| 1492 /* Count num of non-zero elements */ \ | |
| 5275 | 1493 octave_idx_type nel = 0; \ |
| 1494 for (octave_idx_type j = 0; j < m1_nc; j++) \ | |
| 1495 for (octave_idx_type i = 0; i < m1_nr; i++) \ | |
| 5164 | 1496 if ((m1.elem(i, j) != LHS_ZERO) \ |
| 1497 OP (m2.elem(i, j) != RHS_ZERO)) \ | |
| 1498 nel++; \ | |
| 1499 \ | |
| 1500 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \ | |
| 1501 \ | |
| 5275 | 1502 octave_idx_type ii = 0; \ |
| 5164 | 1503 r.cidx (0) = 0; \ |
| 5275 | 1504 for (octave_idx_type j = 0; j < m1_nc; j++) \ |
| 5164 | 1505 { \ |
| 5275 | 1506 for (octave_idx_type i = 0; i < m1_nr; i++) \ |
| 5164 | 1507 { \ |
| 1508 bool el = (m1.elem(i, j) != LHS_ZERO) \ | |
| 1509 OP (m2.elem(i, j) != RHS_ZERO); \ | |
| 1510 if (el) \ | |
| 1511 { \ | |
| 1512 r.data(ii) = el; \ | |
| 1513 r.ridx(ii++) = i; \ | |
| 1514 } \ | |
| 1515 } \ | |
| 1516 r.cidx(j+1) = ii; \ | |
| 1517 } \ | |
| 1518 } \ | |
| 1519 } \ | |
| 1520 else \ | |
| 1521 { \ | |
| 1522 if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \ | |
| 1523 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \ | |
| 1524 } \ | |
| 1525 return r; \ | |
| 1526 } | |
| 1527 | |
| 1528 #define SPARSE_SMM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1529 SPARSE_SMM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1530 SPARSE_SMM_BOOL_OP (mx_el_or, ||, M1, M2, LHS_ZERO, RHS_ZERO) \ | |
| 1531 | |
| 1532 #define SPARSE_SMM_BOOL_OPS(M1, M2, ZERO) \ | |
| 1533 SPARSE_SMM_BOOL_OPS2(M1, M2, ZERO, ZERO) | |
| 1534 | |
| 6708 | 1535 #define SPARSE_SMM_OP_DECLS(R1, R2, M1, M2, API) \ |
| 1536 SPARSE_SMM_BIN_OP_DECLS (R1, R2, M1, M2, API) \ | |
| 1537 SPARSE_SMM_CMP_OP_DECLS (M1, M2, API) \ | |
| 1538 SPARSE_SMM_BOOL_OP_DECLS (M1, M2, API) | |
| 5164 | 1539 |
| 1540 // Avoid some code duplication. Maybe we should use templates. | |
| 1541 | |
| 1542 #define SPARSE_CUMSUM(RET_TYPE, ELT_TYPE, FCN) \ | |
| 1543 \ | |
| 5275 | 1544 octave_idx_type nr = rows (); \ |
| 1545 octave_idx_type nc = cols (); \ | |
| 5164 | 1546 \ |
| 1547 RET_TYPE retval; \ | |
| 1548 \ | |
| 1549 if (nr > 0 && nc > 0) \ | |
| 1550 { \ | |
| 1551 if ((nr == 1 && dim == -1) || dim == 1) \ | |
| 1552 /* Ugly!! Is there a better way? */ \ | |
| 1553 retval = transpose (). FCN (0) .transpose (); \ | |
| 1554 else \ | |
| 1555 { \ | |
| 5275 | 1556 octave_idx_type nel = 0; \ |
| 1557 for (octave_idx_type i = 0; i < nc; i++) \ | |
| 5164 | 1558 { \ |
| 1559 ELT_TYPE t = ELT_TYPE (); \ | |
| 5275 | 1560 for (octave_idx_type j = cidx (i); j < cidx (i+1); j++) \ |
| 5164 | 1561 { \ |
| 1562 t += data(j); \ | |
| 1563 if (t != ELT_TYPE ()) \ | |
| 6482 | 1564 { \ |
| 1565 if (j == cidx(i+1) - 1) \ | |
| 1566 nel += nr - ridx(j); \ | |
| 1567 else \ | |
| 1568 nel += ridx(j+1) - ridx(j); \ | |
| 1569 } \ | |
| 5164 | 1570 } \ |
| 1571 } \ | |
| 1572 retval = RET_TYPE (nr, nc, nel); \ | |
| 1573 retval.cidx(0) = 0; \ | |
| 5275 | 1574 octave_idx_type ii = 0; \ |
| 1575 for (octave_idx_type i = 0; i < nc; i++) \ | |
| 5164 | 1576 { \ |
| 1577 ELT_TYPE t = ELT_TYPE (); \ | |
| 5275 | 1578 for (octave_idx_type j = cidx (i); j < cidx (i+1); j++) \ |
| 5164 | 1579 { \ |
| 1580 t += data(j); \ | |
| 1581 if (t != ELT_TYPE ()) \ | |
| 1582 { \ | |
| 1583 if (j == cidx(i+1) - 1) \ | |
| 1584 { \ | |
| 5275 | 1585 for (octave_idx_type k = ridx(j); k < nr; k++) \ |
| 5164 | 1586 { \ |
| 1587 retval.data (ii) = t; \ | |
| 1588 retval.ridx (ii++) = k; \ | |
| 1589 } \ | |
| 1590 } \ | |
| 1591 else \ | |
| 1592 { \ | |
| 5275 | 1593 for (octave_idx_type k = ridx(j); k < ridx(j+1); k++) \ |
| 5164 | 1594 { \ |
| 1595 retval.data (ii) = t; \ | |
| 1596 retval.ridx (ii++) = k; \ | |
| 1597 } \ | |
| 1598 } \ | |
| 1599 } \ | |
| 1600 } \ | |
| 1601 retval.cidx(i+1) = ii; \ | |
| 1602 } \ | |
| 1603 } \ | |
| 1604 } \ | |
| 1605 else \ | |
| 1606 retval = RET_TYPE (nr,nc); \ | |
| 1607 \ | |
| 1608 return retval | |
| 1609 | |
| 1610 | |
| 1611 #define SPARSE_CUMPROD(RET_TYPE, ELT_TYPE, FCN) \ | |
| 1612 \ | |
| 5275 | 1613 octave_idx_type nr = rows (); \ |
| 1614 octave_idx_type nc = cols (); \ | |
| 5164 | 1615 \ |
| 1616 RET_TYPE retval; \ | |
| 1617 \ | |
| 1618 if (nr > 0 && nc > 0) \ | |
| 1619 { \ | |
| 1620 if ((nr == 1 && dim == -1) || dim == 1) \ | |
| 1621 /* Ugly!! Is there a better way? */ \ | |
| 1622 retval = transpose (). FCN (0) .transpose (); \ | |
| 1623 else \ | |
| 1624 { \ | |
| 5275 | 1625 octave_idx_type nel = 0; \ |
| 1626 for (octave_idx_type i = 0; i < nc; i++) \ | |
| 5164 | 1627 { \ |
| 5275 | 1628 octave_idx_type jj = 0; \ |
| 1629 for (octave_idx_type j = cidx (i); j < cidx (i+1); j++) \ | |
| 5164 | 1630 { \ |
| 1631 if (jj == ridx(j)) \ | |
| 1632 { \ | |
| 1633 nel++; \ | |
| 1634 jj++; \ | |
| 1635 } \ | |
| 1636 else \ | |
| 1637 break; \ | |
| 1638 } \ | |
| 1639 } \ | |
| 1640 retval = RET_TYPE (nr, nc, nel); \ | |
| 1641 retval.cidx(0) = 0; \ | |
| 5275 | 1642 octave_idx_type ii = 0; \ |
| 1643 for (octave_idx_type i = 0; i < nc; i++) \ | |
| 5164 | 1644 { \ |
| 1645 ELT_TYPE t = ELT_TYPE (1.); \ | |
| 5275 | 1646 octave_idx_type jj = 0; \ |
| 1647 for (octave_idx_type j = cidx (i); j < cidx (i+1); j++) \ | |
| 5164 | 1648 { \ |
| 1649 if (jj == ridx(j)) \ | |
| 1650 { \ | |
| 1651 t *= data(j); \ | |
| 1652 retval.data(ii) = t; \ | |
| 1653 retval.ridx(ii++) = jj++; \ | |
| 1654 } \ | |
| 1655 else \ | |
| 1656 break; \ | |
| 1657 } \ | |
| 1658 retval.cidx(i+1) = ii; \ | |
| 1659 } \ | |
| 1660 } \ | |
| 1661 } \ | |
| 1662 else \ | |
| 1663 retval = RET_TYPE (nr,nc); \ | |
| 1664 \ | |
| 1665 return retval | |
| 1666 | |
| 1667 #define SPARSE_BASE_REDUCTION_OP(RET_TYPE, EL_TYPE, ROW_EXPR, COL_EXPR, \ | |
| 1668 INIT_VAL, MT_RESULT) \ | |
| 1669 \ | |
| 5275 | 1670 octave_idx_type nr = rows (); \ |
| 1671 octave_idx_type nc = cols (); \ | |
| 5164 | 1672 \ |
| 1673 RET_TYPE retval; \ | |
| 1674 \ | |
| 1675 if (nr > 0 && nc > 0) \ | |
| 1676 { \ | |
| 1677 if ((nr == 1 && dim == -1) || dim == 1) \ | |
| 1678 { \ | |
| 7269 | 1679 /* Define j here to allow fancy definition for prod method */ \ |
| 1680 octave_idx_type j = 0; \ | |
| 5164 | 1681 OCTAVE_LOCAL_BUFFER (EL_TYPE, tmp, nr); \ |
| 1682 \ | |
| 5275 | 1683 for (octave_idx_type i = 0; i < nr; i++) \ |
| 7269 | 1684 tmp[i] = INIT_VAL; \ |
| 1685 for (j = 0; j < nc; j++) \ | |
| 1686 { \ | |
| 1687 for (octave_idx_type i = cidx(j); i < cidx(j + 1); i++) \ | |
| 1688 { \ | |
| 1689 ROW_EXPR; \ | |
| 1690 } \ | |
| 5164 | 1691 } \ |
| 5275 | 1692 octave_idx_type nel = 0; \ |
| 1693 for (octave_idx_type i = 0; i < nr; i++) \ | |
| 5164 | 1694 if (tmp[i] != EL_TYPE ()) \ |
| 1695 nel++ ; \ | |
| 5275 | 1696 retval = RET_TYPE (nr, static_cast<octave_idx_type> (1), nel); \ |
| 5164 | 1697 retval.cidx(0) = 0; \ |
| 1698 retval.cidx(1) = nel; \ | |
| 1699 nel = 0; \ | |
| 5275 | 1700 for (octave_idx_type i = 0; i < nr; i++) \ |
| 5164 | 1701 if (tmp[i] != EL_TYPE ()) \ |
| 1702 { \ | |
| 1703 retval.data(nel) = tmp[i]; \ | |
| 1704 retval.ridx(nel++) = i; \ | |
| 1705 } \ | |
| 1706 } \ | |
| 1707 else \ | |
| 1708 { \ | |
| 1709 OCTAVE_LOCAL_BUFFER (EL_TYPE, tmp, nc); \ | |
| 1710 \ | |
| 5275 | 1711 for (octave_idx_type j = 0; j < nc; j++) \ |
| 5164 | 1712 { \ |
| 1713 tmp[j] = INIT_VAL; \ | |
| 7269 | 1714 for (octave_idx_type i = cidx(j); i < cidx(j + 1); i++) \ |
| 1715 { \ | |
| 5164 | 1716 COL_EXPR; \ |
| 7269 | 1717 } \ |
| 5164 | 1718 } \ |
| 5275 | 1719 octave_idx_type nel = 0; \ |
| 1720 for (octave_idx_type i = 0; i < nc; i++) \ | |
| 5164 | 1721 if (tmp[i] != EL_TYPE ()) \ |
| 1722 nel++ ; \ | |
| 5275 | 1723 retval = RET_TYPE (static_cast<octave_idx_type> (1), nc, nel); \ |
| 5164 | 1724 retval.cidx(0) = 0; \ |
| 1725 nel = 0; \ | |
| 5275 | 1726 for (octave_idx_type i = 0; i < nc; i++) \ |
| 5164 | 1727 if (tmp[i] != EL_TYPE ()) \ |
| 1728 { \ | |
| 1729 retval.data(nel) = tmp[i]; \ | |
| 1730 retval.ridx(nel++) = 0; \ | |
| 1731 retval.cidx(i+1) = retval.cidx(i) + 1; \ | |
| 1732 } \ | |
| 1733 else \ | |
| 1734 retval.cidx(i+1) = retval.cidx(i); \ | |
| 1735 } \ | |
| 1736 } \ | |
| 1737 else if (nc == 0 && (nr == 0 || (nr == 1 && dim == -1))) \ | |
| 1738 { \ | |
| 7197 | 1739 if (MT_RESULT) \ |
| 1740 { \ | |
| 1741 retval = RET_TYPE (static_cast<octave_idx_type> (1), \ | |
| 1742 static_cast<octave_idx_type> (1), \ | |
| 1743 static_cast<octave_idx_type> (1)); \ | |
| 1744 retval.cidx(0) = 0; \ | |
| 1745 retval.cidx(1) = 1; \ | |
| 1746 retval.ridx(0) = 0; \ | |
| 1747 retval.data(0) = MT_RESULT; \ | |
| 1748 } \ | |
| 1749 else \ | |
| 1750 retval = RET_TYPE (static_cast<octave_idx_type> (1), \ | |
| 1751 static_cast<octave_idx_type> (1), \ | |
| 1752 static_cast<octave_idx_type> (0)); \ | |
| 5164 | 1753 } \ |
| 1754 else if (nr == 0 && (dim == 0 || dim == -1)) \ | |
| 1755 { \ | |
| 7197 | 1756 if (MT_RESULT) \ |
| 5164 | 1757 { \ |
| 7197 | 1758 retval = RET_TYPE (static_cast<octave_idx_type> (1), nc, nc); \ |
| 1759 retval.cidx (0) = 0; \ | |
| 1760 for (octave_idx_type i = 0; i < nc ; i++) \ | |
| 1761 { \ | |
| 1762 retval.ridx (i) = 0; \ | |
| 1763 retval.cidx (i+1) = i; \ | |
| 1764 retval.data (i) = MT_RESULT; \ | |
| 1765 } \ | |
| 1766 } \ | |
| 1767 else \ | |
| 1768 retval = RET_TYPE (static_cast<octave_idx_type> (1), nc, \ | |
| 1769 static_cast<octave_idx_type> (0)); \ | |
| 5164 | 1770 } \ |
| 1771 else if (nc == 0 && dim == 1) \ | |
| 1772 { \ | |
| 7197 | 1773 if (MT_RESULT) \ |
| 1774 { \ | |
| 1775 retval = RET_TYPE (nr, static_cast<octave_idx_type> (1), nr); \ | |
| 1776 retval.cidx(0) = 0; \ | |
| 1777 retval.cidx(1) = nr; \ | |
| 1778 for (octave_idx_type i = 0; i < nr; i++) \ | |
| 1779 { \ | |
| 1780 retval.ridx(i) = i; \ | |
| 1781 retval.data(i) = MT_RESULT; \ | |
| 1782 } \ | |
| 1783 } \ | |
| 1784 else \ | |
| 1785 retval = RET_TYPE (nr, static_cast<octave_idx_type> (1), \ | |
| 1786 static_cast<octave_idx_type> (0)); \ | |
| 5164 | 1787 } \ |
| 1788 else \ | |
| 1789 retval.resize (nr > 0, nc > 0); \ | |
| 1790 \ | |
| 1791 return retval | |
| 1792 | |
| 1793 #define SPARSE_REDUCTION_OP_ROW_EXPR(OP) \ | |
| 7269 | 1794 tmp[ridx(i)] OP data (i) |
| 5164 | 1795 |
| 1796 #define SPARSE_REDUCTION_OP_COL_EXPR(OP) \ | |
| 7269 | 1797 tmp[j] OP data (i) |
| 5164 | 1798 |
| 1799 #define SPARSE_REDUCTION_OP(RET_TYPE, EL_TYPE, OP, INIT_VAL, MT_RESULT) \ | |
| 1800 SPARSE_BASE_REDUCTION_OP (RET_TYPE, EL_TYPE, \ | |
| 1801 SPARSE_REDUCTION_OP_ROW_EXPR (OP), \ | |
| 1802 SPARSE_REDUCTION_OP_COL_EXPR (OP), \ | |
| 1803 INIT_VAL, MT_RESULT) | |
| 1804 | |
| 7350 | 1805 |
| 1806 // Don't break from this loop if the test succeeds because | |
| 1807 // we are looping over the rows and not the columns in the inner | |
| 1808 // loop. | |
| 5164 | 1809 #define SPARSE_ANY_ALL_OP_ROW_CODE(TEST_OP, TEST_TRUE_VAL) \ |
| 7269 | 1810 if (data (i) TEST_OP 0.0) \ |
| 7350 | 1811 tmp[ridx(i)] = TEST_TRUE_VAL; \ |
| 5164 | 1812 |
| 1813 #define SPARSE_ANY_ALL_OP_COL_CODE(TEST_OP, TEST_TRUE_VAL) \ | |
| 7269 | 1814 if (data (i) TEST_OP 0.0) \ |
| 5164 | 1815 { \ |
| 1816 tmp[j] = TEST_TRUE_VAL; \ | |
| 1817 break; \ | |
| 1818 } | |
| 1819 | |
| 7269 | 1820 #define SPARSE_ANY_ALL_OP(DIM, INIT_VAL, MT_RESULT, TEST_OP, TEST_TRUE_VAL) \ |
| 5164 | 1821 SPARSE_BASE_REDUCTION_OP (SparseBoolMatrix, char, \ |
| 1822 SPARSE_ANY_ALL_OP_ROW_CODE (TEST_OP, TEST_TRUE_VAL), \ | |
| 1823 SPARSE_ANY_ALL_OP_COL_CODE (TEST_OP, TEST_TRUE_VAL), \ | |
| 7269 | 1824 INIT_VAL, MT_RESULT) |
| 5164 | 1825 |
| 7269 | 1826 #define SPARSE_ALL_OP(DIM) \ |
| 1827 if ((rows() == 1 && dim == -1) || dim == 1) \ | |
| 1828 return transpose (). all (0). transpose(); \ | |
| 1829 else \ | |
| 1830 { \ | |
|
9417
5d46c4a894e8
fix bugs in sparse reductions
Jaroslav Hajek <highegg@gmail.com>
parents:
8377
diff
changeset
|
1831 SPARSE_ANY_ALL_OP (DIM, (cidx(j+1) - cidx(j) < nr ? false : true), \ |
| 7269 | 1832 true, ==, false); \ |
| 1833 } | |
| 5164 | 1834 |
| 7269 | 1835 #define SPARSE_ANY_OP(DIM) SPARSE_ANY_ALL_OP (DIM, false, false, !=, true) |
| 5164 | 1836 |
| 5681 | 1837 #define SPARSE_SPARSE_MUL( RET_TYPE, RET_EL_TYPE, EL_TYPE ) \ |
| 5275 | 1838 octave_idx_type nr = m.rows (); \ |
| 1839 octave_idx_type nc = m.cols (); \ | |
| 5164 | 1840 \ |
| 5275 | 1841 octave_idx_type a_nr = a.rows (); \ |
| 1842 octave_idx_type a_nc = a.cols (); \ | |
| 5164 | 1843 \ |
| 6221 | 1844 if (nr == 1 && nc == 1) \ |
| 1845 { \ | |
| 1846 RET_EL_TYPE s = m.elem(0,0); \ | |
| 1847 octave_idx_type nz = a.nnz(); \ | |
| 1848 RET_TYPE r (a_nr, a_nc, nz); \ | |
| 1849 \ | |
| 1850 for (octave_idx_type i = 0; i < nz; i++) \ | |
| 1851 { \ | |
| 1852 OCTAVE_QUIT; \ | |
| 1853 r.data(i) = s * a.data(i); \ | |
| 1854 r.ridx(i) = a.ridx(i); \ | |
| 1855 } \ | |
| 1856 for (octave_idx_type i = 0; i < a_nc + 1; i++) \ | |
| 1857 { \ | |
| 1858 OCTAVE_QUIT; \ | |
| 1859 r.cidx(i) = a.cidx(i); \ | |
| 1860 } \ | |
| 1861 \ | |
| 1862 r.maybe_compress (true); \ | |
| 1863 return r; \ | |
| 1864 } \ | |
| 1865 else if (a_nr == 1 && a_nc == 1) \ | |
| 1866 { \ | |
| 1867 RET_EL_TYPE s = a.elem(0,0); \ | |
| 1868 octave_idx_type nz = m.nnz(); \ | |
| 1869 RET_TYPE r (nr, nc, nz); \ | |
| 1870 \ | |
| 1871 for (octave_idx_type i = 0; i < nz; i++) \ | |
| 1872 { \ | |
| 1873 OCTAVE_QUIT; \ | |
| 1874 r.data(i) = m.data(i) * s; \ | |
| 1875 r.ridx(i) = m.ridx(i); \ | |
| 1876 } \ | |
| 1877 for (octave_idx_type i = 0; i < nc + 1; i++) \ | |
| 1878 { \ | |
| 1879 OCTAVE_QUIT; \ | |
| 1880 r.cidx(i) = m.cidx(i); \ | |
| 1881 } \ | |
| 1882 \ | |
| 1883 r.maybe_compress (true); \ | |
| 1884 return r; \ | |
| 1885 } \ | |
| 1886 else if (nc != a_nr) \ | |
| 5164 | 1887 { \ |
| 1888 gripe_nonconformant ("operator *", nr, nc, a_nr, a_nc); \ | |
| 1889 return RET_TYPE (); \ | |
| 1890 } \ | |
| 1891 else \ | |
| 1892 { \ | |
| 5586 | 1893 OCTAVE_LOCAL_BUFFER (octave_idx_type, w, nr); \ |
| 5876 | 1894 RET_TYPE retval (nr, a_nc, static_cast<octave_idx_type> (0)); \ |
| 5586 | 1895 for (octave_idx_type i = 0; i < nr; i++) \ |
| 1896 w[i] = 0; \ | |
| 5795 | 1897 retval.xcidx(0) = 0; \ |
| 5164 | 1898 \ |
| 5275 | 1899 octave_idx_type nel = 0; \ |
| 5164 | 1900 \ |
| 5275 | 1901 for (octave_idx_type i = 0; i < a_nc; i++) \ |
| 5164 | 1902 { \ |
| 5275 | 1903 for (octave_idx_type j = a.cidx(i); j < a.cidx(i+1); j++) \ |
| 5164 | 1904 { \ |
| 5275 | 1905 octave_idx_type col = a.ridx(j); \ |
| 1906 for (octave_idx_type k = m.cidx(col) ; k < m.cidx(col+1); k++) \ | |
| 5586 | 1907 { \ |
| 1908 if (w[m.ridx(k)] < i + 1) \ | |
| 1909 { \ | |
| 1910 w[m.ridx(k)] = i + 1; \ | |
| 1911 nel++; \ | |
| 1912 } \ | |
| 5587 | 1913 OCTAVE_QUIT; \ |
| 5586 | 1914 } \ |
| 5164 | 1915 } \ |
| 5795 | 1916 retval.xcidx(i+1) = nel; \ |
| 5164 | 1917 } \ |
| 1918 \ | |
| 1919 if (nel == 0) \ | |
| 1920 return RET_TYPE (nr, a_nc); \ | |
| 1921 else \ | |
| 1922 { \ | |
| 5586 | 1923 for (octave_idx_type i = 0; i < nr; i++) \ |
| 1924 w[i] = 0; \ | |
| 1925 \ | |
| 5681 | 1926 OCTAVE_LOCAL_BUFFER (RET_EL_TYPE, Xcol, nr); \ |
| 5586 | 1927 \ |
| 5795 | 1928 retval.change_capacity (nel); \ |
| 5587 | 1929 /* The optimal break-point as estimated from simulations */ \ |
| 1930 /* Note that Mergesort is O(nz log(nz)) while searching all */ \ | |
| 1931 /* values is O(nr), where nz here is non-zero per row of */ \ | |
| 1932 /* length nr. The test itself was then derived from the */ \ | |
| 1933 /* simulation with random square matrices and the observation */ \ | |
| 1934 /* of the number of non-zero elements in the output matrix */ \ | |
| 1935 /* it was found that the breakpoints were */ \ | |
| 1936 /* nr: 500 1000 2000 5000 10000 */ \ | |
| 1937 /* nz: 6 25 97 585 2202 */ \ | |
| 1938 /* The below is a simplication of the 'polyfit'-ed parameters */ \ | |
| 1939 /* to these breakpoints */ \ | |
| 5795 | 1940 octave_idx_type n_per_col = (a_nc > 43000 ? 43000 : \ |
| 1941 (a_nc * a_nc) / 43000); \ | |
| 1942 octave_idx_type ii = 0; \ | |
| 1943 octave_idx_type *ri = retval.xridx(); \ | |
| 1944 octave_sort<octave_idx_type> sort; \ | |
| 1945 \ | |
| 1946 for (octave_idx_type i = 0; i < a_nc ; i++) \ | |
| 5164 | 1947 { \ |
| 5795 | 1948 if (retval.xcidx(i+1) - retval.xcidx(i) > n_per_col) \ |
| 5587 | 1949 { \ |
| 1950 for (octave_idx_type j = a.cidx(i); j < a.cidx(i+1); j++) \ | |
| 1951 { \ | |
| 1952 octave_idx_type col = a.ridx(j); \ | |
| 1953 EL_TYPE tmpval = a.data(j); \ | |
| 1954 for (octave_idx_type k = m.cidx(col) ; \ | |
| 1955 k < m.cidx(col+1); k++) \ | |
| 1956 { \ | |
| 1957 OCTAVE_QUIT; \ | |
| 1958 octave_idx_type row = m.ridx(k); \ | |
| 1959 if (w[row] < i + 1) \ | |
| 1960 { \ | |
| 1961 w[row] = i + 1; \ | |
| 1962 Xcol[row] = tmpval * m.data(k); \ | |
| 1963 } \ | |
| 1964 else \ | |
| 1965 Xcol[row] += tmpval * m.data(k); \ | |
| 1966 } \ | |
| 1967 } \ | |
| 1968 for (octave_idx_type k = 0; k < nr; k++) \ | |
| 5813 | 1969 if (w[k] == i + 1) \ |
| 5587 | 1970 { \ |
| 1971 retval.xdata(ii) = Xcol[k]; \ | |
| 1972 retval.xridx(ii++) = k; \ | |
| 1973 } \ | |
| 5795 | 1974 } \ |
| 1975 else \ | |
| 1976 { \ | |
| 1977 for (octave_idx_type j = a.cidx(i); j < a.cidx(i+1); j++) \ | |
| 1978 { \ | |
| 1979 octave_idx_type col = a.ridx(j); \ | |
| 1980 EL_TYPE tmpval = a.data(j); \ | |
| 1981 for (octave_idx_type k = m.cidx(col) ; \ | |
| 1982 k < m.cidx(col+1); k++) \ | |
| 1983 { \ | |
| 1984 OCTAVE_QUIT; \ | |
| 1985 octave_idx_type row = m.ridx(k); \ | |
| 1986 if (w[row] < i + 1) \ | |
| 1987 { \ | |
| 1988 w[row] = i + 1; \ | |
| 1989 retval.xridx(ii++) = row;\ | |
| 1990 Xcol[row] = tmpval * m.data(k); \ | |
| 1991 } \ | |
| 1992 else \ | |
| 1993 Xcol[row] += tmpval * m.data(k); \ | |
| 1994 } \ | |
| 1995 } \ | |
| 1996 sort.sort (ri + retval.xcidx(i), ii - retval.xcidx(i)); \ | |
| 1997 for (octave_idx_type k = retval.xcidx(i); k < ii; k++) \ | |
| 1998 retval.xdata(k) = Xcol[retval.xridx(k)]; \ | |
| 5587 | 1999 } \ |
| 5164 | 2000 } \ |
| 5813 | 2001 retval.maybe_compress (true);\ |
| 5164 | 2002 return retval; \ |
| 2003 } \ | |
| 2004 } | |
| 2005 | |
| 5681 | 2006 #define SPARSE_FULL_MUL( RET_TYPE, EL_TYPE, ZERO ) \ |
| 5429 | 2007 octave_idx_type nr = m.rows (); \ |
| 2008 octave_idx_type nc = m.cols (); \ | |
| 2009 \ | |
| 2010 octave_idx_type a_nr = a.rows (); \ | |
| 2011 octave_idx_type a_nc = a.cols (); \ | |
| 2012 \ | |
| 6221 | 2013 if (nr == 1 && nc == 1) \ |
| 2014 { \ | |
|
7802
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2015 RET_TYPE retval = m.elem (0,0) * a; \ |
| 6221 | 2016 return retval; \ |
| 2017 } \ | |
| 2018 else if (nc != a_nr) \ | |
| 5429 | 2019 { \ |
| 2020 gripe_nonconformant ("operator *", nr, nc, a_nr, a_nc); \ | |
| 2021 return RET_TYPE (); \ | |
| 2022 } \ | |
| 2023 else \ | |
| 2024 { \ | |
| 5681 | 2025 RET_TYPE retval (nr, a_nc, ZERO); \ |
| 5429 | 2026 \ |
| 2027 for (octave_idx_type i = 0; i < a_nc ; i++) \ | |
|
7802
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2028 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2029 for (octave_idx_type j = 0; j < a_nr; j++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2030 { \ |
| 5429 | 2031 OCTAVE_QUIT; \ |
|
7802
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2032 \ |
| 5429 | 2033 EL_TYPE tmpval = a.elem(j,i); \ |
|
7802
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2034 for (octave_idx_type k = m.cidx(j) ; k < m.cidx(j+1); k++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2035 retval.elem (m.ridx(k),i) += tmpval * m.data(k); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2036 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2037 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2038 return retval; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2039 } |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2040 |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2041 #define SPARSE_FULL_TRANS_MUL( RET_TYPE, EL_TYPE, ZERO, CONJ_OP ) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2042 octave_idx_type nr = m.rows (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2043 octave_idx_type nc = m.cols (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2044 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2045 octave_idx_type a_nr = a.rows (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2046 octave_idx_type a_nc = a.cols (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2047 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2048 if (nr == 1 && nc == 1) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2049 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2050 RET_TYPE retval = CONJ_OP (m.elem(0,0)) * a; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2051 return retval; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2052 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2053 else if (nr != a_nr) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2054 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2055 gripe_nonconformant ("operator *", nc, nr, a_nr, a_nc); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2056 return RET_TYPE (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2057 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2058 else \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2059 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2060 RET_TYPE retval (nc, a_nc); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2061 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2062 for (octave_idx_type i = 0; i < a_nc ; i++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2063 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2064 for (octave_idx_type j = 0; j < nc; j++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2065 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2066 OCTAVE_QUIT; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2067 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2068 EL_TYPE acc = ZERO; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2069 for (octave_idx_type k = m.cidx(j) ; k < m.cidx(j+1); k++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2070 acc += a.elem (m.ridx(k),i) * CONJ_OP (m.data(k)); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2071 retval.xelem (j,i) = acc; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2072 } \ |
| 5429 | 2073 } \ |
| 2074 return retval; \ | |
| 2075 } | |
| 2076 | |
| 5681 | 2077 #define FULL_SPARSE_MUL( RET_TYPE, EL_TYPE, ZERO ) \ |
| 5429 | 2078 octave_idx_type nr = m.rows (); \ |
| 2079 octave_idx_type nc = m.cols (); \ | |
| 2080 \ | |
| 2081 octave_idx_type a_nr = a.rows (); \ | |
| 2082 octave_idx_type a_nc = a.cols (); \ | |
| 2083 \ | |
| 6221 | 2084 if (a_nr == 1 && a_nc == 1) \ |
| 2085 { \ | |
|
7802
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2086 RET_TYPE retval = m * a.elem (0,0); \ |
| 6221 | 2087 return retval; \ |
| 2088 } \ | |
| 2089 else if (nc != a_nr) \ | |
| 5429 | 2090 { \ |
| 2091 gripe_nonconformant ("operator *", nr, nc, a_nr, a_nc); \ | |
| 2092 return RET_TYPE (); \ | |
| 2093 } \ | |
| 2094 else \ | |
| 2095 { \ | |
| 5681 | 2096 RET_TYPE retval (nr, a_nc, ZERO); \ |
| 5429 | 2097 \ |
| 2098 for (octave_idx_type i = 0; i < a_nc ; i++) \ | |
|
7802
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2099 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2100 OCTAVE_QUIT; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2101 for (octave_idx_type j = a.cidx(i); j < a.cidx(i+1); j++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2102 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2103 octave_idx_type col = a.ridx(j); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2104 EL_TYPE tmpval = a.data(j); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2105 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2106 for (octave_idx_type k = 0 ; k < nr; k++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2107 retval.xelem (k,i) += tmpval * m.elem(k,col); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2108 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2109 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2110 return retval; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2111 } |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2112 |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2113 #define FULL_SPARSE_MUL_TRANS( RET_TYPE, EL_TYPE, ZERO, CONJ_OP ) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2114 octave_idx_type nr = m.rows (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2115 octave_idx_type nc = m.cols (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2116 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2117 octave_idx_type a_nr = a.rows (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2118 octave_idx_type a_nc = a.cols (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2119 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2120 if (a_nr == 1 && a_nc == 1) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2121 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2122 RET_TYPE retval = m * CONJ_OP (a.elem(0,0)); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2123 return retval; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2124 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2125 else if (nc != a_nc) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2126 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2127 gripe_nonconformant ("operator *", nr, nc, a_nc, a_nr); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2128 return RET_TYPE (); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2129 } \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2130 else \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2131 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2132 RET_TYPE retval (nr, a_nr, ZERO); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2133 \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2134 for (octave_idx_type i = 0; i < a_nc ; i++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2135 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2136 OCTAVE_QUIT; \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2137 for (octave_idx_type j = a.cidx(i); j < a.cidx(i+1); j++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2138 { \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2139 octave_idx_type col = a.ridx(j); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2140 EL_TYPE tmpval = CONJ_OP (a.data(j)); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2141 for (octave_idx_type k = 0 ; k < nr; k++) \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2142 retval.xelem (k,col) += tmpval * m.elem(k,i); \ |
|
1a446f28ce68
implement optimized sparse-dense transposed multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7350
diff
changeset
|
2143 } \ |
| 5429 | 2144 } \ |
| 2145 return retval; \ | |
| 2146 } | |
| 2147 | |
| 5164 | 2148 #endif |
| 2149 | |
| 2150 /* | |
| 2151 ;;; Local Variables: *** | |
| 2152 ;;; mode: C++ *** | |
| 2153 ;;; End: *** | |
| 2154 */ |