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