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