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

annotate liboctave/operators/Sparse-op-defs.h @ 19895:19755f4fc851

maint: Cleanup C++ code to follow Octave coding conventions. Try to wrap long lines to < 80 characters. Use GNU style and don't indent first brace of function definition. "case" statement is aligned flush left with brace of switch stmt. Remove trailing '\' line continuation from the end of #define macros. Use 2 spaces for indent. * files-dock-widget.cc, history-dock-widget.cc, main-window.cc, octave-cmd.cc, octave-dock-widget.cc, octave-gui.cc, resource-manager.cc, settings-dialog.cc, shortcut-manager.cc, welcome-wizard.cc, workspace-view.cc, cellfun.cc, data.cc, debug.cc, debug.h, dirfns.cc, error.h, file-io.cc, gl-render.cc, gl-render.h, gl2ps-renderer.h, graphics.cc, graphics.in.h, help.cc, input.cc, load-path.cc, load-path.h, lookup.cc, lu.cc, oct-stream.cc, octave-default-image.h, ordschur.cc, pr-output.cc, qz.cc, strfns.cc, symtab.cc, symtab.h, sysdep.cc, variables.cc, zfstream.h, __fltk_uigetfile__.cc, __init_fltk__.cc, __magick_read__.cc, __osmesa_print__.cc, audiodevinfo.cc, ov-classdef.cc, ov-classdef.h, ov-fcn.h, ov-float.cc, ov-flt-complex.cc, ov-java.cc, ov-range.cc, ov-re-mat.cc, ov-usr-fcn.h, ov.cc, op-int.h, options-usage.h, pt-eval.cc, Array-C.cc, Array-fC.cc, Array.cc, Array.h, PermMatrix.cc, Sparse.cc, chMatrix.h, dSparse.cc, dim-vector.h, bsxfun-decl.h, bsxfun-defs.cc, oct-norm.cc, Sparse-op-defs.h, oct-inttypes.cc, oct-inttypes.h, main.in.cc, mkoctfile.in.cc: Cleanup C++ code to follow Octave coding conventions.

author	Rik <rik@octave.org>
date	Wed, 25 Feb 2015 11:55:49 -0800
parents	4197fc428c7d
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
19731 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19303 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
19303 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 18851 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
19303 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 18851 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
19303 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 18851 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 \
18712 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 } \
18712 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 \
18712 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 } \
18712 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 \
18712 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 } \
18712 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) \
19895 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19731 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
19303 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 18851 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 { \
18851 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18712 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 { \
18851 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18712 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) \
19895 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19731 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
19303 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 18851 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 { \
18851 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18712 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 { \
18851 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18712 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) \
19895 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19731 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) \
19895 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19731 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
18712 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 */ \
18851 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18712 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 */ \
18851 9ac2357f19bc doc: Replace "non-zero" with "nonzero" to match existing usage. Rik <rik@octave.org> parents: 18712 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
18712 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
18712 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
18712 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
18712 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 > octave-nkf

annotate liboctave/operators/Sparse-op-defs.h @ 19895:19755f4fc851