Mercurial > octave
annotate liboctave/array/Sparse.cc @ 23461:8befed6e9ccc
maint: Eliminate fairly useless 1-line comment ahead of copyright statement for some files.
* oct-errno.h, urlwrite.cc, Array.cc, Array.h, CColVector.cc, CDiagMatrix.cc,
CMatrix.cc, CNDArray.cc, CRowVector.cc, DiagArray2.cc, DiagArray2.h,
MDiagArray2.h, Matrix.h, Sparse.cc, boolMatrix.cc, boolNDArray.cc, chMatrix.cc,
chNDArray.cc, dColVector.cc, dDiagMatrix.cc, dMatrix.cc, dNDArray.cc,
dRowVector.cc, fCColVector.cc, fCDiagMatrix.cc, fCMatrix.cc, fCNDArray.cc,
fCRowVector.cc, fColVector.cc, fDiagMatrix.cc, fMatrix.cc, fNDArray.cc,
fRowVector.cc, int16NDArray.cc, int32NDArray.cc, int64NDArray.cc,
int8NDArray.cc, intNDArray.cc, uint16NDArray.cc, uint32NDArray.cc,
uint64NDArray.cc, uint8NDArray.cc, f77-extern.cc:
Remove first line comment that describes file as this can already be determined
by filename.
author | Rik <rik@octave.org> |
---|---|
date | Tue, 02 May 2017 15:00:43 -0700 |
parents | 855122b993da |
children | b6498c088fca |
rev | line source |
---|---|
5164 | 1 /* |
2 | |
23219
3ac9f9ecfae5
maint: Update copyright dates.
John W. Eaton <jwe@octave.org>
parents:
23083
diff
changeset
|
3 Copyright (C) 2004-2017 David Bateman |
11523 | 4 Copyright (C) 1998-2004 Andy Adler |
10521
4d1fc073fbb7
add some missing copyright stmts
Jaroslav Hajek <highegg@gmail.com>
parents:
10520
diff
changeset
|
5 Copyright (C) 2010 VZLU Prague |
7016 | 6 |
7 This file is part of Octave. | |
5164 | 8 |
9 Octave is free software; you can redistribute it and/or modify it | |
22755
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
10 under the terms of the GNU General Public License as published by |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
11 the Free Software Foundation; either version 3 of the License, or |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
12 (at your option) any later version. |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
13 |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
14 Octave is distributed in the hope that it will be useful, but |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
15 WITHOUT ANY WARRANTY; without even the implied warranty of |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22600
diff
changeset
|
17 GNU General Public License for more details. |
5164 | 18 |
19 You should have received a copy of the GNU General Public License | |
7016 | 20 along with Octave; see the file COPYING. If not, see |
21 <http://www.gnu.org/licenses/>. | |
5164 | 22 |
23 */ | |
24 | |
21690
b6a686543080
Only include config.h in files that are compiled separately.
John W. Eaton <jwe@octave.org>
parents:
21660
diff
changeset
|
25 // This file should not include config.h. It is only included in other |
b6a686543080
Only include config.h in files that are compiled separately.
John W. Eaton <jwe@octave.org>
parents:
21660
diff
changeset
|
26 // C++ source files that should have included config.h before including |
b6a686543080
Only include config.h in files that are compiled separately.
John W. Eaton <jwe@octave.org>
parents:
21660
diff
changeset
|
27 // this file. |
5164 | 28 |
29 #include <cassert> | |
30 | |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
31 #include <algorithm> |
5164 | 32 #include <iostream> |
15215
9020dddc925a
use std::numeric_limits for integer max and min values
John W. Eaton <jwe@octave.org>
parents:
15020
diff
changeset
|
33 #include <limits> |
5765 | 34 #include <sstream> |
5164 | 35 #include <vector> |
36 | |
37 #include "Array.h" | |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
38 #include "MArray.h" |
5164 | 39 #include "Array-util.h" |
40 #include "Range.h" | |
41 #include "idx-vector.h" | |
42 #include "lo-error.h" | |
43 #include "quit.h" | |
8377
25bc2d31e1bf
improve OCTAVE_LOCAL_BUFFER
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
44 #include "oct-locbuf.h" |
5164 | 45 |
46 #include "Sparse.h" | |
47 #include "sparse-sort.h" | |
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
9177
diff
changeset
|
48 #include "sparse-util.h" |
5164 | 49 #include "oct-spparms.h" |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
50 #include "mx-inlines.cc" |
5164 | 51 |
13030
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
52 #include "PermMatrix.h" |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
53 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
54 template <typename T> |
21573
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21256
diff
changeset
|
55 typename Sparse<T>::SparseRep * |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21256
diff
changeset
|
56 Sparse<T>::nil_rep (void) |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21256
diff
changeset
|
57 { |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21256
diff
changeset
|
58 static typename Sparse<T>::SparseRep nr; |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21256
diff
changeset
|
59 return &nr; |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21256
diff
changeset
|
60 } |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21256
diff
changeset
|
61 |
21574 | 62 template <typename T> |
13030
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
63 Sparse<T>::Sparse (const PermMatrix& a) |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
64 : rep (new typename Sparse<T>::SparseRep (a.rows (), a.cols (), a.rows ())), |
19861
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
65 dimensions (dim_vector (a.rows (), a.cols ())) |
13030
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
66 { |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
67 octave_idx_type n = a.rows (); |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
68 for (octave_idx_type i = 0; i <= n; i++) |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
69 cidx (i) = i; |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
70 |
18849
aa9ca67f09fb
make all permutation matrices column permutations (bug #42418)
David Spies <dnspies@gmail.com>
parents:
18812
diff
changeset
|
71 const Array<octave_idx_type> pv = a.col_perm_vec (); |
aa9ca67f09fb
make all permutation matrices column permutations (bug #42418)
David Spies <dnspies@gmail.com>
parents:
18812
diff
changeset
|
72 |
aa9ca67f09fb
make all permutation matrices column permutations (bug #42418)
David Spies <dnspies@gmail.com>
parents:
18812
diff
changeset
|
73 for (octave_idx_type i = 0; i < n; i++) |
aa9ca67f09fb
make all permutation matrices column permutations (bug #42418)
David Spies <dnspies@gmail.com>
parents:
18812
diff
changeset
|
74 ridx (i) = pv(i); |
13030
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
75 |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
76 for (octave_idx_type i = 0; i < n; i++) |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
77 data (i) = 1.0; |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
78 } |
b646413c3d0e
Make operators do smarter sparse conversions on permutation matrices.
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12511
diff
changeset
|
79 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
80 template <typename T> |
5164 | 81 T& |
5275 | 82 Sparse<T>::SparseRep::elem (octave_idx_type _r, octave_idx_type _c) |
5164 | 83 { |
5275 | 84 octave_idx_type i; |
5164 | 85 |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
86 if (nzmx <= 0) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
87 (*current_liboctave_error_handler) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
88 ("Sparse::SparseRep::elem (octave_idx_type, octave_idx_type): sparse matrix filled"); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
89 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
90 for (i = c[_c]; i < c[_c + 1]; i++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
91 if (r[i] == _r) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
92 return d[i]; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
93 else if (r[i] > _r) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
94 break; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
95 |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
96 // Ok, If we've gotten here, we're in trouble. Have to create a |
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
97 // new element in the sparse array. This' gonna be slow!!! |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
98 if (c[ncols] == nzmx) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
99 (*current_liboctave_error_handler) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
100 ("Sparse::SparseRep::elem (octave_idx_type, octave_idx_type): sparse matrix filled"); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
101 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
102 octave_idx_type to_move = c[ncols] - i; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
103 if (to_move != 0) |
5164 | 104 { |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
105 for (octave_idx_type j = c[ncols]; j > i; j--) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
106 { |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
107 d[j] = d[j-1]; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
108 r[j] = r[j-1]; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
109 } |
5164 | 110 } |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
111 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
112 for (octave_idx_type j = _c + 1; j < ncols + 1; j++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
113 c[j] = c[j] + 1; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
114 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
115 d[i] = 0.; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
116 r[i] = _r; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
117 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
118 return d[i]; |
5164 | 119 } |
120 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
121 template <typename T> |
5164 | 122 T |
5275 | 123 Sparse<T>::SparseRep::celem (octave_idx_type _r, octave_idx_type _c) const |
5164 | 124 { |
5604 | 125 if (nzmx > 0) |
5275 | 126 for (octave_idx_type i = c[_c]; i < c[_c + 1]; i++) |
5164 | 127 if (r[i] == _r) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
128 return d[i]; |
5164 | 129 return T (); |
130 } | |
131 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
132 template <typename T> |
5164 | 133 void |
134 Sparse<T>::SparseRep::maybe_compress (bool remove_zeros) | |
135 { | |
136 if (remove_zeros) | |
137 { | |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
138 octave_idx_type i = 0; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
139 octave_idx_type k = 0; |
10497
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
140 for (octave_idx_type j = 1; j <= ncols; j++) |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
141 { |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
142 octave_idx_type u = c[j]; |
21337
cfe11042fbc0
eliminate useless assignment in for loop
John W. Eaton <jwe@octave.org>
parents:
21301
diff
changeset
|
143 for (; i < u; i++) |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
144 if (d[i] != T ()) |
10497
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
145 { |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
146 d[k] = d[i]; |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
147 r[k++] = r[i]; |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
148 } |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
149 c[j] = k; |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
150 } |
5164 | 151 } |
10497
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
152 |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
153 change_length (c[ncols]); |
5164 | 154 } |
155 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
156 template <typename T> |
5164 | 157 void |
5275 | 158 Sparse<T>::SparseRep::change_length (octave_idx_type nz) |
5164 | 159 { |
10497
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
160 for (octave_idx_type j = ncols; j > 0 && c[j] > nz; j--) |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
161 c[j] = nz; |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
162 |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
163 // We shall skip reallocation if we have less than 1/frac extra elements to |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
164 // discard. |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
165 static const int frac = 5; |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
166 if (nz > nzmx || nz < nzmx - nzmx/frac) |
5164 | 167 { |
10497
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
168 // Reallocate. |
cb7ffe7288f0
improve & fix SparseRep reallocation and compression
Jaroslav Hajek <highegg@gmail.com>
parents:
10494
diff
changeset
|
169 octave_idx_type min_nzmx = std::min (nz, nzmx); |
5275 | 170 |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
171 octave_idx_type *new_ridx = new octave_idx_type [nz]; |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
172 std::copy_n (r, min_nzmx, new_ridx); |
5164 | 173 |
174 delete [] r; | |
175 r = new_ridx; | |
176 | |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
177 T *new_data = new T [nz]; |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
178 std::copy_n (d, min_nzmx, new_data); |
5164 | 179 |
180 delete [] d; | |
181 d = new_data; | |
182 | |
5604 | 183 nzmx = nz; |
5164 | 184 } |
185 } | |
186 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
187 template <typename T> |
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
9177
diff
changeset
|
188 bool |
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
9177
diff
changeset
|
189 Sparse<T>::SparseRep::indices_ok (void) const |
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
9177
diff
changeset
|
190 { |
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
9177
diff
changeset
|
191 return sparse_indices_ok (r, c, nrows, ncols, nnz ()); |
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
9177
diff
changeset
|
192 } |
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
9177
diff
changeset
|
193 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
194 template <typename T> |
21990
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
195 bool |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
196 Sparse<T>::SparseRep::any_element_is_nan (void) const |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
197 { |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
198 octave_idx_type nz = nnz (); |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
199 |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
200 for (octave_idx_type i = 0; i < nz; i++) |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
201 if (octave::math::isnan (d[i])) |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
202 return true; |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
203 |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
204 return false; |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
205 } |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
206 |
efce657ceb86
Provide a warning when an array is used in an if/while/until (bug #43098).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21751
diff
changeset
|
207 template <typename T> |
5275 | 208 Sparse<T>::Sparse (octave_idx_type nr, octave_idx_type nc, T val) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
209 : rep (0), dimensions (dim_vector (nr, nc)) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
210 { |
5630 | 211 if (val != T ()) |
5164 | 212 { |
17823
eaf5c3ef3e8d
avoid crash in sparse constructor (bug #)
John W. Eaton <jwe@octave.org>
parents:
17769
diff
changeset
|
213 rep = new typename Sparse<T>::SparseRep (nr, nc, dimensions.safe_numel ()); |
5630 | 214 |
215 octave_idx_type ii = 0; | |
216 xcidx (0) = 0; | |
217 for (octave_idx_type j = 0; j < nc; j++) | |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
218 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
219 for (octave_idx_type i = 0; i < nr; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
220 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
221 xdata (ii) = val; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
222 xridx (ii++) = i; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
223 } |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
224 xcidx (j+1) = ii; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
225 } |
5630 | 226 } |
227 else | |
228 { | |
229 rep = new typename Sparse<T>::SparseRep (nr, nc, 0); | |
230 for (octave_idx_type j = 0; j < nc+1; j++) | |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
231 xcidx (j) = 0; |
5164 | 232 } |
233 } | |
234 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
235 template <typename T> |
5164 | 236 Sparse<T>::Sparse (const dim_vector& dv) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
237 : rep (0), dimensions (dv) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
238 { |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
239 if (dv.ndims () != 2) |
5164 | 240 (*current_liboctave_error_handler) |
241 ("Sparse::Sparse (const dim_vector&): dimension mismatch"); | |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
242 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
243 rep = new typename Sparse<T>::SparseRep (dv(0), dv(1), 0); |
5164 | 244 } |
245 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
246 template <typename T> |
5164 | 247 Sparse<T>::Sparse (const Sparse<T>& a, const dim_vector& dv) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
248 : rep (0), dimensions (dv) |
5164 | 249 { |
250 | |
251 // Work in unsigned long long to avoid overflow issues with numel | |
252 unsigned long long a_nel = static_cast<unsigned long long>(a.rows ()) * | |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
253 static_cast<unsigned long long>(a.cols ()); |
20218
b2100e1659ac
maint: Use cuddled parentheses when indexing dimension_vectors.
Rik <rik@octave.org>
parents:
19861
diff
changeset
|
254 unsigned long long dv_nel = static_cast<unsigned long long>(dv(0)) * |
b2100e1659ac
maint: Use cuddled parentheses when indexing dimension_vectors.
Rik <rik@octave.org>
parents:
19861
diff
changeset
|
255 static_cast<unsigned long long>(dv(1)); |
5164 | 256 |
257 if (a_nel != dv_nel) | |
258 (*current_liboctave_error_handler) | |
259 ("Sparse::Sparse (const Sparse&, const dim_vector&): dimension mismatch"); | |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
260 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
261 dim_vector old_dims = a.dims (); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
262 octave_idx_type new_nzmx = a.nnz (); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
263 octave_idx_type new_nr = dv(0); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
264 octave_idx_type new_nc = dv(1); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
265 octave_idx_type old_nr = old_dims(0); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
266 octave_idx_type old_nc = old_dims(1); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
267 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
268 rep = new typename Sparse<T>::SparseRep (new_nr, new_nc, new_nzmx); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
269 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
270 octave_idx_type kk = 0; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
271 xcidx (0) = 0; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
272 for (octave_idx_type i = 0; i < old_nc; i++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
273 for (octave_idx_type j = a.cidx (i); j < a.cidx (i+1); j++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
274 { |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
275 octave_idx_type tmp = i * old_nr + a.ridx (j); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
276 octave_idx_type ii = tmp % new_nr; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
277 octave_idx_type jj = (tmp - ii) / new_nr; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
278 for (octave_idx_type k = kk; k < jj; k++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
279 xcidx (k+1) = j; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
280 kk = jj; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
281 xdata (j) = a.data (j); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
282 xridx (j) = ii; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
283 } |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
284 for (octave_idx_type k = kk; k < new_nc; k++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
285 xcidx (k+1) = new_nzmx; |
5164 | 286 } |
287 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
288 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
289 Sparse<T>::Sparse (const Array<T>& a, const idx_vector& r, |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
290 const idx_vector& c, octave_idx_type nr, |
10527
b4d2080b6df7
Replace nzmax by nnz as needed
David Bateman <dbateman@free.fr>
parents:
10521
diff
changeset
|
291 octave_idx_type nc, bool sum_terms, |
b4d2080b6df7
Replace nzmax by nnz as needed
David Bateman <dbateman@free.fr>
parents:
10521
diff
changeset
|
292 octave_idx_type nzm) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
293 : rep (0), dimensions () |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
294 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
295 if (nr < 0) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
296 nr = r.extent (0); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
297 else if (r.extent (nr) > nr) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
298 (*current_liboctave_error_handler) ("sparse: row index %d out of bound %d", |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
299 r.extent (nr), nr); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
300 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
301 if (nc < 0) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
302 nc = c.extent (0); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
303 else if (c.extent (nc) > nc) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
304 (*current_liboctave_error_handler) |
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
305 ("sparse: column index %d out of bound %d", r.extent (nc), nc); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
306 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
307 dimensions = dim_vector (nr, nc); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
308 |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
309 octave_idx_type n = a.numel (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
310 octave_idx_type rl = r.length (nr); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
311 octave_idx_type cl = c.length (nc); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
312 bool a_scalar = n == 1; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
313 if (a_scalar) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
314 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
315 if (rl != 1) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
316 n = rl; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
317 else if (cl != 1) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
318 n = cl; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
319 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
320 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
321 if ((rl != 1 && rl != n) || (cl != 1 && cl != n)) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
322 (*current_liboctave_error_handler) ("sparse: dimension mismatch"); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
323 |
17664
f4b0430fa5fd
Avoid memory leak in Sparse constructor.
Rik <rik@octave.org>
parents:
17642
diff
changeset
|
324 // Only create rep after input validation to avoid memory leak. |
f4b0430fa5fd
Avoid memory leak in Sparse constructor.
Rik <rik@octave.org>
parents:
17642
diff
changeset
|
325 rep = new typename Sparse<T>::SparseRep (nr, nc, (nzm > 0 ? nzm : 0)); |
f4b0430fa5fd
Avoid memory leak in Sparse constructor.
Rik <rik@octave.org>
parents:
17642
diff
changeset
|
326 |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
327 if (rl <= 1 && cl <= 1) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
328 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
329 if (n == 1 && a(0) != T ()) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
330 { |
10527
b4d2080b6df7
Replace nzmax by nnz as needed
David Bateman <dbateman@free.fr>
parents:
10521
diff
changeset
|
331 change_capacity (nzm > 1 ? nzm : 1); |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
332 xcidx (0) = 0; |
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
333 xridx (0) = r(0); |
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
334 xdata (0) = a(0); |
15358
b135f013679e
maint: periodic merge of stable to default
John W. Eaton <jwe@octave.org>
diff
changeset
|
335 |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
336 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
|
337 xcidx (j+1) = j >= c(0); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
338 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
339 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
340 else if (a_scalar) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
341 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
342 // This is completely specialized, because the sorts can be simplified. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
343 T a0 = a(0); |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
344 if (a0 == T ()) |
10509
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
345 { |
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
346 // Do nothing, it's an empty matrix. |
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
347 } |
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
348 else if (cl == 1) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
349 { |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
350 // Sparse column vector. Sort row indices. |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
351 idx_vector rs = r.sorted (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
352 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
353 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
354 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
355 const octave_idx_type *rd = rs.raw (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
356 // Count unique indices. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
357 octave_idx_type new_nz = 1; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
358 for (octave_idx_type i = 1; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
359 new_nz += rd[i-1] != rd[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
360 // Allocate result. |
10527
b4d2080b6df7
Replace nzmax by nnz as needed
David Bateman <dbateman@free.fr>
parents:
10521
diff
changeset
|
361 change_capacity (nzm > new_nz ? nzm : new_nz); |
14656
8d2ce821e38a
Ensure sparse constructors have valid ridx and data indices even if they are zero matrices (bug #36104)
David Bateman <dbateman@free.fr>
parents:
14446
diff
changeset
|
362 xcidx (0) = 0; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
363 xcidx (1) = new_nz; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
364 octave_idx_type *rri = ridx (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
365 T *rrd = data (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
366 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
367 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
368 |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
369 octave_idx_type k = -1; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
370 octave_idx_type l = -1; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
371 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
372 if (sum_terms) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
373 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
374 // Sum repeated indices. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
375 for (octave_idx_type i = 0; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
376 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
377 if (rd[i] != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
378 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
379 l = rd[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
380 rri[++k] = rd[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
381 rrd[k] = a0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
382 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
383 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
384 rrd[k] += a0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
385 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
386 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
387 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
388 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
389 // Pick the last one. |
11571
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
390 for (octave_idx_type i = 0; i < n; i++) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
391 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
392 if (rd[i] != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
393 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
394 l = rd[i]; |
11571
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
395 rri[++k] = rd[i]; |
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
396 rrd[k] = a0; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
397 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
398 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
399 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
400 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
401 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
402 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
403 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
404 idx_vector rr = r; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
405 idx_vector cc = c; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
406 const octave_idx_type *rd = rr.raw (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
407 const octave_idx_type *cd = cc.raw (); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
408 OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, ci, nc+1, 0); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
409 ci[0] = 0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
410 // Bin counts of column indices. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
411 for (octave_idx_type i = 0; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
412 ci[cd[i]+1]++; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
413 // Make them cumulative, shifted one to right. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
414 for (octave_idx_type i = 1, s = 0; i <= nc; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
415 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
416 octave_idx_type s1 = s + ci[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
417 ci[i] = s; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
418 s = s1; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
419 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
420 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
421 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
422 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
423 // Bucket sort. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
424 OCTAVE_LOCAL_BUFFER (octave_idx_type, sidx, n); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
425 for (octave_idx_type i = 0; i < n; i++) |
11571
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
426 if (rl == 1) |
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
427 sidx[ci[cd[i]+1]++] = rd[0]; |
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
428 else |
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
429 sidx[ci[cd[i]+1]++] = rd[i]; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
430 |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
431 // Subsorts. We don't need a stable sort, all values are equal. |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
432 xcidx (0) = 0; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
433 for (octave_idx_type j = 0; j < nc; j++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
434 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
435 std::sort (sidx + ci[j], sidx + ci[j+1]); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
436 octave_idx_type l = -1; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
437 octave_idx_type nzj = 0; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
438 // Count. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
439 for (octave_idx_type i = ci[j]; i < ci[j+1]; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
440 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
441 octave_idx_type k = sidx[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
442 if (k != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
443 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
444 l = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
445 nzj++; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
446 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
447 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
448 // Set column pointer. |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
449 xcidx (j+1) = xcidx (j) + nzj; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
450 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
451 |
10527
b4d2080b6df7
Replace nzmax by nnz as needed
David Bateman <dbateman@free.fr>
parents:
10521
diff
changeset
|
452 change_capacity (nzm > xcidx (nc) ? nzm : xcidx (nc)); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
453 octave_idx_type *rri = ridx (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
454 T *rrd = data (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
455 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
456 // Fill-in data. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
457 for (octave_idx_type j = 0, jj = -1; j < nc; j++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
458 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
459 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
460 octave_idx_type l = -1; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
461 if (sum_terms) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
462 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
463 // Sum adjacent terms. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
464 for (octave_idx_type i = ci[j]; i < ci[j+1]; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
465 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
466 octave_idx_type k = sidx[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
467 if (k != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
468 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
469 l = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
470 rrd[++jj] = a0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
471 rri[jj] = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
472 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
473 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
474 rrd[jj] += a0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
475 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
476 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
477 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
478 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
479 // Use the last one. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
480 for (octave_idx_type i = ci[j]; i < ci[j+1]; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
481 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
482 octave_idx_type k = sidx[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
483 if (k != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
484 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
485 l = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
486 rrd[++jj] = a0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
487 rri[jj] = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
488 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
489 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
490 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
491 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
492 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
493 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
494 else if (cl == 1) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
495 { |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
496 // Sparse column vector. Sort row indices. |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
497 Array<octave_idx_type> rsi; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
498 idx_vector rs = r.sorted (rsi); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
499 |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
500 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
501 |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
502 const octave_idx_type *rd = rs.raw (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
503 const octave_idx_type *rdi = rsi.data (); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
504 // Count unique indices. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
505 octave_idx_type new_nz = 1; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
506 for (octave_idx_type i = 1; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
507 new_nz += rd[i-1] != rd[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
508 // Allocate result. |
10527
b4d2080b6df7
Replace nzmax by nnz as needed
David Bateman <dbateman@free.fr>
parents:
10521
diff
changeset
|
509 change_capacity (nzm > new_nz ? nzm : new_nz); |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
510 xcidx (0) = 0; |
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
511 xcidx (1) = new_nz; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
512 octave_idx_type *rri = ridx (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
513 T *rrd = data (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
514 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
515 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
516 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
517 octave_idx_type k = 0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
518 rri[k] = rd[0]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
519 rrd[k] = a(rdi[0]); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
520 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
521 if (sum_terms) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
522 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
523 // Sum repeated indices. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
524 for (octave_idx_type i = 1; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
525 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
526 if (rd[i] != rd[i-1]) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
527 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
528 rri[++k] = rd[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
529 rrd[k] = a(rdi[i]); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
530 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
531 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
532 rrd[k] += a(rdi[i]); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
533 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
534 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
535 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
536 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
537 // Pick the last one. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
538 for (octave_idx_type i = 1; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
539 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
540 if (rd[i] != rd[i-1]) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
541 rri[++k] = rd[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
542 rrd[k] = a(rdi[i]); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
543 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
544 } |
10509
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
545 |
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
546 maybe_compress (true); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
547 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
548 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
549 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
550 idx_vector rr = r; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
551 idx_vector cc = c; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
552 const octave_idx_type *rd = rr.raw (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
553 const octave_idx_type *cd = cc.raw (); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
554 OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, ci, nc+1, 0); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
555 ci[0] = 0; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
556 // Bin counts of column indices. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
557 for (octave_idx_type i = 0; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
558 ci[cd[i]+1]++; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
559 // Make them cumulative, shifted one to right. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
560 for (octave_idx_type i = 1, s = 0; i <= nc; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
561 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
562 octave_idx_type s1 = s + ci[i]; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
563 ci[i] = s; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
564 s = s1; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
565 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
566 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
567 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
568 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
569 typedef std::pair<octave_idx_type, octave_idx_type> idx_pair; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
570 // Bucket sort. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
571 OCTAVE_LOCAL_BUFFER (idx_pair, spairs, n); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
572 for (octave_idx_type i = 0; i < n; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
573 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
574 idx_pair& p = spairs[ci[cd[i]+1]++]; |
11571
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
575 if (rl == 1) |
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
576 p.first = rd[0]; |
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
577 else |
0e414f837c58
Fix indexing error in the construction of sparse matrices
David Bateman <dbateman@free.fr>
parents:
11570
diff
changeset
|
578 p.first = rd[i]; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
579 p.second = i; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
580 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
581 |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
582 // Subsorts. We don't need a stable sort, the second index stabilizes it. |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
583 xcidx (0) = 0; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
584 for (octave_idx_type j = 0; j < nc; j++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
585 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
586 std::sort (spairs + ci[j], spairs + ci[j+1]); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
587 octave_idx_type l = -1; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
588 octave_idx_type nzj = 0; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
589 // Count. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
590 for (octave_idx_type i = ci[j]; i < ci[j+1]; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
591 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
592 octave_idx_type k = spairs[i].first; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
593 if (k != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
594 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
595 l = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
596 nzj++; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
597 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
598 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
599 // Set column pointer. |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
600 xcidx (j+1) = xcidx (j) + nzj; |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
601 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
602 |
10527
b4d2080b6df7
Replace nzmax by nnz as needed
David Bateman <dbateman@free.fr>
parents:
10521
diff
changeset
|
603 change_capacity (nzm > xcidx (nc) ? nzm : xcidx (nc)); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
604 octave_idx_type *rri = ridx (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
605 T *rrd = data (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
606 |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
607 // Fill-in data. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
608 for (octave_idx_type j = 0, jj = -1; j < nc; j++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
609 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
610 octave_quit (); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
611 octave_idx_type l = -1; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
612 if (sum_terms) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
613 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
614 // Sum adjacent terms. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
615 for (octave_idx_type i = ci[j]; i < ci[j+1]; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
616 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
617 octave_idx_type k = spairs[i].first; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
618 if (k != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
619 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
620 l = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
621 rrd[++jj] = a(spairs[i].second); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
622 rri[jj] = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
623 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
624 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
625 rrd[jj] += a(spairs[i].second); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
626 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
627 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
628 else |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
629 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
630 // Use the last one. |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
631 for (octave_idx_type i = ci[j]; i < ci[j+1]; i++) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
632 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
633 octave_idx_type k = spairs[i].first; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
634 if (k != l) |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
635 { |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
636 l = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
637 rri[++jj] = k; |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
638 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
639 rrd[jj] = a(spairs[i].second); |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
640 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
641 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
642 } |
10509
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
643 |
ddbd812d09aa
properly compress sparse matrices after assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10506
diff
changeset
|
644 maybe_compress (true); |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
645 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
646 } |
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10468
diff
changeset
|
647 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
648 template <typename T> |
5164 | 649 Sparse<T>::Sparse (const Array<T>& a) |
11508
41866901ec62
Sparse.cc: more constructor fixes
John W. Eaton <jwe@octave.org>
parents:
11311
diff
changeset
|
650 : rep (0), dimensions (a.dims ()) |
5164 | 651 { |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
652 if (dimensions.ndims () > 2) |
5164 | 653 (*current_liboctave_error_handler) |
654 ("Sparse::Sparse (const Array<T>&): dimension mismatch"); | |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
655 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
656 octave_idx_type nr = rows (); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
657 octave_idx_type nc = cols (); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
658 octave_idx_type len = a.numel (); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
659 octave_idx_type new_nzmx = 0; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
660 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
661 // First count the number of nonzero terms |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
662 for (octave_idx_type i = 0; i < len; i++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
663 if (a(i) != T ()) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
664 new_nzmx++; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
665 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
666 rep = new typename Sparse<T>::SparseRep (nr, nc, new_nzmx); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
667 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
668 octave_idx_type ii = 0; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
669 xcidx (0) = 0; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
670 for (octave_idx_type j = 0; j < nc; j++) |
5164 | 671 { |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
672 for (octave_idx_type i = 0; i < nr; i++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
673 if (a.elem (i,j) != T ()) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
674 { |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
675 xdata (ii) = a.elem (i,j); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
676 xridx (ii++) = i; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
677 } |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
678 xcidx (j+1) = ii; |
5164 | 679 } |
680 } | |
681 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
682 template <typename T> |
5164 | 683 Sparse<T>::~Sparse (void) |
684 { | |
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
13841
diff
changeset
|
685 if (--rep->count == 0) |
5164 | 686 delete rep; |
687 } | |
688 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
689 template <typename T> |
7717
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
690 Sparse<T>& |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
691 Sparse<T>::operator = (const Sparse<T>& a) |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
692 { |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
693 if (this != &a) |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
694 { |
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
13841
diff
changeset
|
695 if (--rep->count == 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
696 delete rep; |
7717
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
697 |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
698 rep = a.rep; |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
699 rep->count++; |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
700 |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
701 dimensions = a.dimensions; |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
702 } |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
703 |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
704 return *this; |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
705 } |
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
706 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
707 template <typename T> |
5275 | 708 octave_idx_type |
709 Sparse<T>::compute_index (const Array<octave_idx_type>& ra_idx) const | |
5164 | 710 { |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
711 octave_idx_type n = dimensions.ndims (); |
5164 | 712 |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
713 if (n <= 0 || n != ra_idx.numel ()) |
5164 | 714 (*current_liboctave_error_handler) |
715 ("Sparse<T>::compute_index: invalid ra_idxing operation"); | |
716 | |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
717 octave_idx_type retval = -1; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
718 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
719 retval = ra_idx(--n); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
720 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
721 while (--n >= 0) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
722 { |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
723 retval *= dimensions(n); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
724 retval += ra_idx(n); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
725 } |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
726 |
5164 | 727 return retval; |
728 } | |
729 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
730 template <typename T> |
5164 | 731 T |
5275 | 732 Sparse<T>::range_error (const char *fcn, octave_idx_type n) const |
5164 | 733 { |
734 (*current_liboctave_error_handler) ("%s (%d): range error", fcn, n); | |
735 } | |
736 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
737 template <typename T> |
5164 | 738 T& |
5275 | 739 Sparse<T>::range_error (const char *fcn, octave_idx_type n) |
5164 | 740 { |
741 (*current_liboctave_error_handler) ("%s (%d): range error", fcn, n); | |
742 } | |
743 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
744 template <typename T> |
5164 | 745 T |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
746 Sparse<T>::range_error (const char *fcn, octave_idx_type i, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
747 octave_idx_type j) const |
5164 | 748 { |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
749 (*current_liboctave_error_handler) ("%s (%d, %d): range error", fcn, i, j); |
5164 | 750 } |
751 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
752 template <typename T> |
5164 | 753 T& |
5275 | 754 Sparse<T>::range_error (const char *fcn, octave_idx_type i, octave_idx_type j) |
5164 | 755 { |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
756 (*current_liboctave_error_handler) ("%s (%d, %d): range error", fcn, i, j); |
5164 | 757 } |
758 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
759 template <typename T> |
5164 | 760 T |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
761 Sparse<T>::range_error (const char *fcn, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
762 const Array<octave_idx_type>& ra_idx) const |
5164 | 763 { |
5765 | 764 std::ostringstream buf; |
5164 | 765 |
766 buf << fcn << " ("; | |
767 | |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20229
diff
changeset
|
768 octave_idx_type n = ra_idx.numel (); |
5164 | 769 |
770 if (n > 0) | |
771 buf << ra_idx(0); | |
772 | |
5275 | 773 for (octave_idx_type i = 1; i < n; i++) |
5164 | 774 buf << ", " << ra_idx(i); |
775 | |
776 buf << "): range error"; | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
777 |
5765 | 778 std::string buf_str = buf.str (); |
779 | |
780 (*current_liboctave_error_handler) (buf_str.c_str ()); | |
5164 | 781 } |
782 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
783 template <typename T> |
5164 | 784 T& |
5275 | 785 Sparse<T>::range_error (const char *fcn, const Array<octave_idx_type>& ra_idx) |
5164 | 786 { |
5765 | 787 std::ostringstream buf; |
5164 | 788 |
789 buf << fcn << " ("; | |
790 | |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20229
diff
changeset
|
791 octave_idx_type n = ra_idx.numel (); |
5164 | 792 |
793 if (n > 0) | |
794 buf << ra_idx(0); | |
795 | |
5275 | 796 for (octave_idx_type i = 1; i < n; i++) |
5164 | 797 buf << ", " << ra_idx(i); |
798 | |
799 buf << "): range error"; | |
800 | |
5765 | 801 std::string buf_str = buf.str (); |
802 | |
803 (*current_liboctave_error_handler) (buf_str.c_str ()); | |
5164 | 804 } |
805 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
806 template <typename T> |
5164 | 807 Sparse<T> |
808 Sparse<T>::reshape (const dim_vector& new_dims) const | |
809 { | |
810 Sparse<T> retval; | |
6689 | 811 dim_vector dims2 = new_dims; |
812 | |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
813 if (dims2.ndims () > 2) |
5164 | 814 { |
19410
95c533ed464b
use warning IDs for all warnings in liboctave
John W. Eaton <jwe@octave.org>
parents:
19381
diff
changeset
|
815 (*current_liboctave_warning_with_id_handler) |
95c533ed464b
use warning IDs for all warnings in liboctave
John W. Eaton <jwe@octave.org>
parents:
19381
diff
changeset
|
816 ("Octave:reshape-smashes-dims", |
21014
b9d4c3615e89
maint: Capitalize D for dimension in messages and comments.
Rik <rik@octave.org>
parents:
20673
diff
changeset
|
817 "reshape: sparse reshape to N-D array smashes dims"); |
6814 | 818 |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
819 for (octave_idx_type i = 2; i < dims2.ndims (); i++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
820 dims2(1) *= dims2(i); |
6814 | 821 |
6689 | 822 dims2.resize (2); |
823 } | |
824 | |
825 if (dimensions != dims2) | |
826 { | |
827 if (dimensions.numel () == dims2.numel ()) | |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
828 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
829 octave_idx_type new_nnz = nnz (); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
830 octave_idx_type new_nr = dims2 (0); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
831 octave_idx_type new_nc = dims2 (1); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
832 octave_idx_type old_nr = rows (); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
833 octave_idx_type old_nc = cols (); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
834 retval = Sparse<T> (new_nr, new_nc, new_nnz); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
835 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
836 octave_idx_type kk = 0; |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
837 retval.xcidx (0) = 0; |
21562
6c2fd62db1f7
maint: Eliminate accidental double spaces in code.
Rik <rik@octave.org>
parents:
21337
diff
changeset
|
838 // Quotient and remainder of i * old_nr divided by new_nr. |
21256
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
839 // Track them individually to avoid overflow (bug #42850). |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
840 octave_idx_type i_old_qu = 0; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
841 octave_idx_type i_old_rm = static_cast<octave_idx_type> (-old_nr); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
842 for (octave_idx_type i = 0; i < old_nc; i++) |
21256
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
843 { |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
844 i_old_rm += old_nr; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
845 if (i_old_rm >= new_nr) |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
846 { |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
847 i_old_qu += i_old_rm / new_nr; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
848 i_old_rm = i_old_rm % new_nr; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
849 } |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
850 for (octave_idx_type j = cidx (i); j < cidx (i+1); j++) |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
851 { |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
852 octave_idx_type ii, jj; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
853 ii = (i_old_rm + ridx (j)) % new_nr; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
854 jj = i_old_qu + (i_old_rm + ridx (j)) / new_nr; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
855 |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
856 // Original calculation subject to overflow |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
857 // ii = (i*old_nr + ridx (j)) % new_nr |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
858 // jj = (i*old_nr + ridx (j)) / new_nr |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
859 |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
860 for (octave_idx_type k = kk; k < jj; k++) |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
861 retval.xcidx (k+1) = j; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
862 kk = jj; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
863 retval.xdata (j) = data (j); |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
864 retval.xridx (j) = ii; |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
865 } |
a93fa1b0796e
Avoid overflow while reshaping large sparse matrices (bug #42850).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21255
diff
changeset
|
866 } |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
867 for (octave_idx_type k = kk; k < new_nc; k++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
868 retval.xcidx (k+1) = new_nnz; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
869 } |
5164 | 870 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
871 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
872 std::string dimensions_str = dimensions.str (); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
873 std::string new_dims_str = new_dims.str (); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
874 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
875 (*current_liboctave_error_handler) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
876 ("reshape: can't reshape %s array to %s array", |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
877 dimensions_str.c_str (), new_dims_str.c_str ()); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
878 } |
5164 | 879 } |
880 else | |
881 retval = *this; | |
882 | |
883 return retval; | |
884 } | |
885 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
886 template <typename T> |
5164 | 887 Sparse<T> |
5275 | 888 Sparse<T>::permute (const Array<octave_idx_type>& perm_vec, bool) const |
5164 | 889 { |
6813 | 890 // The only valid permutations of a sparse array are [1, 2] and [2, 1]. |
891 | |
892 bool fail = false; | |
6817 | 893 bool trans = false; |
6813 | 894 |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20229
diff
changeset
|
895 if (perm_vec.numel () == 2) |
5164 | 896 { |
6813 | 897 if (perm_vec(0) == 0 && perm_vec(1) == 1) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
898 /* do nothing */; |
6813 | 899 else if (perm_vec(0) == 1 && perm_vec(1) == 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
900 trans = true; |
5164 | 901 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
902 fail = true; |
5164 | 903 } |
904 else | |
6813 | 905 fail = true; |
906 | |
907 if (fail) | |
908 (*current_liboctave_error_handler) | |
909 ("permutation vector contains an invalid element"); | |
910 | |
6817 | 911 return trans ? this->transpose () : *this; |
5164 | 912 } |
913 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
914 template <typename T> |
5164 | 915 void |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
916 Sparse<T>::resize1 (octave_idx_type n) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
917 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
918 octave_idx_type nr = rows (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
919 octave_idx_type nc = cols (); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
920 |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
921 if (nr == 0) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
922 resize (1, std::max (nc, n)); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
923 else if (nc == 0) |
10520
72c90e7132a9
fix failing sparse assignment tests
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
924 resize (nr, (n + nr - 1) / nr); // Ain't it wicked? |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
925 else if (nr == 1) |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
926 resize (1, n); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
927 else if (nc == 1) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
928 resize (n, 1); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
929 else |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
930 octave::err_invalid_resize (); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
931 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
932 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
933 template <typename T> |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
934 void |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
935 Sparse<T>::resize (const dim_vector& dv) |
5164 | 936 { |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
937 octave_idx_type n = dv.ndims (); |
5164 | 938 |
939 if (n != 2) | |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
940 (*current_liboctave_error_handler) ("sparse array must be 2-D"); |
5164 | 941 |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
942 resize (dv(0), dv(1)); |
5164 | 943 } |
944 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
945 template <typename T> |
5164 | 946 void |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
947 Sparse<T>::resize (octave_idx_type r, octave_idx_type c) |
5164 | 948 { |
949 if (r < 0 || c < 0) | |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
950 (*current_liboctave_error_handler) ("can't resize to negative dimension"); |
5164 | 951 |
952 if (r == dim1 () && c == dim2 ()) | |
953 return; | |
954 | |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
955 // This wouldn't be necessary for r >= rows () if nrows wasn't part of the |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
956 // Sparse rep. It is not good for anything in there. |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
957 make_unique (); |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
958 |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
959 if (r < rows ()) |
5164 | 960 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
961 octave_idx_type i = 0; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
962 octave_idx_type k = 0; |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
963 for (octave_idx_type j = 1; j <= rep->ncols; j++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
964 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
965 octave_idx_type u = xcidx (j); |
21337
cfe11042fbc0
eliminate useless assignment in for loop
John W. Eaton <jwe@octave.org>
parents:
21301
diff
changeset
|
966 for (; i < u; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
967 if (xridx (i) < r) |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
968 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
969 xdata (k) = xdata (i); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
970 xridx (k++) = xridx (i); |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
971 } |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
972 xcidx (j) = k; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
973 } |
5164 | 974 } |
975 | |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
976 rep->nrows = dimensions(0) = r; |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
977 |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
978 if (c != rep->ncols) |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
979 { |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
980 octave_idx_type *new_cidx = new octave_idx_type [c+1]; |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
981 std::copy_n (rep->c, std::min (c, rep->ncols) + 1, new_cidx); |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
982 delete [] rep->c; |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
983 rep->c = new_cidx; |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
984 |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
985 if (c > rep->ncols) |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
986 std::fill_n (rep->c + rep->ncols + 1, c - rep->ncols, |
19861
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
987 rep->c[rep->ncols]); |
10499
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
988 } |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
989 |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
990 rep->ncols = dimensions(1) = c; |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
991 |
fabed15083a4
optimize sparse resize
Jaroslav Hajek <highegg@gmail.com>
parents:
10497
diff
changeset
|
992 rep->change_length (rep->nnz ()); |
5164 | 993 } |
994 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
995 template <typename T> |
5164 | 996 Sparse<T>& |
5275 | 997 Sparse<T>::insert (const Sparse<T>& a, octave_idx_type r, octave_idx_type c) |
5164 | 998 { |
5275 | 999 octave_idx_type a_rows = a.rows (); |
1000 octave_idx_type a_cols = a.cols (); | |
1001 octave_idx_type nr = rows (); | |
1002 octave_idx_type nc = cols (); | |
5164 | 1003 |
1004 if (r < 0 || r + a_rows > rows () || c < 0 || c + a_cols > cols ()) | |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
1005 (*current_liboctave_error_handler) ("range error for insert"); |
5164 | 1006 |
1007 // First count the number of elements in the final array | |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1008 octave_idx_type nel = cidx (c) + a.nnz (); |
5164 | 1009 |
1010 if (c + a_cols < nc) | |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1011 nel += cidx (nc) - cidx (c + a_cols); |
5164 | 1012 |
5275 | 1013 for (octave_idx_type i = c; i < c + a_cols; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1014 for (octave_idx_type j = cidx (i); j < cidx (i+1); j++) |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1015 if (ridx (j) < r || ridx (j) >= r + a_rows) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1016 nel++; |
5164 | 1017 |
1018 Sparse<T> tmp (*this); | |
1019 --rep->count; | |
1020 rep = new typename Sparse<T>::SparseRep (nr, nc, nel); | |
1021 | |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1022 for (octave_idx_type i = 0; i < tmp.cidx (c); i++) |
5164 | 1023 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1024 data (i) = tmp.data (i); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1025 ridx (i) = tmp.ridx (i); |
5164 | 1026 } |
5275 | 1027 for (octave_idx_type i = 0; i < c + 1; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1028 cidx (i) = tmp.cidx (i); |
5164 | 1029 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1030 octave_idx_type ii = cidx (c); |
5275 | 1031 |
1032 for (octave_idx_type i = c; i < c + a_cols; i++) | |
5164 | 1033 { |
10142
829e69ec3110
make OCTAVE_QUIT a function
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
1034 octave_quit (); |
5164 | 1035 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1036 for (octave_idx_type j = tmp.cidx (i); j < tmp.cidx (i+1); j++) |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1037 if (tmp.ridx (j) < r) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1038 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1039 data (ii) = tmp.data (j); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1040 ridx (ii++) = tmp.ridx (j); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1041 } |
5164 | 1042 |
10142
829e69ec3110
make OCTAVE_QUIT a function
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
1043 octave_quit (); |
5164 | 1044 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1045 for (octave_idx_type j = a.cidx (i-c); j < a.cidx (i-c+1); j++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1046 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1047 data (ii) = a.data (j); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1048 ridx (ii++) = r + a.ridx (j); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1049 } |
5164 | 1050 |
10142
829e69ec3110
make OCTAVE_QUIT a function
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
1051 octave_quit (); |
5164 | 1052 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1053 for (octave_idx_type j = tmp.cidx (i); j < tmp.cidx (i+1); j++) |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1054 if (tmp.ridx (j) >= r + a_rows) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1055 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1056 data (ii) = tmp.data (j); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1057 ridx (ii++) = tmp.ridx (j); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1058 } |
5164 | 1059 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1060 cidx (i+1) = ii; |
5164 | 1061 } |
1062 | |
5275 | 1063 for (octave_idx_type i = c + a_cols; i < nc; i++) |
5164 | 1064 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1065 for (octave_idx_type j = tmp.cidx (i); j < tmp.cidx (i+1); j++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1066 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1067 data (ii) = tmp.data (j); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1068 ridx (ii++) = tmp.ridx (j); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1069 } |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1070 cidx (i+1) = ii; |
5164 | 1071 } |
1072 | |
1073 return *this; | |
1074 } | |
1075 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1076 template <typename T> |
5164 | 1077 Sparse<T>& |
5275 | 1078 Sparse<T>::insert (const Sparse<T>& a, const Array<octave_idx_type>& ra_idx) |
5164 | 1079 { |
1080 | |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20229
diff
changeset
|
1081 if (ra_idx.numel () != 2) |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
1082 (*current_liboctave_error_handler) ("range error for insert"); |
5164 | 1083 |
20218
b2100e1659ac
maint: Use cuddled parentheses when indexing dimension_vectors.
Rik <rik@octave.org>
parents:
19861
diff
changeset
|
1084 return insert (a, ra_idx(0), ra_idx(1)); |
5164 | 1085 } |
1086 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1087 template <typename T> |
5164 | 1088 Sparse<T> |
1089 Sparse<T>::transpose (void) const | |
1090 { | |
1091 assert (ndims () == 2); | |
1092 | |
5275 | 1093 octave_idx_type nr = rows (); |
1094 octave_idx_type nc = cols (); | |
5648 | 1095 octave_idx_type nz = nnz (); |
5164 | 1096 Sparse<T> retval (nc, nr, nz); |
1097 | |
5648 | 1098 for (octave_idx_type i = 0; i < nz; i++) |
8987
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1099 retval.xcidx (ridx (i) + 1)++; |
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1100 // retval.xcidx[1:nr] holds the row degrees for rows 0:(nr-1) |
5648 | 1101 nz = 0; |
8987
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1102 for (octave_idx_type i = 1; i <= nr; i++) |
5164 | 1103 { |
8987
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1104 const octave_idx_type tmp = retval.xcidx (i); |
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1105 retval.xcidx (i) = nz; |
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1106 nz += tmp; |
5164 | 1107 } |
8987
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1108 // retval.xcidx[1:nr] holds row entry *start* offsets for rows 0:(nr-1) |
5648 | 1109 |
1110 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
|
1111 for (octave_idx_type k = cidx (j); k < cidx (j+1); k++) |
5648 | 1112 { |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1113 octave_idx_type q = retval.xcidx (ridx (k) + 1)++; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1114 retval.xridx (q) = j; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1115 retval.xdata (q) = data (k); |
5648 | 1116 } |
8987
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1117 assert (nnz () == retval.xcidx (nr)); |
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1118 // retval.xcidx[1:nr] holds row entry *end* offsets for rows 0:(nr-1) |
542015fada9e
Eliminate the workspace in sparse transpose.
Jason Riedy <jason@acm.org>
parents:
8920
diff
changeset
|
1119 // and retval.xcidx[0:(nr-1)] holds their row entry *start* offsets |
5164 | 1120 |
1121 return retval; | |
1122 } | |
1123 | |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1124 // Lower bound lookup. Could also use octave_sort, but that has upper bound |
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1125 // semantics, so requires some manipulation to set right. Uses a plain loop |
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1126 // for small columns. |
10493
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1127 static octave_idx_type |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1128 lblookup (const octave_idx_type *ridx, octave_idx_type nr, |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1129 octave_idx_type ri) |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1130 { |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1131 if (nr <= 8) |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1132 { |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1133 octave_idx_type l; |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1134 for (l = 0; l < nr; l++) |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1135 if (ridx[l] >= ri) |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1136 break; |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1137 return l; |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1138 } |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1139 else |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1140 return std::lower_bound (ridx, ridx + nr, ri) - ridx; |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1141 } |
2f8bacc2a57d
fix order of func defs in Sparse.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
10490
diff
changeset
|
1142 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1143 template <typename T> |
5164 | 1144 void |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1145 Sparse<T>::delete_elements (const idx_vector& idx) |
5164 | 1146 { |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1147 Sparse<T> retval; |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1148 |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1149 assert (ndims () == 2); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1150 |
5275 | 1151 octave_idx_type nr = dim1 (); |
1152 octave_idx_type nc = dim2 (); | |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1153 octave_idx_type nz = nnz (); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1154 |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1155 octave_idx_type nel = numel (); // Can throw. |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1156 |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1157 const dim_vector idx_dims = idx.orig_dimensions (); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1158 |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1159 if (idx.extent (nel) > nel) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
1160 octave::err_del_index_out_of_range (true, idx.extent (nel), nel); |
21120
499b851fbfae
Replace pattern if/err_XXX/else/code with if/err_XXX/ code.
Rik <rik@octave.org>
parents:
21118
diff
changeset
|
1161 |
499b851fbfae
Replace pattern if/err_XXX/else/code with if/err_XXX/ code.
Rik <rik@octave.org>
parents:
21118
diff
changeset
|
1162 if (nc == 1) |
5164 | 1163 { |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1164 // Sparse column vector. |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1165 const Sparse<T> tmp = *this; // constant copy to prevent COW. |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1166 |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1167 octave_idx_type lb, ub; |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1168 |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1169 if (idx.is_cont_range (nel, lb, ub)) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1170 { |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1171 // Special-case a contiguous range. |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1172 // Look-up indices first. |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1173 octave_idx_type li = lblookup (tmp.ridx (), nz, lb); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1174 octave_idx_type ui = lblookup (tmp.ridx (), nz, ub); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1175 // Copy data and adjust indices. |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1176 octave_idx_type nz_new = nz - (ui - li); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1177 *this = Sparse<T> (nr - (ub - lb), 1, nz_new); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1178 std::copy_n (tmp.data (), li, data ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1179 std::copy_n (tmp.ridx (), li, xridx ()); |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1180 std::copy (tmp.data () + ui, tmp.data () + nz, xdata () + li); |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1181 mx_inline_sub (nz - ui, xridx () + li, tmp.ridx () + ui, ub - lb); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1182 xcidx (1) = nz_new; |
10382
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1183 } |
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1184 else |
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1185 { |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1186 OCTAVE_LOCAL_BUFFER (octave_idx_type, ridx_new, nz); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1187 OCTAVE_LOCAL_BUFFER (T, data_new, nz); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1188 idx_vector sidx = idx.sorted (true); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1189 const octave_idx_type *sj = sidx.raw (); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1190 octave_idx_type sl = sidx.length (nel); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1191 octave_idx_type nz_new = 0; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1192 octave_idx_type j = 0; |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1193 for (octave_idx_type i = 0; i < nz; i++) |
10382
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1194 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1195 octave_idx_type r = tmp.ridx (i); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1196 for (; j < sl && sj[j] < r; j++) ; |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1197 if (j == sl || sj[j] > r) |
10382
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1198 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1199 data_new[nz_new] = tmp.data (i); |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1200 ridx_new[nz_new++] = r - j; |
10382
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1201 } |
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1202 } |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1203 |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1204 *this = Sparse<T> (nr - sl, 1, nz_new); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1205 std::copy_n (ridx_new, nz_new, ridx ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1206 std::copy_n (data_new, nz_new, xdata ()); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1207 xcidx (1) = nz_new; |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1208 } |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1209 } |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1210 else if (nr == 1) |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1211 { |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1212 // Sparse row vector. |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1213 octave_idx_type lb, ub; |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1214 if (idx.is_cont_range (nc, lb, ub)) |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1215 { |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1216 const Sparse<T> tmp = *this; |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1217 octave_idx_type lbi = tmp.cidx (lb); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1218 octave_idx_type ubi = tmp.cidx (ub); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1219 octave_idx_type new_nz = nz - (ubi - lbi); |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1220 *this = Sparse<T> (1, nc - (ub - lb), new_nz); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1221 std::copy_n (tmp.data (), lbi, data ()); |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1222 std::copy (tmp.data () + ubi, tmp.data () + nz , xdata () + lbi); |
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1223 std::fill_n (ridx (), new_nz, static_cast<octave_idx_type> (0)); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1224 std::copy_n (tmp.cidx () + 1, lb, cidx () + 1); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1225 mx_inline_sub (nc - ub, xcidx () + 1, tmp.cidx () + ub + 1, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1226 ubi - lbi); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1227 } |
5164 | 1228 else |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1229 *this = index (idx.complement (nc)); |
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1230 } |
17642
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1231 else if (idx.length (nel) != 0) |
10484
6a9571b57745
rewrite sparse null assignment (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10480
diff
changeset
|
1232 { |
17642
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1233 if (idx.is_colon_equiv (nel)) |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1234 *this = Sparse<T> (); |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1235 else |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1236 { |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1237 *this = index (idx_vector::colon); |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1238 delete_elements (idx); |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1239 *this = transpose (); // We want a row vector. |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1240 } |
5164 | 1241 } |
1242 } | |
1243 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1244 template <typename T> |
5164 | 1245 void |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1246 Sparse<T>::delete_elements (const idx_vector& idx_i, const idx_vector& idx_j) |
5164 | 1247 { |
1248 assert (ndims () == 2); | |
1249 | |
5275 | 1250 octave_idx_type nr = dim1 (); |
1251 octave_idx_type nc = dim2 (); | |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1252 octave_idx_type nz = nnz (); |
5164 | 1253 |
1254 if (idx_i.is_colon ()) | |
1255 { | |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1256 // Deleting columns. |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1257 octave_idx_type lb, ub; |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1258 if (idx_j.extent (nc) > nc) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
1259 octave::err_del_index_out_of_range (false, idx_j.extent (nc), nc); |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1260 else if (idx_j.is_cont_range (nc, lb, ub)) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1261 { |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1262 if (lb == 0 && ub == nc) |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1263 { |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1264 // Delete all rows and columns. |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1265 *this = Sparse<T> (nr, 0); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1266 } |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1267 else if (nz == 0) |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1268 { |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1269 // No elements to preserve; adjust dimensions. |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1270 *this = Sparse<T> (nr, nc - (ub - lb)); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1271 } |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1272 else |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1273 { |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1274 const Sparse<T> tmp = *this; |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1275 octave_idx_type lbi = tmp.cidx (lb); |
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1276 octave_idx_type ubi = tmp.cidx (ub); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1277 octave_idx_type new_nz = nz - (ubi - lbi); |
14792
8483286c0a13
Update Sparse sources to GNU standards (whitespace changes only)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
14791
diff
changeset
|
1278 |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1279 *this = Sparse<T> (nr, nc - (ub - lb), new_nz); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1280 std::copy_n (tmp.data (), lbi, data ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1281 std::copy_n (tmp.ridx (), lbi, ridx ()); |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1282 std::copy (tmp.data () + ubi, tmp.data () + nz, xdata () + lbi); |
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1283 std::copy (tmp.ridx () + ubi, tmp.ridx () + nz, xridx () + lbi); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1284 std::copy_n (tmp.cidx () + 1, lb, cidx () + 1); |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1285 mx_inline_sub (nc - ub, xcidx () + lb + 1, |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1286 tmp.cidx () + ub + 1, ubi - lbi); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1287 } |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1288 } |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1289 else |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1290 *this = index (idx_i, idx_j.complement (nc)); |
5164 | 1291 } |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1292 else if (idx_j.is_colon ()) |
5164 | 1293 { |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1294 // Deleting rows. |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1295 octave_idx_type lb, ub; |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1296 if (idx_i.extent (nr) > nr) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
1297 octave::err_del_index_out_of_range (false, idx_i.extent (nr), nr); |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1298 else if (idx_i.is_cont_range (nr, lb, ub)) |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1299 { |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1300 if (lb == 0 && ub == nr) |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1301 { |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1302 // Delete all rows and columns. |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1303 *this = Sparse<T> (0, nc); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1304 } |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1305 else if (nz == 0) |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1306 { |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1307 // No elements to preserve; adjust dimensions. |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1308 *this = Sparse<T> (nr - (ub - lb), nc); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1309 } |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1310 else |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1311 { |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1312 // This is more memory-efficient than the approach below. |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1313 const Sparse<T> tmpl = index (idx_vector (0, lb), idx_j); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1314 const Sparse<T> tmpu = index (idx_vector (ub, nr), idx_j); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1315 *this = Sparse<T> (nr - (ub - lb), nc, |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1316 tmpl.nnz () + tmpu.nnz ()); |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1317 for (octave_idx_type j = 0, k = 0; j < nc; j++) |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1318 { |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1319 for (octave_idx_type i = tmpl.cidx (j); i < tmpl.cidx (j+1); |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1320 i++) |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1321 { |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1322 xdata (k) = tmpl.data (i); |
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1323 xridx (k++) = tmpl.ridx (i); |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1324 } |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1325 for (octave_idx_type i = tmpu.cidx (j); i < tmpu.cidx (j+1); |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1326 i++) |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1327 { |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1328 xdata (k) = tmpu.data (i); |
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1329 xridx (k++) = tmpu.ridx (i) + lb; |
14794
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1330 } |
41dcb2c5bb1a
Special-case removing rows or columns from empty sparse matrices
John W. Eaton <jwe@octave.org>
parents:
14792
diff
changeset
|
1331 |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17823
diff
changeset
|
1332 xcidx (j+1) = k; |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1333 } |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1334 } |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1335 } |
5164 | 1336 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1337 { |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1338 // This is done by transposing, deleting columns, then transposing |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1339 // again. |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1340 Sparse<T> tmp = transpose (); |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1341 tmp.delete_elements (idx_j, idx_i); |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1342 *this = tmp.transpose (); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1343 } |
5164 | 1344 } |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1345 else |
17642
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1346 { |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1347 // Empty assignment (no elements to delete) is OK if there is at |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1348 // least one zero-length index and at most one other index that is |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1349 // non-colon (or equivalent) index. Since we only have two |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1350 // indices, we just need to check that we have at least one zero |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1351 // length index. Matlab considers "[]" to be an empty index but |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1352 // not "false". We accept both. |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1353 |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1354 bool empty_assignment |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1355 = (idx_i.length (nr) == 0 || idx_j.length (nc) == 0); |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1356 |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1357 if (! empty_assignment) |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1358 (*current_liboctave_error_handler) |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1359 ("a null assignment can only have one non-colon index"); |
7ed397c8ca68
improve compatibility of null assignment (bug #31287)
John W. Eaton <jwe@octave.org>
parents:
17285
diff
changeset
|
1360 } |
5164 | 1361 } |
1362 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1363 template <typename T> |
5164 | 1364 void |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1365 Sparse<T>::delete_elements (int dim, const idx_vector& idx) |
5164 | 1366 { |
10490
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1367 if (dim == 0) |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1368 delete_elements (idx, idx_vector::colon); |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1369 else if (dim == 1) |
fdccd69d26bd
rewrite sparse null assignment (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10484
diff
changeset
|
1370 delete_elements (idx_vector::colon, idx); |
5164 | 1371 else |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
1372 (*current_liboctave_error_handler) ("invalid dimension in delete_elements"); |
5164 | 1373 } |
1374 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1375 template <typename T> |
5164 | 1376 Sparse<T> |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1377 Sparse<T>::index (const idx_vector& idx, bool resize_ok) const |
5164 | 1378 { |
1379 Sparse<T> retval; | |
1380 | |
1381 assert (ndims () == 2); | |
1382 | |
5275 | 1383 octave_idx_type nr = dim1 (); |
1384 octave_idx_type nc = dim2 (); | |
5681 | 1385 octave_idx_type nz = nnz (); |
5275 | 1386 |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1387 octave_idx_type nel = numel (); // Can throw. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1388 |
19413
e354372e20f2
allow sparse arrays to be indexed by N-d arrays (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19410
diff
changeset
|
1389 const dim_vector idx_dims = idx.orig_dimensions ().redim (2); |
e354372e20f2
allow sparse arrays to be indexed by N-d arrays (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19410
diff
changeset
|
1390 |
e354372e20f2
allow sparse arrays to be indexed by N-d arrays (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19410
diff
changeset
|
1391 if (idx.is_colon ()) |
5164 | 1392 { |
10494
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1393 if (nc == 1) |
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1394 retval = *this; |
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1395 else |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1396 { |
10494
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1397 // Fast magic colon processing. |
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1398 retval = Sparse<T> (nel, 1, nz); |
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1399 |
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1400 for (octave_idx_type i = 0; i < nc; i++) |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1401 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1402 for (octave_idx_type j = cidx (i); j < cidx (i+1); j++) |
10494
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1403 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1404 retval.xdata (j) = data (j); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1405 retval.xridx (j) = ridx (j) + i * nr; |
10494
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1406 } |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1407 } |
10494
e52f41fd82c7
optimize (:) indexing of sparse column vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10493
diff
changeset
|
1408 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1409 retval.xcidx (0) = 0; |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1410 retval.xcidx (1) = nz; |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1411 } |
5164 | 1412 } |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1413 else if (idx.extent (nel) > nel) |
10421
99e9bae2d81e
improve sparse indexing interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10382
diff
changeset
|
1414 { |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1415 if (! resize_ok) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
1416 octave::err_index_out_of_range (1, 1, idx.extent (nel), nel, dims ()); |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1417 |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1418 // resize_ok is completely handled here. |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1419 octave_idx_type ext = idx.extent (nel); |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1420 Sparse<T> tmp = *this; |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1421 tmp.resize1 (ext); |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1422 retval = tmp.index (idx); |
10421
99e9bae2d81e
improve sparse indexing interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10382
diff
changeset
|
1423 } |
5164 | 1424 else if (nr == 1 && nc == 1) |
1425 { | |
1426 // You have to be pretty sick to get to this bit of code, | |
1427 // since you have a scalar stored as a sparse matrix, and | |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1428 // then want to make a dense matrix with sparse representation. |
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1429 // Ok, we'll do it, but you deserve what you get!! |
23450
855122b993da
maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents:
23448
diff
changeset
|
1430 retval = (Sparse<T> (idx_dims(0), idx_dims(1), nz ? data (0) : T ())); |
5164 | 1431 } |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1432 else if (nc == 1) |
5164 | 1433 { |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1434 // Sparse column vector. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1435 octave_idx_type lb, ub; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1436 |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1437 if (idx.is_scalar ()) |
10382
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1438 { |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1439 // Scalar index - just a binary lookup. |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1440 octave_idx_type i = lblookup (ridx (), nz, idx(0)); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1441 if (i < nz && ridx (i) == idx(0)) |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1442 retval = Sparse (1, 1, data (i)); |
10382
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1443 else |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1444 retval = Sparse (1, 1); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1445 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1446 else if (idx.is_cont_range (nel, lb, ub)) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1447 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1448 // Special-case a contiguous range. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1449 // Look-up indices first. |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1450 octave_idx_type li = lblookup (ridx (), nz, lb); |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1451 octave_idx_type ui = lblookup (ridx (), nz, ub); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1452 // Copy data and adjust indices. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1453 octave_idx_type nz_new = ui - li; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1454 retval = Sparse<T> (ub - lb, 1, nz_new); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1455 std::copy_n (data () + li, nz_new, retval.data ()); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1456 mx_inline_sub (nz_new, retval.xridx (), ridx () + li, lb); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1457 retval.xcidx (1) = nz_new; |
10382
1766c133674c
Special case sparse index method for ranges and maybe_delete_elements method for sparse vectors
David Bateman <dbateman@free.fr>
parents:
10367
diff
changeset
|
1458 } |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1459 else if (idx.is_permutation (nel) && idx.is_vector ()) |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1460 { |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1461 if (idx.is_range () && idx.increment () == -1) |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1462 { |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1463 retval = Sparse<T> (nr, 1, nz); |
14433
ec660526ae50
Fix sparse range indexing bug (bug #35570)
Marco Caliari <marco.caliari@univr.it>
parents:
14138
diff
changeset
|
1464 |
ec660526ae50
Fix sparse range indexing bug (bug #35570)
Marco Caliari <marco.caliari@univr.it>
parents:
14138
diff
changeset
|
1465 for (octave_idx_type j = 0; j < nz; j++) |
ec660526ae50
Fix sparse range indexing bug (bug #35570)
Marco Caliari <marco.caliari@univr.it>
parents:
14138
diff
changeset
|
1466 retval.ridx (j) = nr - ridx (nz - j - 1) - 1; |
ec660526ae50
Fix sparse range indexing bug (bug #35570)
Marco Caliari <marco.caliari@univr.it>
parents:
14138
diff
changeset
|
1467 |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1468 std::copy_n (cidx (), 2, retval.cidx ()); |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1469 std::reverse_copy (data (), data () + nz, retval.data ()); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1470 } |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1471 else |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1472 { |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1473 Array<T> tmp = array_value (); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1474 tmp = tmp.index (idx); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1475 retval = Sparse<T> (tmp); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1476 } |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1477 } |
5164 | 1478 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1479 { |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1480 // If indexing a sparse column vector by a vector, the result is a |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1481 // sparse column vector, otherwise it inherits the shape of index. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1482 // Vector transpose is cheap, so do it right here. |
19416
06b23f224f52
fix problem with changeset e354372e20f2 (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19413
diff
changeset
|
1483 |
06b23f224f52
fix problem with changeset e354372e20f2 (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19413
diff
changeset
|
1484 Array<octave_idx_type> tmp_idx = idx.as_array ().as_matrix (); |
06b23f224f52
fix problem with changeset e354372e20f2 (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19413
diff
changeset
|
1485 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
1486 const Array<octave_idx_type> idxa = (idx_dims(0) == 1 |
19416
06b23f224f52
fix problem with changeset e354372e20f2 (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19413
diff
changeset
|
1487 ? tmp_idx.transpose () |
06b23f224f52
fix problem with changeset e354372e20f2 (bug #43855)
John W. Eaton <jwe@octave.org>
parents:
19413
diff
changeset
|
1488 : tmp_idx); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1489 |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1490 octave_idx_type new_nr = idxa.rows (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1491 octave_idx_type new_nc = idxa.cols (); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1492 |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1493 // Lookup. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1494 // FIXME: Could specialize for sorted idx? |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1495 NoAlias< Array<octave_idx_type> > lidx (dim_vector (new_nr, new_nc)); |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1496 for (octave_idx_type i = 0; i < new_nr*new_nc; i++) |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1497 lidx(i) = lblookup (ridx (), nz, idxa(i)); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1498 |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1499 // Count matches. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1500 retval = Sparse<T> (idxa.rows (), idxa.cols ()); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1501 for (octave_idx_type j = 0; j < new_nc; j++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1502 { |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1503 octave_idx_type nzj = 0; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1504 for (octave_idx_type i = 0; i < new_nr; i++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1505 { |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1506 octave_idx_type l = lidx(i, j); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1507 if (l < nz && ridx (l) == idxa(i, j)) |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1508 nzj++; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1509 else |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1510 lidx(i, j) = nz; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1511 } |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1512 retval.xcidx (j+1) = retval.xcidx (j) + nzj; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1513 } |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1514 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1515 retval.change_capacity (retval.xcidx (new_nc)); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
1516 |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1517 // Copy data and set row indices. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1518 octave_idx_type k = 0; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1519 for (octave_idx_type j = 0; j < new_nc; j++) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1520 for (octave_idx_type i = 0; i < new_nr; i++) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1521 { |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1522 octave_idx_type l = lidx(i, j); |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1523 if (l < nz) |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1524 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1525 retval.data (k) = data (l); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1526 retval.xridx (k++) = i; |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1527 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1528 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1529 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1530 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1531 else if (nr == 1) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1532 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1533 octave_idx_type lb, ub; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1534 if (idx.is_scalar ()) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1535 retval = Sparse<T> (1, 1, elem (0, idx(0))); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1536 else if (idx.is_cont_range (nel, lb, ub)) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1537 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1538 // Special-case a contiguous range. |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1539 octave_idx_type lbi = cidx (lb); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1540 octave_idx_type ubi = cidx (ub); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1541 octave_idx_type new_nz = ubi - lbi; |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1542 retval = Sparse<T> (1, ub - lb, new_nz); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1543 std::copy_n (data () + lbi, new_nz, retval.data ()); |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1544 std::fill_n (retval.ridx (), new_nz, static_cast<octave_idx_type> (0)); |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1545 mx_inline_sub (ub - lb + 1, retval.cidx (), cidx () + lb, lbi); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1546 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1547 else |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1548 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1549 // Sparse row vectors occupy O(nr) storage anyway, so let's just |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1550 // convert the matrix to full, index, and sparsify the result. |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1551 retval = Sparse<T> (array_value ().index (idx)); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1552 } |
5164 | 1553 } |
1554 else | |
1555 { | |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1556 if (nr != 0 && idx.is_scalar ()) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1557 retval = Sparse<T> (1, 1, elem (idx(0) % nr, idx(0) / nr)); |
10421
99e9bae2d81e
improve sparse indexing interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10382
diff
changeset
|
1558 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1559 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
1560 // Indexing a non-vector sparse matrix by linear indexing. |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1561 // I suppose this is rare (and it may easily overflow), so let's take |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1562 // the easy way, and reshape first to column vector, which is already |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1563 // handled above. |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1564 retval = index (idx_vector::colon).index (idx); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1565 // In this case we're supposed to always inherit the shape, but |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1566 // column(row) doesn't do it, so we'll do it instead. |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1567 if (idx_dims(0) == 1 && idx_dims(1) != 1) |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
1568 retval = retval.transpose (); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1569 } |
5164 | 1570 } |
1571 | |
1572 return retval; | |
1573 } | |
1574 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1575 template <typename T> |
5164 | 1576 Sparse<T> |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1577 Sparse<T>::index (const idx_vector& idx_i, const idx_vector& idx_j, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1578 bool resize_ok) const |
5164 | 1579 { |
1580 Sparse<T> retval; | |
1581 | |
1582 assert (ndims () == 2); | |
1583 | |
5275 | 1584 octave_idx_type nr = dim1 (); |
1585 octave_idx_type nc = dim2 (); | |
1586 | |
10421
99e9bae2d81e
improve sparse indexing interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10382
diff
changeset
|
1587 octave_idx_type n = idx_i.length (nr); |
99e9bae2d81e
improve sparse indexing interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10382
diff
changeset
|
1588 octave_idx_type m = idx_j.length (nc); |
99e9bae2d81e
improve sparse indexing interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10382
diff
changeset
|
1589 |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1590 octave_idx_type lb, ub; |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1591 |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1592 if (idx_i.extent (nr) > nr || idx_j.extent (nc) > nc) |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1593 { |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1594 // resize_ok is completely handled here. |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1595 if (resize_ok) |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1596 { |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1597 octave_idx_type ext_i = idx_i.extent (nr); |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1598 octave_idx_type ext_j = idx_j.extent (nc); |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1599 Sparse<T> tmp = *this; |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1600 tmp.resize (ext_i, ext_j); |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1601 retval = tmp.index (idx_i, idx_j); |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1602 } |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1603 else if (idx_i.extent (nr) > nr) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
1604 octave::err_index_out_of_range (2, 1, idx_i.extent (nr), nr, dims ()); |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1605 else |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
1606 octave::err_index_out_of_range (2, 2, idx_j.extent (nc), nc, dims ()); |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1607 } |
16803
f4eef73b6e90
When indexing scalars stored as sparse matrices, convert to an array, index and then resparsify (bug #37774)
David Bateman <dbateman@free.fr>
parents:
15358
diff
changeset
|
1608 else if (nr == 1 && nc == 1) |
f4eef73b6e90
When indexing scalars stored as sparse matrices, convert to an array, index and then resparsify (bug #37774)
David Bateman <dbateman@free.fr>
parents:
15358
diff
changeset
|
1609 { |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1610 // Scalars stored as sparse matrices occupy more memory than |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1611 // a scalar, so let's just convert the matrix to full, index, |
16803
f4eef73b6e90
When indexing scalars stored as sparse matrices, convert to an array, index and then resparsify (bug #37774)
David Bateman <dbateman@free.fr>
parents:
15358
diff
changeset
|
1612 // and sparsify the result. |
f4eef73b6e90
When indexing scalars stored as sparse matrices, convert to an array, index and then resparsify (bug #37774)
David Bateman <dbateman@free.fr>
parents:
15358
diff
changeset
|
1613 |
f4eef73b6e90
When indexing scalars stored as sparse matrices, convert to an array, index and then resparsify (bug #37774)
David Bateman <dbateman@free.fr>
parents:
15358
diff
changeset
|
1614 retval = Sparse<T> (array_value ().index (idx_i, idx_j)); |
f4eef73b6e90
When indexing scalars stored as sparse matrices, convert to an array, index and then resparsify (bug #37774)
David Bateman <dbateman@free.fr>
parents:
15358
diff
changeset
|
1615 } |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1616 else if (idx_i.is_colon ()) |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1617 { |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1618 // Great, we're just manipulating columns. This is going to be quite |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1619 // efficient, because the columns can stay compressed as they are. |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1620 if (idx_j.is_colon ()) |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1621 retval = *this; // Shallow copy. |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1622 else if (idx_j.is_cont_range (nc, lb, ub)) |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1623 { |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1624 // Special-case a contiguous range. |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1625 octave_idx_type lbi = cidx (lb); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1626 octave_idx_type ubi = cidx (ub); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1627 octave_idx_type new_nz = ubi - lbi; |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1628 retval = Sparse<T> (nr, ub - lb, new_nz); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1629 std::copy_n (data () + lbi, new_nz, retval.data ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1630 std::copy_n (ridx () + lbi, new_nz, retval.ridx ()); |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1631 mx_inline_sub (ub - lb + 1, retval.cidx (), cidx () + lb, lbi); |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1632 } |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1633 else |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1634 { |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1635 // Count new nonzero elements. |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1636 retval = Sparse<T> (nr, m); |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1637 for (octave_idx_type j = 0; j < m; j++) |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1638 { |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1639 octave_idx_type jj = idx_j(j); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1640 retval.xcidx (j+1) = retval.xcidx (j) + (cidx (jj+1) - cidx (jj)); |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1641 } |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1642 |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1643 retval.change_capacity (retval.xcidx (m)); |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1644 |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1645 // Copy data & indices. |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1646 for (octave_idx_type j = 0; j < m; j++) |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1647 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1648 octave_idx_type ljj = cidx (idx_j(j)); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1649 octave_idx_type lj = retval.xcidx (j); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1650 octave_idx_type nzj = retval.xcidx (j+1) - lj; |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1651 |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1652 std::copy_n (data () + ljj, nzj, retval.data () + lj); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1653 std::copy_n (ridx () + ljj, nzj, retval.ridx () + lj); |
10432
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1654 } |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1655 } |
10207338603a
improve sparse 2D indexing (part 1)
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1656 } |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1657 else if (nc == 1 && idx_j.is_colon_equiv (nc) && idx_i.is_vector ()) |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1658 { |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1659 // It's actually vector indexing. The 1D index is specialized for that. |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1660 retval = index (idx_i); |
14790
b8041f48b0ff
Return sparse column vectors when the indexing allows it (bug #36656)
David Bateman <dbateman@free.fr>
parents:
14789
diff
changeset
|
1661 |
b8041f48b0ff
Return sparse column vectors when the indexing allows it (bug #36656)
David Bateman <dbateman@free.fr>
parents:
14789
diff
changeset
|
1662 // If nr == 1 then the vector indexing will return a column vector!! |
b8041f48b0ff
Return sparse column vectors when the indexing allows it (bug #36656)
David Bateman <dbateman@free.fr>
parents:
14789
diff
changeset
|
1663 if (nr == 1) |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
1664 retval.transpose (); |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1665 } |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1666 else if (idx_i.is_scalar ()) |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1667 { |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1668 octave_idx_type ii = idx_i(0); |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1669 retval = Sparse<T> (1, m); |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1670 OCTAVE_LOCAL_BUFFER (octave_idx_type, ij, m); |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1671 for (octave_idx_type j = 0; j < m; j++) |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1672 { |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1673 octave_quit (); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1674 octave_idx_type jj = idx_j(j); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1675 octave_idx_type lj = cidx (jj); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1676 octave_idx_type nzj = cidx (jj+1) - cidx (jj); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1677 |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1678 // Scalar index - just a binary lookup. |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1679 octave_idx_type i = lblookup (ridx () + lj, nzj, ii); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1680 if (i < nzj && ridx (i+lj) == ii) |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1681 { |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1682 ij[j] = i + lj; |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1683 retval.xcidx (j+1) = retval.xcidx (j) + 1; |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1684 } |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1685 else |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1686 retval.xcidx (j+1) = retval.xcidx (j); |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1687 } |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1688 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1689 retval.change_capacity (retval.xcidx (m)); |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1690 |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1691 // Copy data, adjust row indices. |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1692 for (octave_idx_type j = 0; j < m; j++) |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1693 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1694 octave_idx_type i = retval.xcidx (j); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1695 if (retval.xcidx (j+1) > i) |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1696 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1697 retval.xridx (i) = 0; |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1698 retval.xdata (i) = data (ij[j]); |
10442
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1699 } |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1700 } |
3011d1765a6e
improve sparse 2d indexing (part 2)
Jaroslav Hajek <highegg@gmail.com>
parents:
10432
diff
changeset
|
1701 } |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1702 else if (idx_i.is_cont_range (nr, lb, ub)) |
5164 | 1703 { |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1704 retval = Sparse<T> (n, m); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1705 OCTAVE_LOCAL_BUFFER (octave_idx_type, li, m); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1706 OCTAVE_LOCAL_BUFFER (octave_idx_type, ui, m); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1707 for (octave_idx_type j = 0; j < m; j++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1708 { |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1709 octave_quit (); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1710 octave_idx_type jj = idx_j(j); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1711 octave_idx_type lj = cidx (jj); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1712 octave_idx_type nzj = cidx (jj+1) - cidx (jj); |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1713 octave_idx_type lij, uij; |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1714 |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1715 // Lookup indices. |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1716 li[j] = lij = lblookup (ridx () + lj, nzj, lb) + lj; |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1717 ui[j] = uij = lblookup (ridx () + lj, nzj, ub) + lj; |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1718 retval.xcidx (j+1) = retval.xcidx (j) + ui[j] - li[j]; |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1719 } |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1720 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1721 retval.change_capacity (retval.xcidx (m)); |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1722 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1723 // Copy data, adjust row indices. |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1724 for (octave_idx_type j = 0, k = 0; j < m; j++) |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1725 { |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1726 octave_quit (); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1727 for (octave_idx_type i = li[j]; i < ui[j]; i++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1728 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1729 retval.xdata (k) = data (i); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1730 retval.xridx (k++) = ridx (i) - lb; |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1731 } |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1732 } |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1733 } |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1734 else if (idx_i.is_permutation (nr)) |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1735 { |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1736 // The columns preserve their length, just need to renumber and sort them. |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1737 // Count new nonzero elements. |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1738 retval = Sparse<T> (nr, m); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1739 for (octave_idx_type j = 0; j < m; j++) |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1740 { |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1741 octave_idx_type jj = idx_j(j); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1742 retval.xcidx (j+1) = retval.xcidx (j) + (cidx (jj+1) - cidx (jj)); |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1743 } |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1744 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1745 retval.change_capacity (retval.xcidx (m)); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1746 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1747 octave_quit (); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1748 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1749 if (idx_i.is_range () && idx_i.increment () == -1) |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1750 { |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1751 // It's nr:-1:1. Just flip all columns. |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1752 for (octave_idx_type j = 0; j < m; j++) |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1753 { |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1754 octave_quit (); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1755 octave_idx_type jj = idx_j(j); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1756 octave_idx_type lj = cidx (jj); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1757 octave_idx_type nzj = cidx (jj+1) - cidx (jj); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1758 octave_idx_type li = retval.xcidx (j); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1759 octave_idx_type uj = lj + nzj - 1; |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1760 for (octave_idx_type i = 0; i < nzj; i++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1761 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1762 retval.xdata (li + i) = data (uj - i); // Copy in reverse order. |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1763 retval.xridx (li + i) = nr - 1 - ridx (uj - i); // Ditto with transform. |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1764 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1765 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1766 } |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1767 else |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1768 { |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1769 // Get inverse permutation. |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1770 idx_vector idx_iinv = idx_i.inverse_permutation (nr); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1771 const octave_idx_type *iinv = idx_iinv.raw (); |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1772 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1773 // Scatter buffer. |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1774 OCTAVE_LOCAL_BUFFER (T, scb, nr); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1775 octave_idx_type *rri = retval.ridx (); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1776 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1777 for (octave_idx_type j = 0; j < m; j++) |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1778 { |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1779 octave_quit (); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1780 octave_idx_type jj = idx_j(j); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1781 octave_idx_type lj = cidx (jj); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1782 octave_idx_type nzj = cidx (jj+1) - cidx (jj); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1783 octave_idx_type li = retval.xcidx (j); |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1784 // Scatter the column, transform indices. |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1785 for (octave_idx_type i = 0; i < nzj; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1786 scb[rri[li + i] = iinv[ridx (lj + i)]] = data (lj + i); |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1787 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1788 octave_quit (); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1789 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1790 // Sort them. |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1791 std::sort (rri + li, rri + li + nzj); |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1792 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1793 // Gather. |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1794 for (octave_idx_type i = 0; i < nzj; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1795 retval.xdata (li + i) = scb[rri[li + i]]; |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1796 } |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1797 } |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1798 |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1799 } |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1800 else if (idx_j.is_colon ()) |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1801 { |
21562
6c2fd62db1f7
maint: Eliminate accidental double spaces in code.
Rik <rik@octave.org>
parents:
21337
diff
changeset
|
1802 // This requires uncompressing columns, which is generally costly, |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1803 // so we rely on the efficient transpose to handle this. |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1804 // It may still make sense to optimize some cases here. |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1805 retval = transpose (); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1806 retval = retval.index (idx_vector::colon, idx_i); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1807 retval = retval.transpose (); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1808 } |
10468
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1809 else |
197b096001b7
improve sparse 2d indexing (part 3)
Jaroslav Hajek <highegg@gmail.com>
parents:
10442
diff
changeset
|
1810 { |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1811 // A(I, J) is decomposed into A(:, J)(I, :). |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1812 retval = index (idx_vector::colon, idx_j); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1813 retval = retval.index (idx_i, idx_vector::colon); |
5164 | 1814 } |
1815 | |
1816 return retval; | |
1817 } | |
1818 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1819 template <typename T> |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1820 void |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1821 Sparse<T>::assign (const idx_vector& idx, const Sparse<T>& rhs) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1822 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1823 Sparse<T> retval; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1824 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1825 assert (ndims () == 2); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1826 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1827 octave_idx_type nr = dim1 (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1828 octave_idx_type nc = dim2 (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1829 octave_idx_type nz = nnz (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1830 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1831 octave_idx_type n = numel (); // Can throw. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1832 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1833 octave_idx_type rhl = rhs.numel (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1834 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1835 if (idx.length (n) == rhl) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1836 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1837 if (rhl == 0) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1838 return; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1839 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1840 octave_idx_type nx = idx.extent (n); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
1841 // Try to resize first if necessary. |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1842 if (nx != n) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1843 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1844 resize1 (nx); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1845 n = numel (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1846 nr = rows (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1847 nc = cols (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1848 // nz is preserved. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1849 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1850 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1851 if (idx.is_colon ()) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1852 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1853 *this = rhs.reshape (dimensions); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1854 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1855 else if (nc == 1 && rhs.cols () == 1) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1856 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1857 // Sparse column vector to sparse column vector assignment. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1858 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1859 octave_idx_type lb, ub; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1860 if (idx.is_cont_range (nr, lb, ub)) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1861 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1862 // Special-case a contiguous range. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1863 // Look-up indices first. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1864 octave_idx_type li = lblookup (ridx (), nz, lb); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1865 octave_idx_type ui = lblookup (ridx (), nz, ub); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1866 octave_idx_type rnz = rhs.nnz (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1867 octave_idx_type new_nz = nz - (ui - li) + rnz; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1868 |
20229
5dfaaaae784f
Deprecate Array::capacity() and Sparse::capacity() for numel() and nzmax().
Carnë Draug <carandraug@octave.org>
parents:
20218
diff
changeset
|
1869 if (new_nz >= nz && new_nz <= nzmax ()) |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1870 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1871 // Adding/overwriting elements, enough capacity allocated. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1872 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1873 if (new_nz > nz) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1874 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1875 // Make room first. |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1876 std::copy_backward (data () + ui, data () + nz, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1877 data () + nz + rnz); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1878 std::copy_backward (ridx () + ui, ridx () + nz, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1879 ridx () + nz + rnz); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1880 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
1881 |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1882 // Copy data and adjust indices from rhs. |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1883 std::copy_n (rhs.data (), rnz, data () + li); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1884 mx_inline_add (rnz, ridx () + li, rhs.ridx (), lb); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1885 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1886 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1887 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1888 // Clearing elements or exceeding capacity, allocate afresh |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1889 // and paste pieces. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1890 const Sparse<T> tmp = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1891 *this = Sparse<T> (nr, 1, new_nz); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1892 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1893 // Head ... |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1894 std::copy_n (tmp.data (), li, data ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1895 std::copy_n (tmp.ridx (), li, ridx ()); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1896 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1897 // new stuff ... |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1898 std::copy_n (rhs.data (), rnz, data () + li); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1899 mx_inline_add (rnz, ridx () + li, rhs.ridx (), lb); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1900 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1901 // ...tail |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1902 std::copy (tmp.data () + ui, tmp.data () + nz, |
19861
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
1903 data () + li + rnz); |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
1904 std::copy (tmp.ridx () + ui, tmp.ridx () + nz, |
19861
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
1905 ridx () + li + rnz); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1906 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1907 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1908 cidx (1) = new_nz; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1909 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1910 else if (idx.is_range () && idx.increment () == -1) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1911 { |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
1912 // It's s(u:-1:l) = r. Reverse the assignment. |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1913 assign (idx.sorted (), rhs.index (idx_vector (rhl - 1, 0, -1))); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1914 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1915 else if (idx.is_permutation (n)) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1916 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1917 *this = rhs.index (idx.inverse_permutation (n)); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1918 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1919 else if (rhs.nnz () == 0) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1920 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1921 // Elements are being zeroed. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1922 octave_idx_type *ri = ridx (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1923 for (octave_idx_type i = 0; i < rhl; i++) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1924 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1925 octave_idx_type iidx = idx(i); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1926 octave_idx_type li = lblookup (ri, nz, iidx); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1927 if (li != nz && ri[li] == iidx) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
1928 xdata (li) = T (); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1929 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1930 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1931 maybe_compress (true); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1932 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1933 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1934 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1935 const Sparse<T> tmp = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1936 octave_idx_type new_nz = nz + rhl; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1937 // Disassembly our matrix... |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1938 Array<octave_idx_type> new_ri (dim_vector (new_nz, 1)); |
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1939 Array<T> new_data (dim_vector (new_nz, 1)); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1940 std::copy_n (tmp.ridx (), nz, new_ri.fortran_vec ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
1941 std::copy_n (tmp.data (), nz, new_data.fortran_vec ()); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1942 // ... insert new data (densified) ... |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1943 idx.copy_data (new_ri.fortran_vec () + nz); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1944 new_data.assign (idx_vector (nz, new_nz), rhs.array_value ()); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1945 // ... reassembly. |
10586 | 1946 *this = Sparse<T> (new_data, new_ri, |
1947 static_cast<octave_idx_type> (0), | |
1948 nr, nc, false); | |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1949 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1950 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1951 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1952 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1953 dim_vector save_dims = dimensions; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1954 *this = index (idx_vector::colon); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1955 assign (idx, rhs.index (idx_vector::colon)); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1956 *this = reshape (save_dims); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1957 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1958 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1959 else if (rhl == 1) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1960 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1961 rhl = idx.length (n); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1962 if (rhs.nnz () != 0) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1963 assign (idx, Sparse<T> (rhl, 1, rhs.data (0))); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1964 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1965 assign (idx, Sparse<T> (rhl, 1)); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1966 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1967 else |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
1968 octave::err_nonconformant ("=", dim_vector(idx.length (n),1), rhs.dims()); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1969 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1970 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
1971 template <typename T> |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1972 void |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1973 Sparse<T>::assign (const idx_vector& idx_i, |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1974 const idx_vector& idx_j, const Sparse<T>& rhs) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1975 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1976 Sparse<T> retval; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1977 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1978 assert (ndims () == 2); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1979 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1980 octave_idx_type nr = dim1 (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1981 octave_idx_type nc = dim2 (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1982 octave_idx_type nz = nnz (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1983 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1984 octave_idx_type n = rhs.rows (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1985 octave_idx_type m = rhs.columns (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1986 |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1987 // FIXME: this should probably be written more like the |
12184
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1988 // Array<T>::assign function... |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1989 |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1990 bool orig_zero_by_zero = (nr == 0 && nc == 0); |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1991 |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1992 if (orig_zero_by_zero || (idx_i.length (nr) == n && idx_j.length (nc) == m)) |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
1993 { |
12184
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1994 octave_idx_type nrx; |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1995 octave_idx_type ncx; |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1996 |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1997 if (orig_zero_by_zero) |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1998 { |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
1999 if (idx_i.is_colon ()) |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2000 { |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2001 nrx = n; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2002 |
12184
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2003 if (idx_j.is_colon ()) |
12318
211f8c905a4f
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
12184
diff
changeset
|
2004 ncx = m; |
12184
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2005 else |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2006 ncx = idx_j.extent (nc); |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2007 } |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2008 else if (idx_j.is_colon ()) |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2009 { |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2010 nrx = idx_i.extent (nr); |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2011 ncx = m; |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2012 } |
12318
211f8c905a4f
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
12184
diff
changeset
|
2013 else |
211f8c905a4f
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
12184
diff
changeset
|
2014 { |
211f8c905a4f
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
12184
diff
changeset
|
2015 nrx = idx_i.extent (nr); |
211f8c905a4f
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
12184
diff
changeset
|
2016 ncx = idx_j.extent (nc); |
211f8c905a4f
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
12184
diff
changeset
|
2017 } |
12184
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2018 } |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2019 else |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2020 { |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2021 nrx = idx_i.extent (nr); |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2022 ncx = idx_j.extent (nc); |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2023 } |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2024 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2025 // Try to resize first if necessary. |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2026 if (nrx != nr || ncx != nc) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2027 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2028 resize (nrx, ncx); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2029 nr = rows (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2030 nc = cols (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2031 // nz is preserved. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2032 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2033 |
12184
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2034 if (n == 0 || m == 0) |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2035 return; |
d8de1a28274c
sparse matrix indexed assignment bug
John W. Eaton <jwe@octave.org>
parents:
11590
diff
changeset
|
2036 |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2037 if (idx_i.is_colon ()) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2038 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2039 octave_idx_type lb, ub; |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
2040 // Great, we're just manipulating columns. This is going to be quite |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2041 // efficient, because the columns can stay compressed as they are. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2042 if (idx_j.is_colon ()) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2043 *this = rhs; // Shallow copy. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2044 else if (idx_j.is_cont_range (nc, lb, ub)) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2045 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2046 // Special-case a contiguous range. |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2047 octave_idx_type li = cidx (lb); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2048 octave_idx_type ui = cidx (ub); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2049 octave_idx_type rnz = rhs.nnz (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2050 octave_idx_type new_nz = nz - (ui - li) + rnz; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2051 |
20229
5dfaaaae784f
Deprecate Array::capacity() and Sparse::capacity() for numel() and nzmax().
Carnë Draug <carandraug@octave.org>
parents:
20218
diff
changeset
|
2052 if (new_nz >= nz && new_nz <= nzmax ()) |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2053 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2054 // Adding/overwriting elements, enough capacity allocated. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2055 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2056 if (new_nz > nz) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2057 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2058 // Make room first. |
21255
6209f428426c
Fix memory corruption allocating to sparse arrays (bug #42825).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
19861
diff
changeset
|
2059 std::copy_backward (data () + ui, data () + nz, |
6209f428426c
Fix memory corruption allocating to sparse arrays (bug #42825).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
19861
diff
changeset
|
2060 data () + new_nz); |
6209f428426c
Fix memory corruption allocating to sparse arrays (bug #42825).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
19861
diff
changeset
|
2061 std::copy_backward (ridx () + ui, ridx () + nz, |
6209f428426c
Fix memory corruption allocating to sparse arrays (bug #42825).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
19861
diff
changeset
|
2062 ridx () + new_nz); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2063 mx_inline_add2 (nc - ub, cidx () + ub + 1, new_nz - nz); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2064 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2065 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2066 // Copy data and indices from rhs. |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2067 std::copy_n (rhs.data (), rnz, data () + li); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2068 std::copy_n (rhs.ridx (), rnz, ridx () + li); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2069 mx_inline_add (ub - lb, cidx () + lb + 1, rhs.cidx () + 1, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2070 li); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2071 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2072 assert (nnz () == new_nz); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2073 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2074 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2075 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2076 // Clearing elements or exceeding capacity, allocate afresh |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2077 // and paste pieces. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2078 const Sparse<T> tmp = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2079 *this = Sparse<T> (nr, nc, new_nz); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2080 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2081 // Head... |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2082 std::copy_n (tmp.data (), li, data ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2083 std::copy_n (tmp.ridx (), li, ridx ()); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2084 std::copy_n (tmp.cidx () + 1, lb, cidx () + 1); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2085 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2086 // new stuff... |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2087 std::copy_n (rhs.data (), rnz, data () + li); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2088 std::copy_n (rhs.ridx (), rnz, ridx () + li); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2089 mx_inline_add (ub - lb, cidx () + lb + 1, rhs.cidx () + 1, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2090 li); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2091 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2092 // ...tail. |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
2093 std::copy (tmp.data () + ui, tmp.data () + nz, |
19861
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
2094 data () + li + rnz); |
19381
af41e41ad28e
replace oct-mem.h inline indirections by standard function calls.
Kai T. Ohlhus <k.ohlhus@gmail.com>
parents:
19078
diff
changeset
|
2095 std::copy (tmp.ridx () + ui, tmp.ridx () + nz, |
19861
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
2096 ridx () + li + rnz); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2097 mx_inline_add (nc - ub, cidx () + ub + 1, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2098 tmp.cidx () + ub + 1, new_nz - nz); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2099 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2100 assert (nnz () == new_nz); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2101 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2102 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2103 else if (idx_j.is_range () && idx_j.increment () == -1) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2104 { |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
2105 // It's s(:,u:-1:l) = r. Reverse the assignment. |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2106 assign (idx_i, idx_j.sorted (), |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2107 rhs.index (idx_i, idx_vector (m - 1, 0, -1))); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2108 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2109 else if (idx_j.is_permutation (nc)) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2110 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2111 *this = rhs.index (idx_i, idx_j.inverse_permutation (nc)); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2112 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2113 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2114 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2115 const Sparse<T> tmp = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2116 *this = Sparse<T> (nr, nc); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2117 OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, jsav, nc, -1); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2118 |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2119 // Assemble column lengths. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2120 for (octave_idx_type i = 0; i < nc; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2121 xcidx (i+1) = tmp.cidx (i+1) - tmp.cidx (i); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2122 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2123 for (octave_idx_type i = 0; i < m; i++) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2124 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2125 octave_idx_type j =idx_j(i); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2126 jsav[j] = i; |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2127 xcidx (j+1) = rhs.cidx (i+1) - rhs.cidx (i); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2128 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2129 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2130 // Make cumulative. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2131 for (octave_idx_type i = 0; i < nc; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2132 xcidx (i+1) += xcidx (i); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2133 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2134 change_capacity (nnz ()); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2135 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2136 // Merge columns. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2137 for (octave_idx_type i = 0; i < nc; i++) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2138 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2139 octave_idx_type l = xcidx (i); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2140 octave_idx_type u = xcidx (i+1); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2141 octave_idx_type j = jsav[i]; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2142 if (j >= 0) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2143 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2144 // from rhs |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2145 octave_idx_type k = rhs.cidx (j); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2146 std::copy_n (rhs.data () + k, u - l, xdata () + l); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2147 std::copy_n (rhs.ridx () + k, u - l, xridx () + l); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2148 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2149 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2150 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2151 // original |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2152 octave_idx_type k = tmp.cidx (i); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2153 std::copy_n (tmp.data () + k, u - l, xdata () + l); |
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
2154 std::copy_n (tmp.ridx () + k, u - l, xridx () + l); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2155 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2156 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2157 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2158 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2159 } |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
2160 else if (nc == 1 && idx_j.is_colon_equiv (nc) && idx_i.is_vector ()) |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
2161 { |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2162 // It's just vector indexing. The 1D assign is specialized for that. |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
2163 assign (idx_i, rhs); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
2164 } |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2165 else if (idx_j.is_colon ()) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2166 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2167 if (idx_i.is_permutation (nr)) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2168 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2169 *this = rhs.index (idx_i.inverse_permutation (nr), idx_j); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2170 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2171 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2172 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2173 // FIXME: optimize more special cases? |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2174 // In general this requires unpacking the columns, which is slow, |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
2175 // especially for many small columns. OTOH, transpose is an |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2176 // efficient O(nr+nc+nnz) operation. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2177 *this = transpose (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2178 assign (idx_vector::colon, idx_i, rhs.transpose ()); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2179 *this = transpose (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2180 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2181 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2182 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2183 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2184 // Split it into 2 assignments and one indexing. |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2185 Sparse<T> tmp = index (idx_vector::colon, idx_j); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2186 tmp.assign (idx_i, idx_vector::colon, rhs); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2187 assign (idx_vector::colon, idx_j, tmp); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2188 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2189 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2190 else if (m == 1 && n == 1) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2191 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2192 n = idx_i.length (nr); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2193 m = idx_j.length (nc); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2194 if (rhs.nnz () != 0) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2195 assign (idx_i, idx_j, Sparse<T> (n, m, rhs.data (0))); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2196 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2197 assign (idx_i, idx_j, Sparse<T> (n, m)); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2198 } |
22600
dd80fb1ef949
maint: minor style fixes for C++ code.
John W. Eaton <jwe@octave.org>
parents:
22489
diff
changeset
|
2199 else if (idx_i.length (nr) == m && idx_j.length (nc) == n |
dd80fb1ef949
maint: minor style fixes for C++ code.
John W. Eaton <jwe@octave.org>
parents:
22489
diff
changeset
|
2200 && (n == 1 || m == 1)) |
20673
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2201 { |
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2202 assign (idx_i, idx_j, rhs.transpose ()); |
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2203 } |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2204 else |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
2205 octave::err_nonconformant ("=", idx_i.length (nr), idx_j.length (nc), n, m); |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2206 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
2207 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2208 // Can't use versions of these in Array.cc due to duplication of the |
7433 | 2209 // instantiations for Array<double and Sparse<double>, etc |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2210 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2211 bool |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2212 sparse_ascending_compare (typename ref_param<T>::type a, |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2213 typename ref_param<T>::type b) |
7433 | 2214 { |
2215 return (a < b); | |
2216 } | |
2217 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2218 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2219 bool |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2220 sparse_descending_compare (typename ref_param<T>::type a, |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2221 typename ref_param<T>::type b) |
7433 | 2222 { |
2223 return (a > b); | |
2224 } | |
2225 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2226 template <typename T> |
7433 | 2227 Sparse<T> |
2228 Sparse<T>::sort (octave_idx_type dim, sortmode mode) const | |
2229 { | |
2230 Sparse<T> m = *this; | |
2231 | |
2232 octave_idx_type nr = m.rows (); | |
2233 octave_idx_type nc = m.columns (); | |
2234 | |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20229
diff
changeset
|
2235 if (m.numel () < 1 || dim > 1) |
7433 | 2236 return m; |
2237 | |
2238 if (dim > 0) | |
2239 { | |
2240 m = m.transpose (); | |
2241 nr = m.rows (); | |
2242 nc = m.columns (); | |
2243 } | |
2244 | |
2245 octave_sort<T> lsort; | |
2246 | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2247 if (mode == ASCENDING) |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2248 lsort.set_compare (sparse_ascending_compare<T>); |
7433 | 2249 else if (mode == DESCENDING) |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2250 lsort.set_compare (sparse_descending_compare<T>); |
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
2251 else |
23448
e1c02e7126a9
avoid calling abort if possible; include cstdlib for declaration if needed
John W. Eaton <jwe@octave.org>
parents:
23432
diff
changeset
|
2252 (*current_liboctave_error_handler) |
e1c02e7126a9
avoid calling abort if possible; include cstdlib for declaration if needed
John W. Eaton <jwe@octave.org>
parents:
23432
diff
changeset
|
2253 ("Sparse<T>::sort: invalid MODE"); |
7433 | 2254 |
2255 T *v = m.data (); | |
2256 octave_idx_type *mcidx = m.cidx (); | |
2257 octave_idx_type *mridx = m.ridx (); | |
2258 | |
2259 for (octave_idx_type j = 0; j < nc; j++) | |
2260 { | |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2261 octave_idx_type ns = mcidx[j + 1] - mcidx[j]; |
7433 | 2262 lsort.sort (v, ns); |
2263 | |
2264 octave_idx_type i; | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2265 if (mode == ASCENDING) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2266 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2267 for (i = 0; i < ns; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2268 if (sparse_ascending_compare<T> (static_cast<T> (0), v[i])) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2269 break; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2270 } |
7433 | 2271 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2272 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2273 for (i = 0; i < ns; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2274 if (sparse_descending_compare<T> (static_cast<T> (0), v[i])) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2275 break; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2276 } |
7433 | 2277 for (octave_idx_type k = 0; k < i; k++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2278 mridx[k] = k; |
7433 | 2279 for (octave_idx_type k = i; k < ns; k++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2280 mridx[k] = k - ns + nr; |
7433 | 2281 |
2282 v += ns; | |
2283 mridx += ns; | |
2284 } | |
2285 | |
2286 if (dim > 0) | |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2287 m = m.transpose (); |
7433 | 2288 |
2289 return m; | |
2290 } | |
2291 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2292 template <typename T> |
7433 | 2293 Sparse<T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2294 Sparse<T>::sort (Array<octave_idx_type> &sidx, octave_idx_type dim, |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2295 sortmode mode) const |
7433 | 2296 { |
2297 Sparse<T> m = *this; | |
2298 | |
2299 octave_idx_type nr = m.rows (); | |
2300 octave_idx_type nc = m.columns (); | |
2301 | |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20229
diff
changeset
|
2302 if (m.numel () < 1 || dim > 1) |
7433 | 2303 { |
10703
5eb420d92307
fix sort and nth_element when trailing singleton dim is specified
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
2304 sidx = Array<octave_idx_type> (dim_vector (nr, nc), 1); |
7433 | 2305 return m; |
2306 } | |
2307 | |
2308 if (dim > 0) | |
2309 { | |
2310 m = m.transpose (); | |
2311 nr = m.rows (); | |
2312 nc = m.columns (); | |
2313 } | |
2314 | |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2315 octave_sort<T> indexed_sort; |
7433 | 2316 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2317 if (mode == ASCENDING) |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2318 indexed_sort.set_compare (sparse_ascending_compare<T>); |
7433 | 2319 else if (mode == DESCENDING) |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2320 indexed_sort.set_compare (sparse_descending_compare<T>); |
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
2321 else |
23448
e1c02e7126a9
avoid calling abort if possible; include cstdlib for declaration if needed
John W. Eaton <jwe@octave.org>
parents:
23432
diff
changeset
|
2322 (*current_liboctave_error_handler) |
e1c02e7126a9
avoid calling abort if possible; include cstdlib for declaration if needed
John W. Eaton <jwe@octave.org>
parents:
23432
diff
changeset
|
2323 ("Sparse<T>::sort: invalid MODE"); |
7433 | 2324 |
2325 T *v = m.data (); | |
2326 octave_idx_type *mcidx = m.cidx (); | |
2327 octave_idx_type *mridx = m.ridx (); | |
2328 | |
2329 sidx = Array<octave_idx_type> (dim_vector (nr, nc)); | |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2330 OCTAVE_LOCAL_BUFFER (octave_idx_type, vi, nr); |
7433 | 2331 |
2332 for (octave_idx_type j = 0; j < nc; j++) | |
2333 { | |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2334 octave_idx_type ns = mcidx[j + 1] - mcidx[j]; |
7433 | 2335 octave_idx_type offset = j * nr; |
2336 | |
2337 if (ns == 0) | |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2338 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2339 for (octave_idx_type k = 0; k < nr; k++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2340 sidx (offset + k) = k; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2341 } |
7433 | 2342 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2343 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2344 for (octave_idx_type i = 0; i < ns; i++) |
8752
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2345 vi[i] = mridx[i]; |
06b9903a029b
fix & clean up complex & sparse sorting
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
2346 |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2347 indexed_sort.sort (v, vi, ns); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2348 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2349 octave_idx_type i; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2350 if (mode == ASCENDING) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2351 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2352 for (i = 0; i < ns; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2353 if (sparse_ascending_compare<T> (static_cast<T> (0), v[i])) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2354 break; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2355 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2356 else |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2357 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2358 for (i = 0; i < ns; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2359 if (sparse_descending_compare<T> (static_cast<T> (0), v[i])) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2360 break; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2361 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2362 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2363 octave_idx_type ii = 0; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2364 octave_idx_type jj = i; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2365 for (octave_idx_type k = 0; k < nr; k++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2366 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2367 if (ii < ns && mridx[ii] == k) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2368 ii++; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2369 else |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2370 sidx (offset + jj++) = k; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2371 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2372 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2373 for (octave_idx_type k = 0; k < i; k++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2374 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2375 sidx (k + offset) = vi[k]; |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2376 mridx[k] = k; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2377 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2378 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2379 for (octave_idx_type k = i; k < ns; k++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2380 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2381 sidx (k - ns + nr + offset) = vi[k]; |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2382 mridx[k] = k - ns + nr; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2383 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2384 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2385 v += ns; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2386 mridx += ns; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2387 } |
7433 | 2388 } |
2389 | |
2390 if (dim > 0) | |
2391 { | |
2392 m = m.transpose (); | |
2393 sidx = sidx.transpose (); | |
2394 } | |
2395 | |
2396 return m; | |
2397 } | |
2398 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2399 template <typename T> |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2400 Sparse<T> |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2401 Sparse<T>::diag (octave_idx_type k) const |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2402 { |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2403 octave_idx_type nnr = rows (); |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2404 octave_idx_type nnc = cols (); |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2405 Sparse<T> d; |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2406 |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2407 if (nnr == 0 || nnc == 0) |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2408 ; // do nothing |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2409 else if (nnr != 1 && nnc != 1) |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2410 { |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2411 if (k > 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2412 nnc -= k; |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2413 else if (k < 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2414 nnr += k; |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2415 |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2416 if (nnr > 0 && nnc > 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2417 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2418 octave_idx_type ndiag = (nnr < nnc) ? nnr : nnc; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2419 |
18812
9ac2357f19bc
doc: Replace "non-zero" with "nonzero" to match existing usage.
Rik <rik@octave.org>
parents:
18678
diff
changeset
|
2420 // Count the number of nonzero elements |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2421 octave_idx_type nel = 0; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2422 if (k > 0) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2423 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2424 for (octave_idx_type i = 0; i < ndiag; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2425 if (elem (i, i+k) != 0.) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2426 nel++; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2427 } |
18678
6113e0c6920b
maint: Clean up extra spaces before/after parentheses.
Rik <rik@octave.org>
parents:
18278
diff
changeset
|
2428 else if (k < 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2429 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2430 for (octave_idx_type i = 0; i < ndiag; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2431 if (elem (i-k, i) != 0.) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2432 nel++; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2433 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2434 else |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2435 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2436 for (octave_idx_type i = 0; i < ndiag; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2437 if (elem (i, i) != 0.) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2438 nel++; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2439 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2440 |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2441 d = Sparse<T> (ndiag, 1, nel); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2442 d.xcidx (0) = 0; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2443 d.xcidx (1) = nel; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2444 |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2445 octave_idx_type ii = 0; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2446 if (k > 0) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2447 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2448 for (octave_idx_type i = 0; i < ndiag; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2449 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2450 T tmp = elem (i, i+k); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2451 if (tmp != 0.) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2452 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2453 d.xdata (ii) = tmp; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2454 d.xridx (ii++) = i; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2455 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2456 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2457 } |
18678
6113e0c6920b
maint: Clean up extra spaces before/after parentheses.
Rik <rik@octave.org>
parents:
18278
diff
changeset
|
2458 else if (k < 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2459 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2460 for (octave_idx_type i = 0; i < ndiag; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2461 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2462 T tmp = elem (i-k, i); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2463 if (tmp != 0.) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2464 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2465 d.xdata (ii) = tmp; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2466 d.xridx (ii++) = i; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2467 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2468 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2469 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2470 else |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2471 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2472 for (octave_idx_type i = 0; i < ndiag; i++) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2473 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2474 T tmp = elem (i, i); |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2475 if (tmp != 0.) |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2476 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2477 d.xdata (ii) = tmp; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2478 d.xridx (ii++) = i; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2479 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2480 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2481 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2482 } |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2483 else |
18278
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2484 { |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2485 // Matlab returns [] 0x1 for out-of-range diagonal |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2486 |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2487 octave_idx_type nr = 0; |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2488 octave_idx_type nc = 1; |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2489 octave_idx_type nz = 0; |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2490 |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2491 d = Sparse<T> (nr, nc, nz); |
00539b673cd4
Sparse.cc: Fix C++ function ambiguity (bug #41145).
John W. Eaton <jwe@octave.org>
parents:
18146
diff
changeset
|
2492 } |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2493 } |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2494 else if (nnr != 0 && nnc != 0) |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2495 { |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2496 octave_idx_type roff = 0; |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2497 octave_idx_type coff = 0; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2498 if (k > 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2499 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2500 roff = 0; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2501 coff = k; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2502 } |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2503 else if (k < 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2504 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2505 roff = -k; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2506 coff = 0; |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2507 } |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2508 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2509 if (nnr == 1) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2510 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2511 octave_idx_type n = nnc + std::abs (k); |
10506
bdf5d85cfc5e
replace nzmax by nnz where appropriate in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10499
diff
changeset
|
2512 octave_idx_type nz = nnz (); |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2513 |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2514 d = Sparse<T> (n, n, nz); |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2515 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2516 if (nnz () > 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2517 { |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2518 for (octave_idx_type i = 0; i < coff+1; i++) |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2519 d.xcidx (i) = 0; |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2520 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2521 for (octave_idx_type j = 0; j < nnc; j++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2522 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2523 for (octave_idx_type i = cidx (j); i < cidx (j+1); i++) |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2524 { |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2525 d.xdata (i) = data (i); |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2526 d.xridx (i) = j + roff; |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2527 } |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2528 d.xcidx (j + coff + 1) = cidx (j+1); |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2529 } |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2530 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2531 for (octave_idx_type i = nnc + coff + 1; i < n + 1; i++) |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2532 d.xcidx (i) = nz; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2533 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2534 } |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2535 else |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2536 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2537 octave_idx_type n = nnr + std::abs (k); |
10506
bdf5d85cfc5e
replace nzmax by nnz where appropriate in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10499
diff
changeset
|
2538 octave_idx_type nz = nnz (); |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2539 |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2540 d = Sparse<T> (n, n, nz); |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2541 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2542 if (nnz () > 0) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2543 { |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2544 octave_idx_type ii = 0; |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2545 octave_idx_type ir = ridx (0); |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2546 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2547 for (octave_idx_type i = 0; i < coff+1; i++) |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2548 d.xcidx (i) = 0; |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2549 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2550 for (octave_idx_type i = 0; i < nnr; i++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2551 { |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2552 if (ir == i) |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2553 { |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2554 d.xdata (ii) = data (ii); |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2555 d.xridx (ii++) = ir + roff; |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2556 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2557 if (ii != nz) |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2558 ir = ridx (ii); |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2559 } |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2560 d.xcidx (i + coff + 1) = ii; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2561 } |
10367
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2562 |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2563 for (octave_idx_type i = nnr + coff + 1; i < n+1; i++) |
173e10268080
avoid indexing nonexistent elements in sparse diag
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
2564 d.xcidx (i) = nz; |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2565 } |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
2566 } |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2567 } |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2568 |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2569 return d; |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2570 } |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7573
diff
changeset
|
2571 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2572 template <typename T> |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2573 Sparse<T> |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2574 Sparse<T>::cat (int dim, octave_idx_type n, const Sparse<T> *sparse_list) |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2575 { |
10716
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2576 // Default concatenation. |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2577 bool (dim_vector::*concat_rule) (const dim_vector&, int) = &dim_vector::concat; |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2578 |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2579 if (dim == -1 || dim == -2) |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2580 { |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2581 concat_rule = &dim_vector::hvcat; |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2582 dim = -dim - 1; |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2583 } |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2584 else if (dim < 0) |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2585 (*current_liboctave_error_handler) ("cat: invalid dimension"); |
10716
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2586 |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2587 dim_vector dv; |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2588 octave_idx_type total_nz = 0; |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2589 if (dim != 0 && dim != 1) |
10535
3f973f6c841c
improve sparse concatenation operator
Jaroslav Hajek <highegg@gmail.com>
parents:
10533
diff
changeset
|
2590 (*current_liboctave_error_handler) |
3f973f6c841c
improve sparse concatenation operator
Jaroslav Hajek <highegg@gmail.com>
parents:
10533
diff
changeset
|
2591 ("cat: invalid dimension for sparse concatenation"); |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2592 |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2593 if (n == 1) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2594 return sparse_list[0]; |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2595 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2596 for (octave_idx_type i = 0; i < n; i++) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2597 { |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2598 if (! (dv.*concat_rule) (sparse_list[i].dims (), dim)) |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2599 (*current_liboctave_error_handler) ("cat: dimension mismatch"); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2600 |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2601 total_nz += sparse_list[i].nnz (); |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2602 } |
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21120
diff
changeset
|
2603 |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2604 Sparse<T> retval (dv, total_nz); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11571
diff
changeset
|
2605 |
10716
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2606 if (retval.is_empty ()) |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2607 return retval; |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2608 |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2609 switch (dim) |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2610 { |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2611 case 0: |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2612 { |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2613 // sparse vertcat. This is not efficiently handled by assignment, |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2614 // so we'll do it directly. |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2615 octave_idx_type l = 0; |
10533
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2616 for (octave_idx_type j = 0; j < dv(1); j++) |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2617 { |
10533
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2618 octave_quit (); |
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2619 |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2620 octave_idx_type rcum = 0; |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2621 for (octave_idx_type i = 0; i < n; i++) |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2622 { |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2623 const Sparse<T>& spi = sparse_list[i]; |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
2624 // Skipping empty matrices. See the comment in Array.cc. |
10716
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2625 if (spi.is_empty ()) |
10533
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2626 continue; |
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2627 |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2628 octave_idx_type kl = spi.cidx (j); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
2629 octave_idx_type ku = spi.cidx (j+1); |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2630 for (octave_idx_type k = kl; k < ku; k++, l++) |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2631 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2632 retval.xridx (l) = spi.ridx (k) + rcum; |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2633 retval.xdata (l) = spi.data (k); |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2634 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2635 |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2636 rcum += spi.rows (); |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2637 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2638 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2639 retval.xcidx (j+1) = l; |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2640 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2641 |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2642 break; |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2643 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2644 case 1: |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2645 { |
10533
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2646 octave_idx_type l = 0; |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2647 for (octave_idx_type i = 0; i < n; i++) |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2648 { |
10533
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2649 octave_quit (); |
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2650 |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21704
diff
changeset
|
2651 // Skipping empty matrices. See the comment in Array.cc. |
10716
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2652 if (sparse_list[i].is_empty ()) |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2653 continue; |
f7f26094021b
improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10703
diff
changeset
|
2654 |
10533
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2655 octave_idx_type u = l + sparse_list[i].columns (); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2656 retval.assign (idx_vector::colon, idx_vector (l, u), |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
2657 sparse_list[i]); |
10533
f094ac9bc93e
reuse Array<T>::cat and Sparse<T>::cat in cat/horzcat/vertcat
Jaroslav Hajek <highegg@gmail.com>
parents:
10531
diff
changeset
|
2658 l = u; |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2659 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2660 |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2661 break; |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2662 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2663 default: |
10535
3f973f6c841c
improve sparse concatenation operator
Jaroslav Hajek <highegg@gmail.com>
parents:
10533
diff
changeset
|
2664 assert (false); |
10531
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2665 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2666 |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2667 return retval; |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2668 } |
2dd8ea8bfd71
basic cat functionality in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
10527
diff
changeset
|
2669 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2670 template <typename T> |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2671 Array<T> |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2672 Sparse<T>::array_value () const |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2673 { |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
2674 NoAlias< Array<T> > retval (dims (), T ()); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2675 if (rows () == 1) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2676 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2677 octave_idx_type i = 0; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2678 for (octave_idx_type j = 0, nc = cols (); j < nc; j++) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2679 { |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2680 if (cidx (j+1) > i) |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2681 retval(j) = data (i++); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2682 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2683 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2684 else |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2685 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2686 for (octave_idx_type j = 0, nc = cols (); j < nc; j++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2687 for (octave_idx_type i = cidx (j), iu = cidx (j+1); i < iu; i++) |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2688 retval(ridx (i), j) = data (i); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2689 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2690 |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2691 return retval; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2692 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10421
diff
changeset
|
2693 |
21704
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2694 template <typename T> |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2695 std::istream& |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2696 read_sparse_matrix (std::istream& is, Sparse<T>& a, |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2697 T (*read_fcn) (std::istream&)) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2698 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2699 octave_idx_type nr = a.rows (); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2700 octave_idx_type nc = a.cols (); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2701 octave_idx_type nz = a.nzmax (); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2702 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2703 if (nr > 0 && nc > 0) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2704 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2705 octave_idx_type itmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2706 octave_idx_type jtmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2707 octave_idx_type iold = 0; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2708 octave_idx_type jold = 0; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2709 octave_idx_type ii = 0; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2710 T tmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2711 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2712 a.cidx (0) = 0; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2713 for (octave_idx_type i = 0; i < nz; i++) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2714 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2715 itmp = 0; jtmp = 0; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2716 is >> itmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2717 itmp--; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2718 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2719 is >> jtmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2720 jtmp--; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2721 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2722 if (is.fail ()) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2723 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2724 is.clear(); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2725 std::string err_field; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2726 is >> err_field; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2727 (*current_liboctave_error_handler) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2728 ("invalid sparse matrix: element %d: " |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2729 "Symbols '%s' is not an integer format", |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2730 i+1, err_field.c_str ()); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2731 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2732 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2733 if (itmp < 0 || itmp >= nr) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2734 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2735 is.setstate (std::ios::failbit); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2736 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2737 (*current_liboctave_error_handler) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2738 ("invalid sparse matrix: element %d: " |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2739 "row index = %d out of range", |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2740 i+1, itmp + 1); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2741 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2742 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2743 if (jtmp < 0 || jtmp >= nc) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2744 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2745 is.setstate (std::ios::failbit); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2746 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2747 (*current_liboctave_error_handler) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2748 ("invalid sparse matrix: element %d: " |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2749 "column index = %d out of range", |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2750 i+1, jtmp + 1); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2751 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2752 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2753 if (jtmp < jold) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2754 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2755 is.setstate (std::ios::failbit); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2756 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2757 (*current_liboctave_error_handler) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2758 ("invalid sparse matrix: element %d:" |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2759 "column indices must appear in ascending order (%d < %d)", |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2760 i+1, jtmp, jold); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2761 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2762 else if (jtmp > jold) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2763 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2764 for (octave_idx_type j = jold; j < jtmp; j++) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2765 a.cidx (j+1) = ii; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2766 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2767 else if (itmp < iold) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2768 { |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2769 is.setstate (std::ios::failbit); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2770 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2771 (*current_liboctave_error_handler) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2772 ("invalid sparse matrix: element %d: " |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2773 "row indices must appear in ascending order in each column " |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2774 "(%d < %d)", |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2775 i+1, iold, itmp); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2776 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2777 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2778 iold = itmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2779 jold = jtmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2780 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2781 tmp = read_fcn (is); |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2782 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2783 if (! is) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2784 return is; // Problem, return is in error state |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2785 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2786 a.data (ii) = tmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2787 a.ridx (ii++) = itmp; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2788 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2789 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2790 for (octave_idx_type j = jold; j < nc; j++) |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2791 a.cidx (j+1) = ii; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2792 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2793 |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2794 return is; |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2795 } |
ac59b72712fd
Clearer error messages when loading buggy sparse matrix files (bug #38414)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21690
diff
changeset
|
2796 |
7356 | 2797 /* |
2798 * Tests | |
2799 * | |
2800 | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2801 %!function x = set_slice (x, dim, slice, arg) |
16933
e39f00a32dc7
maint: Use parentheses around condition for switch(),while(),if() statements.
Rik <rik@octave.org>
parents:
16803
diff
changeset
|
2802 %! switch (dim) |
7356 | 2803 %! case 11 |
2804 %! x(slice) = 2; | |
2805 %! case 21 | |
2806 %! x(slice, :) = 2; | |
2807 %! case 22 | |
2808 %! x(:, slice) = 2; | |
2809 %! otherwise | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2810 %! error ("invalid dim, '%d'", dim); |
7356 | 2811 %! endswitch |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2812 %!endfunction |
7356 | 2813 |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2814 %!function x = set_slice2 (x, dim, slice) |
16933
e39f00a32dc7
maint: Use parentheses around condition for switch(),while(),if() statements.
Rik <rik@octave.org>
parents:
16803
diff
changeset
|
2815 %! switch (dim) |
7546
4249c6fb6e09
Treat repeated indices in the sparse assignments
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
2816 %! case 11 |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2817 %! x(slice) = 2 * ones (size (slice)); |
7546
4249c6fb6e09
Treat repeated indices in the sparse assignments
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
2818 %! case 21 |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2819 %! x(slice, :) = 2 * ones (length (slice), columns (x)); |
7546
4249c6fb6e09
Treat repeated indices in the sparse assignments
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
2820 %! case 22 |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2821 %! x(:, slice) = 2 * ones (rows (x), length (slice)); |
7546
4249c6fb6e09
Treat repeated indices in the sparse assignments
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
2822 %! otherwise |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2823 %! error ("invalid dim, '%d'", dim); |
7546
4249c6fb6e09
Treat repeated indices in the sparse assignments
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
2824 %! endswitch |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2825 %!endfunction |
7546
4249c6fb6e09
Treat repeated indices in the sparse assignments
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
2826 |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2827 %!function test_sparse_slice (size, dim, slice) |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2828 %! x = ones (size); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2829 %! s = set_slice (sparse (x), dim, slice); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2830 %! f = set_slice (x, dim, slice); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2831 %! assert (nnz (s), nnz (f)); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2832 %! assert (full (s), f); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2833 %! s = set_slice2 (sparse (x), dim, slice); |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2834 %! f = set_slice2 (x, dim, slice); |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2835 %! assert (nnz (s), nnz (f)); |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2836 %! assert (full (s), f); |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2837 %!endfunction |
7356 | 2838 |
2839 #### 1d indexing | |
2840 | |
2841 ## size = [2 0] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2842 %!test test_sparse_slice ([2 0], 11, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2843 %!assert (set_slice (sparse (ones ([2 0])), 11, 1), sparse ([2 0]')) # sparse different from full |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2844 %!assert (set_slice (sparse (ones ([2 0])), 11, 2), sparse ([0 2]')) # sparse different from full |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2845 %!assert (set_slice (sparse (ones ([2 0])), 11, 3), sparse ([0 0; 2 0]')) # sparse different from full |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2846 %!assert (set_slice (sparse (ones ([2 0])), 11, 4), sparse ([0 0; 0 2]')) # sparse different from full |
7356 | 2847 |
2848 ## size = [0 2] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2849 %!test test_sparse_slice ([0 2], 11, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2850 %!assert (set_slice (sparse (ones ([0 2])), 11, 1), sparse ([2 0])) # sparse different from full |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2851 %!test test_sparse_slice ([0 2], 11, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2852 %!test test_sparse_slice ([0 2], 11, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2853 %!test test_sparse_slice ([0 2], 11, 4); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2854 %!test test_sparse_slice ([0 2], 11, [4, 4]); |
7356 | 2855 |
2856 ## size = [2 1] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2857 %!test test_sparse_slice ([2 1], 11, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2858 %!test test_sparse_slice ([2 1], 11, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2859 %!test test_sparse_slice ([2 1], 11, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2860 %!test test_sparse_slice ([2 1], 11, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2861 %!test test_sparse_slice ([2 1], 11, 4); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2862 %!test test_sparse_slice ([2 1], 11, [4, 4]); |
7356 | 2863 |
2864 ## size = [1 2] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2865 %!test test_sparse_slice ([1 2], 11, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2866 %!test test_sparse_slice ([1 2], 11, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2867 %!test test_sparse_slice ([1 2], 11, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2868 %!test test_sparse_slice ([1 2], 11, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2869 %!test test_sparse_slice ([1 2], 11, 4); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2870 %!test test_sparse_slice ([1 2], 11, [4, 4]); |
7356 | 2871 |
2872 ## size = [2 2] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2873 %!test test_sparse_slice ([2 2], 11, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2874 %!test test_sparse_slice ([2 2], 11, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2875 %!test test_sparse_slice ([2 2], 11, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2876 %!test test_sparse_slice ([2 2], 11, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2877 %!test test_sparse_slice ([2 2], 11, 4); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2878 %!test test_sparse_slice ([2 2], 11, [4, 4]); |
7356 | 2879 # These 2 errors are the same as in the full case |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2880 %!error id=Octave:invalid-resize set_slice (sparse (ones ([2 2])), 11, 5) |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2881 %!error id=Octave:invalid-resize set_slice (sparse (ones ([2 2])), 11, 6) |
7356 | 2882 |
2883 #### 2d indexing | |
2884 | |
2885 ## size = [2 0] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2886 %!test test_sparse_slice ([2 0], 21, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2887 %!test test_sparse_slice ([2 0], 21, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2888 %!test test_sparse_slice ([2 0], 21, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2889 %!test test_sparse_slice ([2 0], 21, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2890 %!assert (set_slice (sparse (ones ([2 0])), 21, 3), sparse (3,0)) |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2891 %!assert (set_slice (sparse (ones ([2 0])), 21, 4), sparse (4,0)) |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2892 %!test test_sparse_slice ([2 0], 22, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2893 %!test test_sparse_slice ([2 0], 22, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2894 %!test test_sparse_slice ([2 0], 22, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2895 %!test test_sparse_slice ([2 0], 22, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2896 %!assert (set_slice (sparse (ones ([2 0])), 22, 3), sparse ([0 0 2;0 0 2])) # sparse different from full |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2897 %!assert (set_slice (sparse (ones ([2 0])), 22, 4), sparse ([0 0 0 2;0 0 0 2])) # sparse different from full |
7356 | 2898 |
2899 ## size = [0 2] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2900 %!test test_sparse_slice ([0 2], 21, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2901 %!test test_sparse_slice ([0 2], 21, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2902 %!test test_sparse_slice ([0 2], 21, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2903 %!test test_sparse_slice ([0 2], 21, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2904 %!assert (set_slice (sparse (ones ([0 2])), 21, 3), sparse ([0 0;0 0;2 2])) # sparse different from full |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2905 %!assert (set_slice (sparse (ones ([0 2])), 21, 4), sparse ([0 0;0 0;0 0;2 2])) # sparse different from full |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2906 %!test test_sparse_slice ([0 2], 22, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2907 %!test test_sparse_slice ([0 2], 22, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2908 %!test test_sparse_slice ([0 2], 22, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2909 %!test test_sparse_slice ([0 2], 22, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2910 %!assert (set_slice (sparse (ones ([0 2])), 22, 3), sparse (0,3)) |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2911 %!assert (set_slice (sparse (ones ([0 2])), 22, 4), sparse (0,4)) |
7356 | 2912 |
2913 ## size = [2 1] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2914 %!test test_sparse_slice ([2 1], 21, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2915 %!test test_sparse_slice ([2 1], 21, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2916 %!test test_sparse_slice ([2 1], 21, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2917 %!test test_sparse_slice ([2 1], 21, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2918 %!test test_sparse_slice ([2 1], 21, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2919 %!test test_sparse_slice ([2 1], 21, 4); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2920 %!test test_sparse_slice ([2 1], 22, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2921 %!test test_sparse_slice ([2 1], 22, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2922 %!test test_sparse_slice ([2 1], 22, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2923 %!test test_sparse_slice ([2 1], 22, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2924 %!test test_sparse_slice ([2 1], 22, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2925 %!test test_sparse_slice ([2 1], 22, 4); |
7356 | 2926 |
2927 ## size = [1 2] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2928 %!test test_sparse_slice ([1 2], 21, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2929 %!test test_sparse_slice ([1 2], 21, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2930 %!test test_sparse_slice ([1 2], 21, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2931 %!test test_sparse_slice ([1 2], 21, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2932 %!test test_sparse_slice ([1 2], 21, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2933 %!test test_sparse_slice ([1 2], 21, 4); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2934 %!test test_sparse_slice ([1 2], 22, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2935 %!test test_sparse_slice ([1 2], 22, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2936 %!test test_sparse_slice ([1 2], 22, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2937 %!test test_sparse_slice ([1 2], 22, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2938 %!test test_sparse_slice ([1 2], 22, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2939 %!test test_sparse_slice ([1 2], 22, 4); |
7356 | 2940 |
2941 ## size = [2 2] | |
14427
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2942 %!test test_sparse_slice ([2 2], 21, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2943 %!test test_sparse_slice ([2 2], 21, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2944 %!test test_sparse_slice ([2 2], 21, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2945 %!test test_sparse_slice ([2 2], 21, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2946 %!test test_sparse_slice ([2 2], 21, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2947 %!test test_sparse_slice ([2 2], 21, 4); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2948 %!test test_sparse_slice ([2 2], 22, []); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2949 %!test test_sparse_slice ([2 2], 22, 1); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2950 %!test test_sparse_slice ([2 2], 22, 2); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2951 %!test test_sparse_slice ([2 2], 22, [2,2]); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2952 %!test test_sparse_slice ([2 2], 22, 3); |
d07e989686b0
Use Octave coding conventions in liboctave %!test blocks
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
2953 %!test test_sparse_slice ([2 2], 22, 4); |
7356 | 2954 |
22489
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2955 %!assert <35570> (speye (3,1)(3:-1:1), sparse ([0; 0; 1])) |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2956 |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2957 ## Test removing columns |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2958 %!test <36656> |
14789
62219ea36f05
Assign the sparse column index when deleting contiguous columns (bug #36656)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
14433
diff
changeset
|
2959 %! s = sparse (magic (5)); |
62219ea36f05
Assign the sparse column index when deleting contiguous columns (bug #36656)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
14433
diff
changeset
|
2960 %! s(:,2:4) = []; |
62219ea36f05
Assign the sparse column index when deleting contiguous columns (bug #36656)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
14433
diff
changeset
|
2961 %! assert (s, sparse (magic (5)(:, [1,5]))); |
62219ea36f05
Assign the sparse column index when deleting contiguous columns (bug #36656)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
14433
diff
changeset
|
2962 |
14790
b8041f48b0ff
Return sparse column vectors when the indexing allows it (bug #36656)
David Bateman <dbateman@free.fr>
parents:
14789
diff
changeset
|
2963 %!test |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14846
diff
changeset
|
2964 %! s = sparse ([], [], [], 1, 1); |
14790
b8041f48b0ff
Return sparse column vectors when the indexing allows it (bug #36656)
David Bateman <dbateman@free.fr>
parents:
14789
diff
changeset
|
2965 %! s(1,:) = []; |
b8041f48b0ff
Return sparse column vectors when the indexing allows it (bug #36656)
David Bateman <dbateman@free.fr>
parents:
14789
diff
changeset
|
2966 %! assert (s, sparse ([], [], [], 0, 1)); |
b8041f48b0ff
Return sparse column vectors when the indexing allows it (bug #36656)
David Bateman <dbateman@free.fr>
parents:
14789
diff
changeset
|
2967 |
17278
79d4b6089968
Fix isequal for sparse matrix (bug #37321)
Stefan Mahr <dac922@gmx.de>
parents:
16933
diff
changeset
|
2968 ## Test (bug #37321) |
22489
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2969 %!test <37321> a=sparse (0,0); assert (all (a) == sparse ([1])); |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2970 %!test <37321> a=sparse (0,1); assert (all (a) == sparse ([1])); |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2971 %!test <37321> a=sparse (1,0); assert (all (a) == sparse ([1])); |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2972 %!test <37321> a=sparse (1,0); assert (all (a,2) == sparse ([1])); |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2973 %!test <37321> a=sparse (1,0); assert (size (all (a,1)), [1 0]); |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2974 %!test <37321> a=sparse (1,1); |
17285
f519560bfcb4
maint: Use Octave spacing conventions in cset 79d4b6089968.
Rik <rik@octave.org>
parents:
17278
diff
changeset
|
2975 %! assert (all (a) == sparse ([0])); |
f519560bfcb4
maint: Use Octave spacing conventions in cset 79d4b6089968.
Rik <rik@octave.org>
parents:
17278
diff
changeset
|
2976 %! assert (size (all (a)), [1 1]); |
22489
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2977 %!test <37321> a=sparse (2,1); |
17285
f519560bfcb4
maint: Use Octave spacing conventions in cset 79d4b6089968.
Rik <rik@octave.org>
parents:
17278
diff
changeset
|
2978 %! assert (all (a) == sparse ([0])); |
f519560bfcb4
maint: Use Octave spacing conventions in cset 79d4b6089968.
Rik <rik@octave.org>
parents:
17278
diff
changeset
|
2979 %! assert (size (all (a)), [1 1]); |
22489
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2980 %!test <37321> a=sparse (1,2); |
17285
f519560bfcb4
maint: Use Octave spacing conventions in cset 79d4b6089968.
Rik <rik@octave.org>
parents:
17278
diff
changeset
|
2981 %! assert (all (a) == sparse ([0])); |
f519560bfcb4
maint: Use Octave spacing conventions in cset 79d4b6089968.
Rik <rik@octave.org>
parents:
17278
diff
changeset
|
2982 %! assert (size (all (a)), [1 1]); |
22489
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2983 %!test <37321> a=sparse (2,2); assert (isequal (all (a), sparse ([0 0]))); |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2984 |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2985 ## Test assigning row to a column slice |
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
2986 %!test <45589> |
20673
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2987 %! a = sparse (magic (3)); |
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2988 %! b = a; |
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2989 %! a(1,:) = 1:3; |
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2990 %! b(1,:) = (1:3)'; |
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2991 %! assert (a, b); |
3d8aee0b7415
Allow assigning row vector to column of Sparse array (bug #45589).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20542
diff
changeset
|
2992 |
7356 | 2993 */ |
2994 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
2995 template <typename T> |
5164 | 2996 void |
2997 Sparse<T>::print_info (std::ostream& os, const std::string& prefix) const | |
2998 { | |
2999 os << prefix << "rep address: " << rep << "\n" | |
5604 | 3000 << prefix << "rep->nzmx: " << rep->nzmx << "\n" |
5164 | 3001 << prefix << "rep->nrows: " << rep->nrows << "\n" |
3002 << prefix << "rep->ncols: " << rep->ncols << "\n" | |
3003 << prefix << "rep->data: " << static_cast<void *> (rep->d) << "\n" | |
3004 << prefix << "rep->ridx: " << static_cast<void *> (rep->r) << "\n" | |
3005 << prefix << "rep->cidx: " << static_cast<void *> (rep->c) << "\n" | |
3006 << prefix << "rep->count: " << rep->count << "\n"; | |
3007 } | |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10509
diff
changeset
|
3008 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
3009 #define INSTANTIATE_SPARSE(T, API) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
3010 template class API Sparse<T>; \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
3011 template std::istream& \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
3012 read_sparse_matrix<T> (std::istream& is, Sparse<T>& a, \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
3013 T (*read_fcn) (std::istream&)); |