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