Mercurial > hg > octave-nkf

annotate liboctave/Sparse.cc @ 14656:8d2ce821e38a

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