Mercurial > hg > octave-nkf

annotate liboctave/array/Sparse.cc @ 20158:857a8f018f53

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