Mercurial > octave-libgccjit
annotate liboctave/Sparse.h @ 8918:f5408862892f
Consistently use element_type in the array classes.
author | Jason Riedy <jason@acm.org> |
---|---|
date | Fri, 06 Mar 2009 10:27:30 -0500 |
parents | 1ebcb9872ced |
children | eb63fbe60fab |
rev | line source |
---|---|
5164 | 1 // Template sparse classes |
2 /* | |
3 | |
7017 | 4 Copyright (C) 2004, 2005, 2006, 2007 David Bateman |
7016 | 5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Andy Adler |
6 | |
7 This file is part of Octave. | |
5164 | 8 |
9 Octave is free software; you can redistribute it and/or modify it | |
10 under the terms of the GNU General Public License as published by the | |
7016 | 11 Free Software Foundation; either version 3 of the License, or (at your |
12 option) any later version. | |
5164 | 13 |
14 Octave is distributed in the hope that it will be useful, but WITHOUT | |
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
17 for more details. | |
18 | |
19 You should have received a copy of the GNU General Public License | |
7016 | 20 along with Octave; see the file COPYING. If not, see |
21 <http://www.gnu.org/licenses/>. | |
5164 | 22 |
23 */ | |
24 | |
25 #if !defined (octave_Sparse_h) | |
26 #define octave_Sparse_h 1 | |
27 | |
28 #include <cassert> | |
29 #include <cstddef> | |
30 | |
31 #include <iostream> | |
32 | |
33 #include "Array.h" | |
34 #include "Array2.h" | |
35 #include "dim-vector.h" | |
36 #include "lo-utils.h" | |
37 | |
7433 | 38 #include "oct-sort.h" |
39 | |
5164 | 40 class idx_vector; |
41 | |
42 // Two dimensional sparse class. Handles the reference counting for | |
43 // all the derived classes. | |
44 | |
45 template <class T> | |
46 class | |
47 Sparse | |
48 { | |
8181
1ebcb9872ced
fix sparse-matrix bool/cmp op instantiation problem
John W. Eaton <jwe@octave.org>
parents:
7717
diff
changeset
|
49 public: |
1ebcb9872ced
fix sparse-matrix bool/cmp op instantiation problem
John W. Eaton <jwe@octave.org>
parents:
7717
diff
changeset
|
50 |
8918
f5408862892f
Consistently use element_type in the array classes.
Jason Riedy <jason@acm.org>
parents:
8181
diff
changeset
|
51 typedef T element_type; |
8181
1ebcb9872ced
fix sparse-matrix bool/cmp op instantiation problem
John W. Eaton <jwe@octave.org>
parents:
7717
diff
changeset
|
52 |
5164 | 53 protected: |
54 //-------------------------------------------------------------------- | |
55 // The real representation of all Sparse arrays. | |
56 //-------------------------------------------------------------------- | |
57 | |
6108 | 58 class OCTAVE_API SparseRep |
5164 | 59 { |
60 public: | |
61 | |
62 T *d; | |
5275 | 63 octave_idx_type *r; |
64 octave_idx_type *c; | |
5604 | 65 octave_idx_type nzmx; |
5275 | 66 octave_idx_type nrows; |
67 octave_idx_type ncols; | |
5164 | 68 int count; |
69 | |
5604 | 70 SparseRep (void) : d (0), r (0), c (new octave_idx_type [1]), nzmx (0), nrows (0), |
5164 | 71 ncols (0), count (1) { c[0] = 0; } |
72 | |
5604 | 73 SparseRep (octave_idx_type n) : d (0), r (0), c (new octave_idx_type [n+1]), nzmx (0), nrows (n), |
5164 | 74 ncols (n), count (1) |
75 { | |
5275 | 76 for (octave_idx_type i = 0; i < n + 1; i++) |
5164 | 77 c[i] = 0; |
78 } | |
79 | |
5604 | 80 SparseRep (octave_idx_type nr, octave_idx_type nc) : d (0), r (0), c (new octave_idx_type [nc+1]), nzmx (0), |
5164 | 81 nrows (nr), ncols (nc), count (1) |
82 { | |
5275 | 83 for (octave_idx_type i = 0; i < nc + 1; i++) |
5164 | 84 c[i] = 0; |
85 } | |
86 | |
5275 | 87 SparseRep (octave_idx_type nr, octave_idx_type nc, octave_idx_type nz) : d (new T [nz]), |
5604 | 88 r (new octave_idx_type [nz]), c (new octave_idx_type [nc+1]), nzmx (nz), nrows (nr), |
5164 | 89 ncols (nc), count (1) |
90 { | |
5275 | 91 for (octave_idx_type i = 0; i < nc + 1; i++) |
5164 | 92 c[i] = 0; |
93 } | |
94 | |
95 SparseRep (const SparseRep& a) | |
5604 | 96 : d (new T [a.nzmx]), r (new octave_idx_type [a.nzmx]), c (new octave_idx_type [a.ncols + 1]), |
97 nzmx (a.nzmx), nrows (a.nrows), ncols (a.ncols), count (1) | |
5164 | 98 { |
5604 | 99 for (octave_idx_type i = 0; i < nzmx; i++) |
5164 | 100 { |
101 d[i] = a.d[i]; | |
102 r[i] = a.r[i]; | |
103 } | |
5275 | 104 for (octave_idx_type i = 0; i < ncols + 1; i++) |
5164 | 105 c[i] = a.c[i]; |
106 } | |
107 | |
108 ~SparseRep (void) { delete [] d; delete [] r; delete [] c; } | |
109 | |
5604 | 110 octave_idx_type length (void) const { return nzmx; } |
5164 | 111 |
5604 | 112 octave_idx_type nnz (void) const { return c [ncols]; } |
5164 | 113 |
5275 | 114 T& elem (octave_idx_type _r, octave_idx_type _c); |
5164 | 115 |
5275 | 116 T celem (octave_idx_type _r, octave_idx_type _c) const; |
5164 | 117 |
5275 | 118 T& data (octave_idx_type i) { return d[i]; } |
5164 | 119 |
5275 | 120 T cdata (octave_idx_type i) const { return d[i]; } |
5164 | 121 |
5275 | 122 octave_idx_type& ridx (octave_idx_type i) { return r[i]; } |
5164 | 123 |
5275 | 124 octave_idx_type cridx (octave_idx_type i) const { return r[i]; } |
5164 | 125 |
5275 | 126 octave_idx_type& cidx (octave_idx_type i) { return c[i]; } |
5164 | 127 |
5275 | 128 octave_idx_type ccidx (octave_idx_type i) const { return c[i]; } |
5164 | 129 |
130 void maybe_compress (bool remove_zeros); | |
131 | |
5275 | 132 void change_length (octave_idx_type nz); |
5164 | 133 |
134 private: | |
135 | |
136 // No assignment! | |
137 | |
138 SparseRep& operator = (const SparseRep& a); | |
139 }; | |
140 | |
141 //-------------------------------------------------------------------- | |
142 | |
143 void make_unique (void) | |
144 { | |
145 if (rep->count > 1) | |
146 { | |
147 --rep->count; | |
148 rep = new SparseRep (*rep); | |
149 } | |
150 } | |
151 | |
152 public: | |
153 | |
154 // !!! WARNING !!! -- these should be protected, not public. You | |
155 // should not access these data members directly! | |
156 | |
157 typename Sparse<T>::SparseRep *rep; | |
158 | |
159 dim_vector dimensions; | |
160 | |
161 protected: | |
162 idx_vector *idx; | |
5275 | 163 octave_idx_type idx_count; |
5164 | 164 |
165 private: | |
166 | |
167 typename Sparse<T>::SparseRep *nil_rep (void) const | |
168 { | |
169 static typename Sparse<T>::SparseRep *nr | |
170 = new typename Sparse<T>::SparseRep (); | |
171 | |
172 nr->count++; | |
173 | |
174 return nr; | |
175 } | |
176 | |
177 public: | |
178 | |
179 Sparse (void) | |
180 : rep (nil_rep ()), dimensions (dim_vector(0,0)), | |
181 idx (0), idx_count (0) { } | |
182 | |
5275 | 183 explicit Sparse (octave_idx_type n) |
5164 | 184 : rep (new typename Sparse<T>::SparseRep (n)), |
185 dimensions (dim_vector (n, n)), idx (0), idx_count (0) { } | |
186 | |
5275 | 187 explicit Sparse (octave_idx_type nr, octave_idx_type nc) |
5164 | 188 : rep (new typename Sparse<T>::SparseRep (nr, nc)), |
189 dimensions (dim_vector (nr, nc)), idx (0), idx_count (0) { } | |
190 | |
5275 | 191 explicit Sparse (octave_idx_type nr, octave_idx_type nc, T val); |
5164 | 192 |
5275 | 193 Sparse (const dim_vector& dv, octave_idx_type nz) |
5164 | 194 : rep (new typename Sparse<T>::SparseRep (dv(0), dv(1), nz)), |
195 dimensions (dv), idx (0), idx_count (0) { } | |
196 | |
5275 | 197 Sparse (octave_idx_type nr, octave_idx_type nc, octave_idx_type nz) |
5164 | 198 : rep (new typename Sparse<T>::SparseRep (nr, nc, nz)), |
199 dimensions (dim_vector (nr, nc)), idx (0), idx_count (0) { } | |
200 | |
201 // Type conversion case. | |
202 template <class U> Sparse (const Sparse<U>& a); | |
203 | |
204 // No type conversion case. | |
205 Sparse (const Sparse<T>& a) | |
206 : rep (a.rep), dimensions (a.dimensions), idx (0), idx_count (0) | |
207 { | |
208 rep->count++; | |
209 } | |
210 | |
211 public: | |
212 | |
213 Sparse (const dim_vector& dv); | |
214 | |
215 Sparse (const Sparse<T>& a, const dim_vector& dv); | |
216 | |
5275 | 217 Sparse (const Array<T>& a, const Array<octave_idx_type>& r, const Array<octave_idx_type>& c, |
218 octave_idx_type nr, octave_idx_type nc, bool sum_terms); | |
5164 | 219 |
220 Sparse (const Array<T>& a, const Array<double>& r, const Array<double>& c, | |
5275 | 221 octave_idx_type nr, octave_idx_type nc, bool sum_terms); |
5164 | 222 |
223 // Sparsify a normal matrix | |
224 Sparse (const Array2<T>& a); | |
225 Sparse (const Array<T>& a); | |
226 | |
227 virtual ~Sparse (void); | |
228 | |
7717
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
229 Sparse<T>& operator = (const Sparse<T>& a); |
5164 | 230 |
5604 | 231 // Note that nzmax and capacity are the amount of storage for |
232 // non-zero elements, while nnz is the actual number of non-zero | |
233 // terms. | |
234 octave_idx_type nzmax (void) const { return rep->length (); } | |
235 octave_idx_type capacity (void) const { return nzmax (); } | |
236 octave_idx_type nnz (void) const { return rep->nnz (); } | |
5164 | 237 |
238 // Paranoid number of elements test for case of dims = (-1,-1) | |
5275 | 239 octave_idx_type numel (void) const |
5164 | 240 { |
241 if (dim1() < 0 || dim2() < 0) | |
242 return 0; | |
243 else | |
244 return dimensions.numel (); | |
245 } | |
246 | |
5275 | 247 octave_idx_type nelem (void) const { return capacity (); } |
248 octave_idx_type length (void) const { return numel (); } | |
5164 | 249 |
5275 | 250 octave_idx_type dim1 (void) const { return dimensions(0); } |
251 octave_idx_type dim2 (void) const { return dimensions(1); } | |
5164 | 252 |
5275 | 253 octave_idx_type rows (void) const { return dim1 (); } |
254 octave_idx_type cols (void) const { return dim2 (); } | |
255 octave_idx_type columns (void) const { return dim2 (); } | |
5164 | 256 |
5275 | 257 octave_idx_type get_row_index (octave_idx_type k) { return ridx (k); } |
258 octave_idx_type get_col_index (octave_idx_type k) | |
5164 | 259 { |
5275 | 260 octave_idx_type ret = 0; |
5164 | 261 while (cidx(ret+1) < k) |
262 ret++; | |
263 return ret; | |
264 } | |
5275 | 265 size_t byte_size (void) const { return (cols () + 1) * sizeof (octave_idx_type) + |
266 capacity () * (sizeof (T) + sizeof (octave_idx_type)); } | |
5164 | 267 |
268 dim_vector dims (void) const { return dimensions; } | |
269 | |
270 Sparse<T> squeeze (void) const { return *this; } | |
271 | |
5275 | 272 octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx) const; |
5164 | 273 |
5275 | 274 T range_error (const char *fcn, octave_idx_type n) const; |
275 T& range_error (const char *fcn, octave_idx_type n); | |
5164 | 276 |
5275 | 277 T range_error (const char *fcn, octave_idx_type i, octave_idx_type j) const; |
278 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j); | |
5164 | 279 |
5275 | 280 T range_error (const char *fcn, const Array<octave_idx_type>& ra_idx) const; |
281 T& range_error (const char *fcn, const Array<octave_idx_type>& ra_idx); | |
5164 | 282 |
283 // No checking, even for multiple references, ever. | |
284 | |
5275 | 285 T& xelem (octave_idx_type n) |
5164 | 286 { |
5275 | 287 octave_idx_type i = n % rows (), j = n / rows(); |
5164 | 288 return xelem (i, j); |
289 } | |
290 | |
5275 | 291 T xelem (octave_idx_type n) const |
5164 | 292 { |
5275 | 293 octave_idx_type i = n % rows (), j = n / rows(); |
5164 | 294 return xelem (i, j); |
295 } | |
296 | |
5275 | 297 T& xelem (octave_idx_type i, octave_idx_type j) { return rep->elem (i, j); } |
298 T xelem (octave_idx_type i, octave_idx_type j) const { return rep->celem (i, j); } | |
5164 | 299 |
5275 | 300 T& xelem (const Array<octave_idx_type>& ra_idx) |
5164 | 301 { return xelem (compute_index (ra_idx)); } |
302 | |
5275 | 303 T xelem (const Array<octave_idx_type>& ra_idx) const |
5164 | 304 { return xelem (compute_index (ra_idx)); } |
305 | |
5775 | 306 // FIXME -- would be nice to fix this so that we don't |
5164 | 307 // unnecessarily force a copy, but that is not so easy, and I see no |
308 // clean way to do it. | |
309 | |
5275 | 310 T& checkelem (octave_idx_type n) |
5164 | 311 { |
312 if (n < 0 || n >= numel ()) | |
313 return range_error ("T& Sparse<T>::checkelem", n); | |
314 else | |
315 { | |
316 make_unique (); | |
317 return xelem (n); | |
318 } | |
319 } | |
320 | |
5275 | 321 T& checkelem (octave_idx_type i, octave_idx_type j) |
5164 | 322 { |
323 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
324 return range_error ("T& Sparse<T>::checkelem", i, j); | |
325 else | |
326 { | |
327 make_unique (); | |
328 return xelem (i, j); | |
329 } | |
330 } | |
331 | |
5275 | 332 T& checkelem (const Array<octave_idx_type>& ra_idx) |
5164 | 333 { |
5275 | 334 octave_idx_type i = compute_index (ra_idx); |
5164 | 335 |
336 if (i < 0) | |
337 return range_error ("T& Sparse<T>::checkelem", ra_idx); | |
338 else | |
339 return elem (i); | |
340 } | |
341 | |
5275 | 342 T& elem (octave_idx_type n) |
5164 | 343 { |
344 make_unique (); | |
345 return xelem (n); | |
346 } | |
347 | |
5275 | 348 T& elem (octave_idx_type i, octave_idx_type j) |
5164 | 349 { |
350 make_unique (); | |
351 return xelem (i, j); | |
352 } | |
353 | |
5275 | 354 T& elem (const Array<octave_idx_type>& ra_idx) |
5164 | 355 { return Sparse<T>::elem (compute_index (ra_idx)); } |
356 | |
357 #if defined (BOUNDS_CHECKING) | |
5275 | 358 T& operator () (octave_idx_type n) { return checkelem (n); } |
359 T& operator () (octave_idx_type i, octave_idx_type j) { return checkelem (i, j); } | |
360 T& operator () (const Array<octave_idx_type>& ra_idx) { return checkelem (ra_idx); } | |
5164 | 361 #else |
5275 | 362 T& operator () (octave_idx_type n) { return elem (n); } |
363 T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); } | |
364 T& operator () (const Array<octave_idx_type>& ra_idx) { return elem (ra_idx); } | |
5164 | 365 #endif |
366 | |
5275 | 367 T checkelem (octave_idx_type n) const |
5164 | 368 { |
369 if (n < 0 || n >= numel ()) | |
370 return range_error ("T Sparse<T>::checkelem", n); | |
371 else | |
372 return xelem (n); | |
373 } | |
374 | |
5275 | 375 T checkelem (octave_idx_type i, octave_idx_type j) const |
5164 | 376 { |
377 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
378 return range_error ("T Sparse<T>::checkelem", i, j); | |
379 else | |
380 return xelem (i, j); | |
381 } | |
382 | |
5275 | 383 T checkelem (const Array<octave_idx_type>& ra_idx) const |
5164 | 384 { |
5275 | 385 octave_idx_type i = compute_index (ra_idx); |
5164 | 386 |
387 if (i < 0) | |
388 return range_error ("T Sparse<T>::checkelem", ra_idx); | |
389 else | |
390 return Sparse<T>::elem (i); | |
391 } | |
392 | |
5275 | 393 T elem (octave_idx_type n) const { return xelem (n); } |
5164 | 394 |
5275 | 395 T elem (octave_idx_type i, octave_idx_type j) const { return xelem (i, j); } |
5164 | 396 |
5275 | 397 T elem (const Array<octave_idx_type>& ra_idx) const |
5164 | 398 { return Sparse<T>::elem (compute_index (ra_idx)); } |
399 | |
400 #if defined (BOUNDS_CHECKING) | |
5275 | 401 T operator () (octave_idx_type n) const { return checkelem (n); } |
402 T operator () (octave_idx_type i, octave_idx_type j) const { return checkelem (i, j); } | |
403 T operator () (const Array<octave_idx_type>& ra_idx) const { return checkelem (ra_idx); } | |
5164 | 404 #else |
5275 | 405 T operator () (octave_idx_type n) const { return elem (n); } |
406 T operator () (octave_idx_type i, octave_idx_type j) const { return elem (i, j); } | |
407 T operator () (const Array<octave_idx_type>& ra_idx) const { return elem (ra_idx); } | |
5164 | 408 #endif |
409 | |
410 Sparse<T> maybe_compress (bool remove_zeros = false) | |
411 { rep->maybe_compress (remove_zeros); return (*this); } | |
412 | |
413 Sparse<T> reshape (const dim_vector& new_dims) const; | |
414 | |
415 // !!! WARNING !!! -- the following resize_no_fill functions are | |
416 // public because template friends don't work properly with versions | |
417 // of gcc earlier than 3.3. You should use these functions only in | |
418 // classes that are derived from Sparse<T>. | |
419 | |
420 // protected: | |
421 | |
5275 | 422 void resize_no_fill (octave_idx_type r, octave_idx_type c); |
5164 | 423 |
424 void resize_no_fill (const dim_vector& dv); | |
425 | |
426 public: | |
5275 | 427 Sparse<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const; |
5164 | 428 |
5275 | 429 Sparse<T> ipermute (const Array<octave_idx_type>& vec) const |
5164 | 430 { return permute (vec, true); } |
431 | |
5275 | 432 void resize (octave_idx_type r, octave_idx_type c) { resize_no_fill (r, c); } |
5164 | 433 |
434 void resize (const dim_vector& dv) { resize_no_fill (dv); } | |
435 | |
5275 | 436 void change_capacity (octave_idx_type nz) { rep->change_length (nz); } |
5164 | 437 |
5275 | 438 Sparse<T>& insert (const Sparse<T>& a, octave_idx_type r, octave_idx_type c); |
439 Sparse<T>& insert (const Sparse<T>& a, const Array<octave_idx_type>& idx); | |
5164 | 440 |
441 bool is_square (void) const { return (dim1 () == dim2 ()); } | |
442 | |
443 bool is_empty (void) const { return (rows () < 1 && cols () < 1); } | |
444 | |
445 Sparse<T> transpose (void) const; | |
446 | |
447 T* data (void) { make_unique (); return rep->d; } | |
5275 | 448 T& data (octave_idx_type i) { make_unique (); return rep->data (i); } |
5164 | 449 T* xdata (void) { return rep->d; } |
5275 | 450 T& xdata (octave_idx_type i) { return rep->data (i); } |
5164 | 451 |
5275 | 452 T data (octave_idx_type i) const { return rep->data (i); } |
5900 | 453 // FIXME -- shouldn't this be returning const T*? |
5164 | 454 T* data (void) const { return rep->d; } |
455 | |
5275 | 456 octave_idx_type* ridx (void) { make_unique (); return rep->r; } |
457 octave_idx_type& ridx (octave_idx_type i) { make_unique (); return rep->ridx (i); } | |
458 octave_idx_type* xridx (void) { return rep->r; } | |
459 octave_idx_type& xridx (octave_idx_type i) { return rep->ridx (i); } | |
5164 | 460 |
5275 | 461 octave_idx_type ridx (octave_idx_type i) const { return rep->cridx (i); } |
5900 | 462 // FIXME -- shouldn't this be returning const octave_idx_type*? |
5275 | 463 octave_idx_type* ridx (void) const { return rep->r; } |
5164 | 464 |
5275 | 465 octave_idx_type* cidx (void) { make_unique (); return rep->c; } |
466 octave_idx_type& cidx (octave_idx_type i) { make_unique (); return rep->cidx (i); } | |
467 octave_idx_type* xcidx (void) { return rep->c; } | |
468 octave_idx_type& xcidx (octave_idx_type i) { return rep->cidx (i); } | |
5164 | 469 |
5275 | 470 octave_idx_type cidx (octave_idx_type i) const { return rep->ccidx (i); } |
5900 | 471 // FIXME -- shouldn't this be returning const octave_idx_type*? |
5275 | 472 octave_idx_type* cidx (void) const { return rep->c; } |
5164 | 473 |
5275 | 474 octave_idx_type ndims (void) const { return dimensions.length (); } |
5164 | 475 |
476 void clear_index (void); | |
477 | |
478 void set_index (const idx_vector& i); | |
479 | |
5275 | 480 octave_idx_type index_count (void) const { return idx_count; } |
5164 | 481 |
482 idx_vector *get_idx (void) const { return idx; } | |
483 | |
484 void maybe_delete_elements (idx_vector& i); | |
485 | |
486 void maybe_delete_elements (idx_vector& i, idx_vector& j); | |
487 | |
488 void maybe_delete_elements (Array<idx_vector>& ra_idx); | |
489 | |
490 Sparse<T> value (void); | |
491 | |
492 Sparse<T> index (idx_vector& i, int resize_ok = 0) const; | |
493 | |
494 Sparse<T> index (idx_vector& i, idx_vector& j, int resize_ok = 0) const; | |
495 | |
496 Sparse<T> index (Array<idx_vector>& ra_idx, int resize_ok = 0) const; | |
497 | |
498 void print_info (std::ostream& os, const std::string& prefix) const; | |
499 | |
5900 | 500 // Unsafe. These functions exist to support the MEX interface. |
501 // You should not use them anywhere else. | |
502 void *mex_get_data (void) const { return const_cast<T *> (data ()); } | |
503 | |
504 octave_idx_type *mex_get_ir (void) const { return const_cast<octave_idx_type *> (ridx ()); } | |
505 | |
506 octave_idx_type *mex_get_jc (void) const { return const_cast<octave_idx_type *> (cidx ()); } | |
7433 | 507 |
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
508 Sparse<T> sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const; |
7433 | 509 Sparse<T> sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0, |
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
510 sortmode mode = ASCENDING) const; |
7602
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
511 |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7602
diff
changeset
|
512 Sparse<T> diag (octave_idx_type k = 0) const; |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7602
diff
changeset
|
513 |
7602
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
514 template <class U, class F> |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
515 Sparse<U> |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
516 map (F fcn) const |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
517 { |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
518 Sparse<U> result; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
519 U f_zero = fcn (0.); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
520 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
521 if (f_zero != 0.) |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
522 { |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
523 octave_idx_type nr = rows (); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
524 octave_idx_type nc = cols (); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
525 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
526 result = Sparse<U> (nr, nc, f_zero); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
527 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
528 for (octave_idx_type j = 0; j < nc; j++) |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
529 for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
530 { |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
531 OCTAVE_QUIT; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
532 /* Use data instead of elem for better performance. */ |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
533 result.data (ridx (i) + j * nr) = fcn (data(i)); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
534 } |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
535 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
536 result.maybe_compress (true); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
537 } |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
538 else |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
539 { |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
540 octave_idx_type nz = nnz (); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
541 octave_idx_type nr = rows (); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
542 octave_idx_type nc = cols (); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
543 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
544 result = Sparse<U> (nr, nc, nz); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
545 octave_idx_type ii = 0; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
546 result.cidx (ii) = 0; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
547 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
548 for (octave_idx_type j = 0; j < nc; j++) |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
549 { |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
550 for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
551 { |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
552 U val = fcn (data (i)); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
553 if (val != 0.0) |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
554 { |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
555 result.data (ii) = val; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
556 result.ridx (ii++) = ridx (i); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
557 } |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
558 OCTAVE_QUIT; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
559 } |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
560 result.cidx (j+1) = ii; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
561 } |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
562 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
563 result.maybe_compress (false); |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
564 } |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
565 |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
566 return result; |
7bfaa9611558
Rewrite sparse mappers in terms of a functor template function
David Bateman <dbateman@free.fr>
parents:
7470
diff
changeset
|
567 } |
5164 | 568 }; |
569 | |
570 // NOTE: these functions should be friends of the Sparse<T> class and | |
571 // Sparse<T>::dimensions should be protected, not public, but we can't | |
572 // do that because of bugs in gcc prior to 3.3. | |
573 | |
574 template <class LT, class RT> | |
575 /* friend */ int | |
576 assign (Sparse<LT>& lhs, const Sparse<RT>& rhs); | |
577 | |
578 template <class LT, class RT> | |
579 /* friend */ int | |
580 assign1 (Sparse<LT>& lhs, const Sparse<RT>& rhs); | |
581 | |
6708 | 582 #define INSTANTIATE_SPARSE_ASSIGN(LT, RT, API) \ |
583 template API int assign (Sparse<LT>&, const Sparse<RT>&); \ | |
584 template API int assign1 (Sparse<LT>&, const Sparse<RT>&); | |
5164 | 585 |
6708 | 586 #define INSTANTIATE_SPARSE(T, API) \ |
587 template class API Sparse<T>; | |
5164 | 588 |
6708 | 589 #define INSTANTIATE_SPARSE_AND_ASSIGN(T, API) \ |
590 INSTANTIATE_SPARSE (T, API); \ | |
591 INSTANTIATE_SPARSE_ASSIGN (T, T, API) | |
5164 | 592 |
593 #endif | |
594 | |
595 /* | |
596 ;;; Local Variables: *** | |
597 ;;; mode: C++ *** | |
598 ;;; End: *** | |
599 */ |