octave-nkf: liboctave/operators/Sparse-op-defs.h annotate

annotate liboctave/operators/Sparse-op-defs.h @ 20750:3339c9bdfe6a

Activate FSAL property in dorpri timestepper * scripts/ode/private/runge_kutta_45_dorpri.m: don't compute first stage if values from previous iteration are passed. * scripts/ode/private/integrate_adaptive.m: do not update cmputed stages if timestep is rejected.

author	Carlo de Falco <carlo.defalco@polimi.it>
date	Sat, 03 Oct 2015 07:32:50 +0200
parents	19755f4fc851
children

rev	line source
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1 /*
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	2
19898 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19461 diff changeset	3 Copyright (C) 2004-2015 David Bateman
11523 fd0a3ac60b0e update copyright notices John W. Eaton <jwe@octave.org> parents: 10900 diff changeset	4 Copyright (C) 1998-2004 Andy Adler
7803 9bcb31cc56be add missing copyright Jaroslav Hajek <highegg@gmail.com> parents: 7802 diff changeset	5 Copyright (C) 2008 Jaroslav Hajek
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6708 diff changeset	6
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6708 diff changeset	7 This file is part of Octave.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	8
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	9 Octave is free software; you can redistribute it and/or modify it
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	10 under the terms of the GNU General Public License as published by the
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6708 diff changeset	11 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6708 diff changeset	12 option) any later version.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	13
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	14 Octave is distributed in the hope that it will be useful, but WITHOUT
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	17 for more details.
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	18
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	19 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6708 diff changeset	20 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6708 diff changeset	21 <http://www.gnu.org/licenses/>.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	22
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	23 */
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	24
17822 ebb3ef964372 maint: Use common #define syntax "octave_filename_h" in h_files. Rik <rik@octave.org> parents: 17769 diff changeset	25 #if !defined (octave_Sparse_op_defs_h)
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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	27
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	31
19461 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19007 diff changeset	32 // sparse matrix by scalar operations.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	35 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	36 F (const M& m, const S& s) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	37 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	38 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	39 octave_idx_type nc = m.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	40 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	41 R r (nr, nc, (0.0 OP s)); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	42 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	43 for (octave_idx_type j = 0; j < nc; j++) \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	46 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	47 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	50 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	51 F (const M& m, const S& s) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	52 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	53 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	54 octave_idx_type nc = m.cols (); \
5681 233d98d95659 [project @ 2006-03-16 17:48:55 by dbateman] dbateman parents: 5604 diff changeset	55 octave_idx_type nz = m.nnz (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	56 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	57 R r (nr, nc, nz); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	58 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	59 for (octave_idx_type i = 0; i < nz; i++) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	63 } \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	66 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	67 r.maybe_compress (true); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	68 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	69 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	70
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	71 #define SPARSE_SMS_BIN_OPS(R1, R2, M, S) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	72 SPARSE_SMS_BIN_OP_1 (R1, operator +, +, M, S) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	73 SPARSE_SMS_BIN_OP_1 (R1, operator -, -, M, S) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	74 SPARSE_SMS_BIN_OP_2 (R2, operator , , M, S) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	75 SPARSE_SMS_BIN_OP_2 (R2, operator /, /, M, S)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	78 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	79 F (const M& m, const S& s) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	80 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	81 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	82 octave_idx_type nc = m.cols (); \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	83 SparseBoolMatrix r; \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	84 \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	85 if (MC (MZ) OP SC (s)) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	86 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	90 if (! (MC (m.data (i)) OP SC (s))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	91 r.data (m.ridx (i) + j * nr) = false; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	92 r.maybe_compress (true); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	93 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	94 else \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	95 { \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	96 r = SparseBoolMatrix (nr, nc, m.nnz ()); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	97 r.cidx (0) = static_cast<octave_idx_type> (0); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	102 if (MC (m.data (i)) OP SC (s)) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	103 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	104 r.ridx (nel) = m.ridx (i); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	105 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	106 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	107 r.cidx (j + 1) = nel; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	108 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	109 r.maybe_compress (false); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	110 } \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	111 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	112 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	120 SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, MZ, , S, SZ, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	124 SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, MZ, , S, SZ, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	125
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	126 #define SPARSE_SMS_BOOL_OP(F, OP, M, S, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	127 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	128 F (const M& m, const S& s) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	129 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	130 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	131 octave_idx_type nc = m.cols (); \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	132 SparseBoolMatrix r; \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	133 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	134 if (nr > 0 && nc > 0) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	142 r.data (m.ridx (i) + j * nr) = false; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	143 r.maybe_compress (true); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	147 r = SparseBoolMatrix (nr, nc, m.nnz ()); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	148 r.cidx (0) = static_cast<octave_idx_type> (0); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	154 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	155 r.ridx (nel) = m.ridx (i); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	156 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	157 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	158 r.cidx (j + 1) = nel; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	159 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	160 r.maybe_compress (false); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	161 } \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	162 } \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	163 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	164 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	165
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	166 #define SPARSE_SMS_BOOL_OPS2(M, S, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	167 SPARSE_SMS_BOOL_OP (mx_el_and, &&, M, S, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	168 SPARSE_SMS_BOOL_OP (mx_el_or, \|\|, M, S, LHS_ZERO, RHS_ZERO)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	169
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	170 #define SPARSE_SMS_BOOL_OPS(M, S, ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	171 SPARSE_SMS_BOOL_OPS2(M, S, ZERO, ZERO)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	172
19461 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19007 diff changeset	173 // scalar by sparse matrix operations.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	174
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	175 #define SPARSE_SSM_BIN_OP_1(R, F, OP, S, M) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	176 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	177 F (const S& s, const M& m) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	178 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	179 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	180 octave_idx_type nc = m.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	181 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	182 R r (nr, nc, (s OP 0.0)); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	183 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	184 for (octave_idx_type j = 0; j < nc; j++) \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	187 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	188 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	189 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	190
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	191 #define SPARSE_SSM_BIN_OP_2(R, F, OP, S, M) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	192 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	193 F (const S& s, const M& m) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	194 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	195 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	196 octave_idx_type nc = m.cols (); \
5681 233d98d95659 [project @ 2006-03-16 17:48:55 by dbateman] dbateman parents: 5604 diff changeset	197 octave_idx_type nz = m.nnz (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	198 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	199 R r (nr, nc, nz); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	200 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	201 for (octave_idx_type i = 0; i < nz; i++) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	205 } \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	208 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	209 r.maybe_compress(true); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	210 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	211 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	212
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	213 #define SPARSE_SSM_BIN_OPS(R1, R2, S, M) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	214 SPARSE_SSM_BIN_OP_1 (R1, operator +, +, S, M) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	215 SPARSE_SSM_BIN_OP_1 (R1, operator -, -, S, M) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	216 SPARSE_SSM_BIN_OP_2 (R2, operator , , S, M) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	217 SPARSE_SSM_BIN_OP_2 (R2, operator /, /, S, M)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	220 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	221 F (const S& s, const M& m) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	222 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	223 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	224 octave_idx_type nc = m.cols (); \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	225 SparseBoolMatrix r; \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	226 \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	227 if (SC (s) OP SC (MZ)) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	228 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	232 if (! (SC (s) OP MC (m.data (i)))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	233 r.data (m.ridx (i) + j * nr) = false; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	234 r.maybe_compress (true); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	235 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	236 else \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	237 { \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	238 r = SparseBoolMatrix (nr, nc, m.nnz ()); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	239 r.cidx (0) = static_cast<octave_idx_type> (0); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	244 if (SC (s) OP MC (m.data (i))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	245 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	246 r.ridx (nel) = m.ridx (i); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	247 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	248 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	249 r.cidx (j + 1) = nel; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	250 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	251 r.maybe_compress (false); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	252 } \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	253 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	254 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	262 SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, SZ, , M, MZ, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	266 SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, SZ, , M, MZ, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	267
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	268 #define SPARSE_SSM_BOOL_OP(F, OP, S, M, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	269 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	270 F (const S& s, const M& m) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	271 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	272 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	273 octave_idx_type nc = m.cols (); \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	274 SparseBoolMatrix r; \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	275 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	276 if (nr > 0 && nc > 0) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	284 r.data (m.ridx (i) + j * nr) = false; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	285 r.maybe_compress (true); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	289 r = SparseBoolMatrix (nr, nc, m.nnz ()); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	290 r.cidx (0) = static_cast<octave_idx_type> (0); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	296 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	297 r.ridx (nel) = m.ridx (i); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	298 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	299 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	300 r.cidx (j + 1) = nel; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	301 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	302 r.maybe_compress (false); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	303 } \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	304 } \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	305 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	306 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	307
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	308 #define SPARSE_SSM_BOOL_OPS2(S, M, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	309 SPARSE_SSM_BOOL_OP (mx_el_and, &&, S, M, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	310 SPARSE_SSM_BOOL_OP (mx_el_or, \|\|, S, M, LHS_ZERO, RHS_ZERO)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	311
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	312 #define SPARSE_SSM_BOOL_OPS(S, M, ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	313 SPARSE_SSM_BOOL_OPS2(S, M, ZERO, ZERO)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	314
19461 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19007 diff changeset	315 // sparse matrix by sparse matrix operations.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	318 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	319 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	320 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	321 R r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	322 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	323 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	324 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	325 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	326 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	327 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	328 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	329 if (m1_nr == 1 && m1_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 9c7073003700 [project @ 2008-01-03 23:05:19 by jwe] jwe parents: 7318 diff changeset	332 r = OP R (m2); \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	333 else \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	336 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	337 for (octave_idx_type j = 0 ; j < m2_nc ; j++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	338 { \
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	339 octave_quit (); \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	346 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	347 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	348 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	349 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	350 else if (m2_nr == 1 && m2_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	353 r = R (m1); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	354 else \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	357 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	358 for (octave_idx_type j = 0 ; j < m1_nc ; j++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	359 { \
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	360 octave_quit (); \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	367 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	368 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	369 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	370 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	371 else if (m1_nr != m2_nr \|\| m1_nc != m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	372 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	373 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	376 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	377 octave_idx_type jx = 0; \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	378 r.cidx (0) = 0; \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	379 for (octave_idx_type i = 0 ; i < m1_nc ; i++) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	383 bool ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	387 bool jb_lt_max = jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	388 \
18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	390 { \
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	391 octave_quit (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	397 jx++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	398 ja++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	399 ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	400 } \
18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	407 jb++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	408 jb_lt_max= jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	409 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	410 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	416 jx++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	417 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	418 ja++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	419 ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	420 jb++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	421 jb_lt_max= jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	422 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	425 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	426 \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	427 r.maybe_compress (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	428 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	429 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	430 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	431 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	434 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	435 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	436 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	437 R r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	438 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	439 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	440 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	441 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	442 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	443 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	444 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	445 if (m1_nr == 1 && m1_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	448 r = R (m2_nr, m2_nc); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	449 else \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	453 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	454 for (octave_idx_type i = 0 ; i < m2_nnz ; i++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	458 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	459 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	460 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	461 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	462 else if (m2_nr == 1 && m2_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	465 r = R (m1_nr, m1_nc); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	466 else \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	470 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	471 for (octave_idx_type i = 0 ; i < m1_nnz ; i++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	475 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	476 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	477 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	478 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	479 else if (m1_nr != m2_nr \|\| m1_nc != m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	480 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	481 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	482 { \
5681 233d98d95659 [project @ 2006-03-16 17:48:55 by dbateman] dbateman parents: 5604 diff changeset	483 r = R (m1_nr, m1_nc, (m1.nnz () > m2.nnz () ? m1.nnz () : m2.nnz ())); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	484 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	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 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	487 for (octave_idx_type i = 0 ; i < m1_nc ; i++) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	491 bool ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	495 bool jb_lt_max = jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	496 \
18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	498 { \
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	499 octave_quit (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	502 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	503 ja++; ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	504 } \
18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	507 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	508 jb++; jb_lt_max= jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	509 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	510 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	516 jx++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	517 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	518 ja++; ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	519 jb++; jb_lt_max= jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	520 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	523 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	524 \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	525 r.maybe_compress (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	526 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	527 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	528 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	529 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	532 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	533 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	534 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	535 R r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	536 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	537 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	538 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	539 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	540 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	541 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	542 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	543 if (m1_nr == 1 && m1_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	548 r = R (m2); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	551 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	552 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	553 else \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	556 for (octave_idx_type j = 0 ; j < m2_nc ; j++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	557 { \
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	558 octave_quit (); \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	565 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	566 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	567 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	568 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	569 else if (m2_nr == 1 && m2_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	574 r = R (m1); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	577 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	578 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	579 else \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	582 for (octave_idx_type j = 0 ; j < m1_nc ; j++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	583 { \
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	584 octave_quit (); \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	591 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	592 r.maybe_compress (); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	593 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	594 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	595 else if (m1_nr != m2_nr \|\| m1_nc != m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	596 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	597 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	598 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	601 r = R (m1_nr, m1_nc, (Complex () OP Complex ())); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	602 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	603 for (octave_idx_type i = 0 ; i < m1_nc ; i++) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	607 bool ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	611 bool jb_lt_max = jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	612 \
18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	614 { \
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	615 octave_quit (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	621 ja++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	622 ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	623 } \
18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	629 jb++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	630 jb_lt_max= jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	631 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	632 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	635 ja++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	636 ja_lt_max= ja < ja_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	637 jb++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	638 jb_lt_max= jb < jb_max; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	639 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	640 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	641 } \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	642 r.maybe_compress (true); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	643 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	644 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	645 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	646 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	647
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	648 // Note that SM ./ SM needs to take into account the NaN and Inf values
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	651 #define SPARSE_SMSM_BIN_OPS(R1, R2, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	652 SPARSE_SMSM_BIN_OP_1 (R1, operator +, +, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	653 SPARSE_SMSM_BIN_OP_1 (R1, operator -, -, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	654 SPARSE_SMSM_BIN_OP_2 (R2, product, *, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	655 SPARSE_SMSM_BIN_OP_3 (R2, quotient, /, M1, M2)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 5ac184c05811 additional AIX build fix John W. Eaton <jwe@octave.org> parents: 8187 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	661 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	662 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	663 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	664 SparseBoolMatrix r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	665 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	666 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	667 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	668 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	669 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	670 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	671 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	672 if (m1_nr == 1 && m1_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	700 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	701 else if (m2_nr == 1 && m2_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	729 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	730 else if (m1_nr == m2_nr && m1_nc == m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	738 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	739 octave_idx_type i1 = m1.cidx (j); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	740 octave_idx_type e1 = m1.cidx (j+1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	741 octave_idx_type i2 = m2.cidx (j); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	742 octave_idx_type e2 = m2.cidx (j+1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	743 while (i1 < e1 \|\| i2 < e2) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	746 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	747 if (! (C1 (Z1) OP C2 (m2.data (i2)))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	748 r.data (m2.ridx (i2) + j * m1_nr) = false; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	749 i2++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	752 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	753 if (! (C1 (m1.data (i1)) OP C2 (Z2))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	754 r.data (m1.ridx (i1) + j * m1_nr) = false; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	755 i1++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	756 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	757 else \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	758 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	759 if (! (C1 (m1.data (i1)) OP C2 (m2.data (i2)))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	760 r.data (m1.ridx (i1) + j * m1_nr) = false; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	761 i1++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	762 i2++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	763 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	764 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	765 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	766 r.maybe_compress (true); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	767 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	768 else \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	769 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	770 r = SparseBoolMatrix (m1_nr, m1_nc, m1.nnz () + m2.nnz ()); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	771 r.cidx (0) = static_cast<octave_idx_type> (0); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	774 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	775 octave_idx_type i1 = m1.cidx (j); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	776 octave_idx_type e1 = m1.cidx (j+1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	777 octave_idx_type i2 = m2.cidx (j); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	778 octave_idx_type e2 = m2.cidx (j+1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	779 while (i1 < e1 \|\| i2 < e2) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	782 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	783 if (C1 (Z1) OP C2 (m2.data (i2))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	784 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	785 r.ridx (nel) = m2.ridx (i2); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	786 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	787 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	788 i2++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	791 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	792 if (C1 (m1.data (i1)) OP C2 (Z2)) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	793 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	794 r.ridx (nel) = m1.ridx (i1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	795 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	796 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	797 i1++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	798 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	799 else \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	800 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	801 if (C1 (m1.data (i1)) OP C2 (m2.data (i2))) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	802 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	803 r.ridx (nel) = m1.ridx (i1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	804 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	805 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	806 i1++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	807 i2++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	808 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	809 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	810 r.cidx (j + 1) = nel; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	811 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	812 r.maybe_compress (false); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	816 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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)) \
cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	819 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	820 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	821 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	822 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	823
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	829 SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, Z1, , M2, Z2, ) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	830 SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, Z1, , M2, Z2, )
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	831
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	832 #define SPARSE_SMSM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2) \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	833 SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, Z1, , M2, Z2, ) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	834 SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, Z1, , M2, Z2, )
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 5ac184c05811 additional AIX build fix John W. Eaton <jwe@octave.org> parents: 8187 diff changeset	838
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	839 #define SPARSE_SMSM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	840 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	841 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	842 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	843 SparseBoolMatrix r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	844 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	845 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	846 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	847 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	848 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	849 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	850 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	851 if (m1_nr == 1 && m1_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	882 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	883 else if (m2_nr == 1 && m2_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	914 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	915 else if (m1_nr == m2_nr && m1_nc == m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	919 r = SparseBoolMatrix (m1_nr, m1_nc, m1.nnz () + m2.nnz ()); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	920 r.cidx (0) = static_cast<octave_idx_type> (0); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	923 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	924 octave_idx_type i1 = m1.cidx (j); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	925 octave_idx_type e1 = m1.cidx (j+1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	926 octave_idx_type i2 = m2.cidx (j); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	927 octave_idx_type e2 = m2.cidx (j+1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	928 while (i1 < e1 \|\| i2 < e2) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	931 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	932 if (LHS_ZERO OP m2.data (i2) != RHS_ZERO) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	933 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	934 r.ridx (nel) = m2.ridx (i2); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	935 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	936 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	937 i2++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	940 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	941 if (m1.data (i1) != LHS_ZERO OP RHS_ZERO) \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	942 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	943 r.ridx (nel) = m1.ridx (i1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	944 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	945 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	946 i1++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	947 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	948 else \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	951 { \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	952 r.ridx (nel) = m1.ridx (i1); \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	953 r.data (nel++) = true; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	954 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	955 i1++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	956 i2++; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	957 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	958 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	959 r.cidx (j + 1) = nel; \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	960 } \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	964 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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)) \
cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	967 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	968 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	969 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	970 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	971
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	972 #define SPARSE_SMSM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	973 SPARSE_SMSM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO) \
20068 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	974 SPARSE_SMSM_BOOL_OP (mx_el_or, \|\|, M1, M2, LHS_ZERO, RHS_ZERO)
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	975
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	976 #define SPARSE_SMSM_BOOL_OPS(M1, M2, ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	977 SPARSE_SMSM_BOOL_OPS2(M1, M2, ZERO, ZERO)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	978
19461 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19007 diff changeset	979 // matrix by sparse matrix operations.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	982 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	983 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	984 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	985 R r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	986 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	987 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	988 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	989 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	990 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	991 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	992 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	995 else if (m1_nr != m2_nr \|\| m1_nc != m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	996 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	997 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1000 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1001 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1002 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1005 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1006 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1007 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1008 R r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1009 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1010 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1011 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1012 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1013 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1014 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1015 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1018 else if (m1_nr != m2_nr \|\| m1_nc != m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1019 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1020 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1048 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1049 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1050 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1051 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1054 #define SPARSE_MSM_BIN_OPS(R1, R2, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1055 SPARSE_MSM_BIN_OP_1 (R1, operator +, +, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1061 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1062 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1063 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1064 SparseBoolMatrix r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1065 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1066 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1067 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1068 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1069 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1070 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1071 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1074 else if (m1_nr == m2_nr && m1_nc == m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 { \
19007 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1084 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1085 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1104 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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)) \
cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1107 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1108 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1109 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1110 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1111
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1117 SPARSE_MSM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1118 SPARSE_MSM_CMP_OP (mx_el_ne, !=, M1, , M2, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1119
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1120 #define SPARSE_MSM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1121 SPARSE_MSM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1122 SPARSE_MSM_CMP_OP (mx_el_ne, !=, M1, , M2, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1123
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1124 #define SPARSE_MSM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1125 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1126 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1127 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1128 SparseBoolMatrix r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1129 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1130 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1131 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1132 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1133 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1134 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1135 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1138 else if (m1_nr == m2_nr && m1_nc == m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 { \
19007 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1149 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1150 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1170 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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)) \
cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1173 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1174 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1175 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1176 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1177
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1178 #define SPARSE_MSM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1179 SPARSE_MSM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO) \
20068 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	1180 SPARSE_MSM_BOOL_OP (mx_el_or, \|\|, M1, M2, LHS_ZERO, RHS_ZERO)
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1181
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1182 #define SPARSE_MSM_BOOL_OPS(M1, M2, ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1183 SPARSE_MSM_BOOL_OPS2(M1, M2, ZERO, ZERO)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1184
19461 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19007 diff changeset	1185 // sparse matrix by matrix operations.
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1188 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1189 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1190 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1191 R r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1192 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1193 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1194 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1195 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1196 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1197 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1198 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1201 else if (m1_nr != m2_nr \|\| m1_nc != m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1202 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1203 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1206 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1207 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1208 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1219 R \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1220 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1221 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1222 R r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1223 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1224 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1225 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1226 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1227 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1228 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1229 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1232 else if (m1_nr != m2_nr \|\| m1_nc != m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1233 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1234 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1262 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1263 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1264 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1265 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1266
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1267 #define SPARSE_SMM_BIN_OPS(R1, R2, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1268 SPARSE_SMM_BIN_OP_1 (R1, operator +, +, M1, M2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1274 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1275 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1276 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1277 SparseBoolMatrix r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1278 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1279 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1280 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1281 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1282 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1283 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1284 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1287 else if (m1_nr == m2_nr && m1_nc == m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 { \
19007 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1297 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1298 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1317 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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)) \
cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1320 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1321 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1322 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1323 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1324
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1330 SPARSE_SMM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1331 SPARSE_SMM_CMP_OP (mx_el_ne, !=, M1, , M2, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1332
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1333 #define SPARSE_SMM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1334 SPARSE_SMM_CMP_OP (mx_el_eq, ==, M1, , M2, ) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1335 SPARSE_SMM_CMP_OP (mx_el_ne, !=, M1, , M2, )
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1336
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1337 #define SPARSE_SMM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1338 SparseBoolMatrix \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1339 F (const M1& m1, const M2& m2) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1340 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1341 SparseBoolMatrix r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1342 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1343 octave_idx_type m1_nr = m1.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1344 octave_idx_type m1_nc = m1.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1345 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1346 octave_idx_type m2_nr = m2.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1347 octave_idx_type m2_nc = m2.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1348 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1351 else if (m1_nr == m2_nr && m1_nc == m2_nc) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 { \
19007 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18833 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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1362 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1363 r = SparseBoolMatrix (m1_nr, m1_nc, nel); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1383 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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)) \
cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1386 gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1387 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1388 return r; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1389 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1390
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1391 #define SPARSE_SMM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1392 SPARSE_SMM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO) \
20068 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	1393 SPARSE_SMM_BOOL_OP (mx_el_or, \|\|, M1, M2, LHS_ZERO, RHS_ZERO)
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1394
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1395 #define SPARSE_SMM_BOOL_OPS(M1, M2, ZERO) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1396 SPARSE_SMM_BOOL_OPS2(M1, M2, ZERO, ZERO)
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1397
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1398 // Avoid some code duplication. Maybe we should use templates.
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1401 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1402 octave_idx_type nr = rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1403 octave_idx_type nc = cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1404 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1405 RET_TYPE retval; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1406 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1407 if (nr > 0 && nc > 0) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1408 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1411 retval = transpose (). FCN (0) .transpose (); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1412 else \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1413 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1416 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1434 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1439 if (t != ELT_TYPE ()) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1444 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1445 retval.data (ii) = t; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1446 retval.ridx (ii++) = k; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1447 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1452 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1453 retval.data (ii) = t; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1454 retval.ridx (ii++) = k; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1455 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1456 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1457 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1462 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1463 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1464 retval = RET_TYPE (nr,nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1465 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1466 return retval
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1467
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1470 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1471 octave_idx_type nr = rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1472 octave_idx_type nc = cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1473 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1474 RET_TYPE retval; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1475 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1476 if (nr > 0 && nc > 0) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1477 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1480 retval = transpose (). FCN (0) .transpose (); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1481 else \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1482 { \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1490 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1491 nel++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1492 jj++; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1493 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1494 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1495 break; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1502 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1512 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1513 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1514 break; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1519 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1520 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1521 retval = RET_TYPE (nr,nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1522 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1523 return retval
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1524
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1527 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1528 octave_idx_type nr = rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1529 octave_idx_type nc = cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1530 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1531 RET_TYPE retval; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1532 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1533 if (nr > 0 && nc > 0) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1534 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1537 /* Define j here to allow fancy definition for prod method */ \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1546 { \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1547 ROW_EXPR; \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1573 { \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1574 COL_EXPR; \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1594 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1595 else if (nc == 0 && (nr == 0 \|\| (nr == 1 && dim == -1))) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1596 { \
7197 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1597 if (MT_RESULT) \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1598 { \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1599 retval = RET_TYPE (static_cast<octave_idx_type> (1), \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1600 static_cast<octave_idx_type> (1), \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	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 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1606 } \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1607 else \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1608 retval = RET_TYPE (static_cast<octave_idx_type> (1), \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1609 static_cast<octave_idx_type> (1), \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1610 static_cast<octave_idx_type> (0)); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1611 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1612 else if (nr == 0 && (dim == 0 \|\| dim == -1)) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1613 { \
7197 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1614 if (MT_RESULT) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1615 { \
7197 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1616 retval = RET_TYPE (static_cast<octave_idx_type> (1), nc, nc); \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1617 retval.cidx (0) = 0; \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1618 for (octave_idx_type i = 0; i < nc ; i++) \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1619 { \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	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 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1624 } \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1625 else \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1628 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1629 else if (nc == 0 && dim == 1) \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1630 { \
7197 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1631 if (MT_RESULT) \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1632 { \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	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 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	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 e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1641 } \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	1642 else \
e1c865f21751 [project @ 2007-11-27 01:38:48 by jwe] jwe parents: 7017 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1645 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1646 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1647 retval.resize (nr > 0, nc > 0); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1648 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1649 return retval
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1650
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1653
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1654 #define SPARSE_REDUCTION_OP_COL_EXPR(OP) \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1655 tmp[j] OP data (i)
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1662
7350 288614c6634d [project @ 2008-01-07 16:50:34 by jwe] jwe parents: 7344 diff changeset	1663
288614c6634d [project @ 2008-01-07 16:50:34 by jwe] jwe parents: 7344 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1666 #define SPARSE_ANY_ALL_OP_ROW_CODE(TEST_OP, TEST_TRUE_VAL) \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1667 if (data (i) TEST_OP 0.0) \
20068 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	1668 tmp[ridx (i)] = TEST_TRUE_VAL;
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1669
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1670 #define SPARSE_ANY_ALL_OP_COL_CODE(TEST_OP, TEST_TRUE_VAL) \
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1671 if (data (i) TEST_OP 0.0) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1672 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1673 tmp[j] = TEST_TRUE_VAL; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1674 break; \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1675 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1676
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1677 #define SPARSE_ANY_ALL_OP(DIM, INIT_VAL, MT_RESULT, TEST_OP, TEST_TRUE_VAL) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1682
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1686 else \
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	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 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1690 }
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1691
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7197 diff changeset	1692 #define SPARSE_ANY_OP(DIM) SPARSE_ANY_ALL_OP (DIM, false, false, !=, true)
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1693
18833 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 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1695 octave_idx_type nr = m.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1696 octave_idx_type nc = m.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1697 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1698 octave_idx_type a_nr = a.rows (); \
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1699 octave_idx_type a_nc = a.cols (); \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1700 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1701 if (nr == 1 && nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1705 RET_TYPE r (a_nr, a_nc, nz); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1706 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1707 for (octave_idx_type i = 0; i < nz; i++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1712 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1713 for (octave_idx_type i = 0; i < a_nc + 1; i++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1717 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1718 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1719 r.maybe_compress (true); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1720 return r; \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1721 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1722 else if (a_nr == 1 && a_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1726 RET_TYPE r (nr, nc, nz); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1727 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1728 for (octave_idx_type i = 0; i < nz; i++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1733 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1734 for (octave_idx_type i = 0; i < nc + 1; i++) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1738 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1739 \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1740 r.maybe_compress (true); \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1741 return r; \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1742 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1743 else if (nc != a_nr) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1744 { \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1745 gripe_nonconformant ("operator *", nr, nc, a_nr, a_nc); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1746 return RET_TYPE (); \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1747 } \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1748 else \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1749 { \
5586 d37b96139376 [project @ 2005-12-28 20:16:50 by dbateman] dbateman parents: 5506 diff changeset	1750 OCTAVE_LOCAL_BUFFER (octave_idx_type, w, nr); \
5876 565d0cd4d9d0 [project @ 2006-07-01 19:42:06 by dbateman] dbateman parents: 5813 diff changeset	1751 RET_TYPE retval (nr, a_nc, static_cast<octave_idx_type> (0)); \
5586 d37b96139376 [project @ 2005-12-28 20:16:50 by dbateman] dbateman parents: 5506 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1755 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1756 octave_idx_type nel = 0; \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1757 \
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1758 for (octave_idx_type i = 0; i < a_nc; i++) \
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 d37b96139376 [project @ 2005-12-28 20:16:50 by dbateman] dbateman parents: 5506 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1775 \
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1778 else \
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1779 { \
5586 d37b96139376 [project @ 2005-12-28 20:16:50 by dbateman] dbateman parents: 5506 diff changeset	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 233d98d95659 [project @ 2006-03-16 17:48:55 by dbateman] dbateman parents: 5604 diff changeset	1783 OCTAVE_LOCAL_BUFFER (RET_EL_TYPE, Xcol, nr); \
5586 d37b96139376 [project @ 2005-12-28 20:16:50 by dbateman] dbateman parents: 5506 diff changeset	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 */ \
19007 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18833 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 */ \
19007 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18833 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 dd0422e4022c [project @ 2006-05-08 21:03:46 by dbateman] dbateman parents: 5775 diff changeset	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 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1861 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	1862
18833 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 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1864 octave_idx_type nr = m.rows (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1865 octave_idx_type nc = m.cols (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1866 \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1867 octave_idx_type a_nr = a.rows (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1868 octave_idx_type a_nc = a.cols (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1869 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1870 if (nr == 1 && nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1873 return retval; \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1874 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1875 else if (nc != a_nr) \
5429 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1876 { \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1877 gripe_nonconformant ("operator *", nr, nc, a_nr, a_nc); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1878 return RET_TYPE (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1879 } \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1880 else \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1881 { \
5681 233d98d95659 [project @ 2006-03-16 17:48:55 by dbateman] dbateman parents: 5604 diff changeset	1882 RET_TYPE retval (nr, a_nc, ZERO); \
5429 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1883 \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	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
18833 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 { \
1a446f28ce68 implement optimized sparse-dense transposed multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7350 diff changeset	1912 gripe_nonconformant ("operator *", nc, nr, a_nr, a_nc); \
1a446f28ce68 implement optimized sparse-dense transposed multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7350 diff changeset	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 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1930 } \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1931 return retval; \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1932 }
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1933
18833 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 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1935 octave_idx_type nr = m.rows (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1936 octave_idx_type nc = m.cols (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1937 \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1938 octave_idx_type a_nr = a.rows (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1939 octave_idx_type a_nc = a.cols (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1940 \
6221 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1941 if (a_nr == 1 && a_nc == 1) \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	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 8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1944 return retval; \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1945 } \
8e0f1eda266b [project @ 2007-01-03 17:23:33 by jwe] jwe parents: 6108 diff changeset	1946 else if (nc != a_nr) \
5429 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1947 { \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1948 gripe_nonconformant ("operator *", nr, nc, a_nr, a_nc); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1949 return RET_TYPE (); \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1950 } \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1951 else \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1952 { \
5681 233d98d95659 [project @ 2006-03-16 17:48:55 by dbateman] dbateman parents: 5604 diff changeset	1953 RET_TYPE retval (nr, a_nc, ZERO); \
5429 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	1954 \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	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
18833 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 { \
1a446f28ce68 implement optimized sparse-dense transposed multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7350 diff changeset	1984 gripe_nonconformant ("operator *", nr, nc, a_nc, a_nr); \
1a446f28ce68 implement optimized sparse-dense transposed multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7350 diff changeset	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 2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	2001 } \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	2002 return retval; \
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	2003 }
2042301733ce [project @ 2005-08-25 12:21:24 by dbateman] dbateman parents: 5307 diff changeset	2004
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: diff changeset	2005 #endif

Mercurial > hg > octave-nkf

annotate liboctave/operators/Sparse-op-defs.h @ 20750:3339c9bdfe6a