Mercurial > hg > octave-nkf

annotate liboctave/Sparse.cc @ 10535:3f973f6c841c

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