Mercurial > octave-nkf
annotate liboctave/Array.h @ 8503:8ba2ee57c594
remove qsort in favor of sort
author | Jaroslav Hajek <highegg@gmail.com> |
---|---|
date | Tue, 13 Jan 2009 12:16:21 +0100 |
parents | 9238637cb81c |
children | ad3afaaa19c1 |
rev | line source |
---|---|
1993 | 1 // Template array classes |
228 | 2 /* |
3 | |
7017 | 4 Copyright (C) 1993, 1994, 1995, 1996, 1997, 2000, 2001, 2002, 2003, |
5 2004, 2005, 2006, 2007 John W. Eaton | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
6 Copyright (C) 2008 Jaroslav Hajek <highegg@gmail.com> |
228 | 7 |
8 This file is part of Octave. | |
9 | |
10 Octave is free software; you can redistribute it and/or modify it | |
11 under the terms of the GNU General Public License as published by the | |
7016 | 12 Free Software Foundation; either version 3 of the License, or (at your |
13 option) any later version. | |
228 | 14 |
15 Octave is distributed in the hope that it will be useful, but WITHOUT | |
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
18 for more details. | |
19 | |
20 You should have received a copy of the GNU General Public License | |
7016 | 21 along with Octave; see the file COPYING. If not, see |
22 <http://www.gnu.org/licenses/>. | |
228 | 23 |
24 */ | |
25 | |
382 | 26 #if !defined (octave_Array_h) |
27 #define octave_Array_h 1 | |
28 | |
1366 | 29 #include <cassert> |
4152 | 30 #include <cstddef> |
3613 | 31 |
3933 | 32 #include <iostream> |
33 | |
4513 | 34 #include "dim-vector.h" |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
35 #include "idx-vector.h" |
3613 | 36 #include "lo-utils.h" |
7433 | 37 #include "oct-sort.h" |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
38 #include "quit.h" |
7433 | 39 |
1359 | 40 // One dimensional array class. Handles the reference counting for |
41 // all the derived classes. | |
238 | 42 |
228 | 43 template <class T> |
3585 | 44 class |
45 Array | |
228 | 46 { |
3504 | 47 protected: |
1619 | 48 |
4513 | 49 //-------------------------------------------------------------------- |
50 // The real representation of all arrays. | |
51 //-------------------------------------------------------------------- | |
1735 | 52 |
53 class ArrayRep | |
54 { | |
55 public: | |
56 | |
57 T *data; | |
5275 | 58 octave_idx_type len; |
1735 | 59 int count; |
60 | |
5275 | 61 ArrayRep (T *d, octave_idx_type l) : data (d), len (l), count (1) { } |
1735 | 62 |
63 ArrayRep (void) : data (0), len (0), count (1) { } | |
64 | |
5275 | 65 explicit ArrayRep (octave_idx_type n) : data (new T [n]), len (n), count (1) { } |
1735 | 66 |
5275 | 67 explicit ArrayRep (octave_idx_type n, const T& val) |
4513 | 68 : data (new T [n]), len (n), count (1) |
69 { | |
70 fill (val); | |
71 } | |
72 | |
1735 | 73 ArrayRep (const ArrayRep& a) |
74 : data (new T [a.len]), len (a.len), count (1) | |
4513 | 75 { |
5275 | 76 for (octave_idx_type i = 0; i < len; i++) |
4513 | 77 data[i] = a.data[i]; |
78 } | |
4517 | 79 |
1735 | 80 ~ArrayRep (void) { delete [] data; } |
81 | |
5275 | 82 octave_idx_type length (void) const { return len; } |
1735 | 83 |
4513 | 84 void fill (const T& val) |
85 { | |
5275 | 86 for (octave_idx_type i = 0; i < len; i++) |
4513 | 87 data[i] = val; |
88 } | |
89 | |
5275 | 90 T& elem (octave_idx_type n) { return data[n]; } |
1735 | 91 |
5275 | 92 T elem (octave_idx_type n) const { return data[n]; } |
1756 | 93 |
4517 | 94 private: |
95 | |
96 // No assignment! | |
97 | |
98 ArrayRep& operator = (const ArrayRep& a); | |
1735 | 99 }; |
100 | |
4513 | 101 //-------------------------------------------------------------------- |
102 | |
6884 | 103 public: |
104 | |
105 // !!! WARNING !!! -- these should be protected, not public. You | |
106 // should not access these methods directly! | |
107 | |
2006 | 108 void make_unique (void) |
109 { | |
110 if (rep->count > 1) | |
111 { | |
112 --rep->count; | |
113 rep = new ArrayRep (*rep); | |
114 } | |
115 } | |
116 | |
4513 | 117 void make_unique (const T& val) |
118 { | |
119 if (rep->count > 1) | |
120 { | |
121 --rep->count; | |
122 rep = new ArrayRep (rep->length (), val); | |
123 } | |
124 else | |
125 rep->fill (val); | |
126 } | |
238 | 127 |
5900 | 128 typedef T element_type; |
129 | |
4902 | 130 // !!! WARNING !!! -- these should be protected, not public. You |
131 // should not access these data members directly! | |
132 | |
133 typename Array<T>::ArrayRep *rep; | |
4518 | 134 |
4513 | 135 dim_vector dimensions; |
136 | |
4518 | 137 protected: |
138 | |
5275 | 139 Array (T *d, octave_idx_type n) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
140 : rep (new typename Array<T>::ArrayRep (d, n)), dimensions (n) { } |
1619 | 141 |
4587 | 142 Array (T *d, const dim_vector& dv) |
143 : rep (new typename Array<T>::ArrayRep (d, get_size (dv))), | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
144 dimensions (dv) { } |
4513 | 145 |
146 private: | |
147 | |
4585 | 148 typename Array<T>::ArrayRep *nil_rep (void) const |
4513 | 149 { |
150 static typename Array<T>::ArrayRep *nr | |
151 = new typename Array<T>::ArrayRep (); | |
152 | |
153 return nr; | |
1550 | 154 } |
238 | 155 |
4902 | 156 template <class U> |
157 T * | |
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
158 coerce (const U *a, octave_idx_type len) |
4902 | 159 { |
160 T *retval = new T [len]; | |
161 | |
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
162 for (octave_idx_type i = 0; i < len; i++) |
4902 | 163 retval[i] = T (a[i]); |
164 | |
165 return retval; | |
166 } | |
167 | |
228 | 168 public: |
238 | 169 |
1550 | 170 Array (void) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
171 : rep (nil_rep ()), dimensions () { rep->count++; } |
1550 | 172 |
5275 | 173 explicit Array (octave_idx_type n) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
174 : rep (new typename Array<T>::ArrayRep (n)), dimensions (n) { } |
1619 | 175 |
5275 | 176 explicit Array (octave_idx_type n, const T& val) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
177 : rep (new typename Array<T>::ArrayRep (n)), dimensions (n) |
4513 | 178 { |
179 fill (val); | |
180 } | |
181 | |
4902 | 182 // Type conversion case. |
183 template <class U> | |
184 Array (const Array<U>& a) | |
185 : rep (new typename Array<T>::ArrayRep (coerce (a.data (), a.length ()), a.length ())), | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
186 dimensions (a.dimensions) |
4902 | 187 { |
188 } | |
189 | |
190 // No type conversion case. | |
4513 | 191 Array (const Array<T>& a) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
192 : rep (a.rep), dimensions (a.dimensions) |
4513 | 193 { |
194 rep->count++; | |
1550 | 195 } |
196 | |
4513 | 197 public: |
198 | |
4587 | 199 Array (const dim_vector& dv) |
200 : rep (new typename Array<T>::ArrayRep (get_size (dv))), | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
201 dimensions (dv) { } |
238 | 202 |
4587 | 203 Array (const dim_vector& dv, const T& val) |
204 : rep (new typename Array<T>::ArrayRep (get_size (dv))), | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
205 dimensions (dv) |
1550 | 206 { |
4513 | 207 fill (val); |
208 } | |
209 | |
4834 | 210 Array (const Array<T>& a, const dim_vector& dv); |
228 | 211 |
4979 | 212 virtual ~Array (void); |
228 | 213 |
7717
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
214 Array<T>& operator = (const Array<T>& a); |
4513 | 215 |
216 void fill (const T& val) { make_unique (val); } | |
238 | 217 |
5275 | 218 octave_idx_type capacity (void) const { return rep->length (); } |
219 octave_idx_type length (void) const { return capacity (); } | |
220 octave_idx_type nelem (void) const { return capacity (); } | |
221 octave_idx_type numel (void) const { return nelem (); } | |
4513 | 222 |
5275 | 223 octave_idx_type dim1 (void) const { return dimensions(0); } |
224 octave_idx_type dim2 (void) const { return dimensions(1); } | |
225 octave_idx_type dim3 (void) const { return dimensions(2); } | |
4513 | 226 |
5275 | 227 octave_idx_type rows (void) const { return dim1 (); } |
228 octave_idx_type cols (void) const { return dim2 (); } | |
229 octave_idx_type columns (void) const { return dim2 (); } | |
230 octave_idx_type pages (void) const { return dim3 (); } | |
4513 | 231 |
4902 | 232 size_t byte_size (void) const { return numel () * sizeof (T); } |
233 | |
4513 | 234 dim_vector dims (void) const { return dimensions; } |
235 | |
4532 | 236 Array<T> squeeze (void) const; |
4703 | 237 |
238 void chop_trailing_singletons (void) | |
239 { dimensions.chop_trailing_singletons (); } | |
240 | |
5275 | 241 static octave_idx_type get_size (octave_idx_type r, octave_idx_type c); |
242 static octave_idx_type get_size (octave_idx_type r, octave_idx_type c, octave_idx_type p); | |
243 static octave_idx_type get_size (const dim_vector& dv); | |
228 | 244 |
5275 | 245 octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx) const; |
4517 | 246 |
5275 | 247 T range_error (const char *fcn, octave_idx_type n) const; |
248 T& range_error (const char *fcn, octave_idx_type n); | |
3665 | 249 |
5275 | 250 T range_error (const char *fcn, octave_idx_type i, octave_idx_type j) const; |
251 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j); | |
4513 | 252 |
5275 | 253 T range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k) const; |
254 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k); | |
4513 | 255 |
6867 | 256 T range_error (const char *fcn, const Array<octave_idx_type>& ra_idx) const; |
257 T& range_error (const char *fcn, const Array<octave_idx_type>& ra_idx); | |
4513 | 258 |
2108 | 259 // No checking, even for multiple references, ever. |
260 | |
5275 | 261 T& xelem (octave_idx_type n) { return rep->elem (n); } |
262 T xelem (octave_idx_type n) const { return rep->elem (n); } | |
2108 | 263 |
5275 | 264 T& xelem (octave_idx_type i, octave_idx_type j) { return xelem (dim1()*j+i); } |
265 T xelem (octave_idx_type i, octave_idx_type j) const { return xelem (dim1()*j+i); } | |
4513 | 266 |
5275 | 267 T& xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return xelem (i, dim2()*k+j); } |
268 T xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return xelem (i, dim2()*k+j); } | |
4513 | 269 |
6867 | 270 T& xelem (const Array<octave_idx_type>& ra_idx) |
4513 | 271 { return xelem (compute_index (ra_idx)); } |
272 | |
6867 | 273 T xelem (const Array<octave_idx_type>& ra_idx) const |
4513 | 274 { return xelem (compute_index (ra_idx)); } |
275 | |
5775 | 276 // FIXME -- would be nice to fix this so that we don't |
2006 | 277 // unnecessarily force a copy, but that is not so easy, and I see no |
278 // clean way to do it. | |
279 | |
5275 | 280 T& checkelem (octave_idx_type n) |
2006 | 281 { |
282 if (n < 0 || n >= rep->length ()) | |
2109 | 283 return range_error ("T& Array<T>::checkelem", n); |
2006 | 284 else |
2108 | 285 { |
286 make_unique (); | |
287 return xelem (n); | |
288 } | |
2006 | 289 } |
290 | |
5275 | 291 T& checkelem (octave_idx_type i, octave_idx_type j) |
4513 | 292 { |
293 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
294 return range_error ("T& Array<T>::checkelem", i, j); | |
295 else | |
296 return elem (dim1()*j+i); | |
297 } | |
298 | |
5275 | 299 T& checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) |
4513 | 300 { |
301 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
302 return range_error ("T& Array<T>::checkelem", i, j, k); | |
303 else | |
304 return elem (i, dim2()*k+j); | |
305 } | |
306 | |
6867 | 307 T& checkelem (const Array<octave_idx_type>& ra_idx) |
4513 | 308 { |
5275 | 309 octave_idx_type i = compute_index (ra_idx); |
4513 | 310 |
311 if (i < 0) | |
312 return range_error ("T& Array<T>::checkelem", ra_idx); | |
313 else | |
314 return elem (i); | |
315 } | |
316 | |
5275 | 317 T& elem (octave_idx_type n) |
2108 | 318 { |
319 make_unique (); | |
2109 | 320 return xelem (n); |
2108 | 321 } |
2306 | 322 |
5275 | 323 T& elem (octave_idx_type i, octave_idx_type j) { return elem (dim1()*j+i); } |
4513 | 324 |
5275 | 325 T& elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, dim2()*k+j); } |
4513 | 326 |
6867 | 327 T& elem (const Array<octave_idx_type>& ra_idx) |
4513 | 328 { return Array<T>::elem (compute_index (ra_idx)); } |
329 | |
2306 | 330 #if defined (BOUNDS_CHECKING) |
5275 | 331 T& operator () (octave_idx_type n) { return checkelem (n); } |
332 T& operator () (octave_idx_type i, octave_idx_type j) { return checkelem (i, j); } | |
333 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return checkelem (i, j, k); } | |
6867 | 334 T& operator () (const Array<octave_idx_type>& ra_idx) { return checkelem (ra_idx); } |
2306 | 335 #else |
5275 | 336 T& operator () (octave_idx_type n) { return elem (n); } |
337 T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); } | |
338 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, j, k); } | |
6867 | 339 T& operator () (const Array<octave_idx_type>& ra_idx) { return elem (ra_idx); } |
2006 | 340 #endif |
341 | |
5275 | 342 T checkelem (octave_idx_type n) const |
2006 | 343 { |
344 if (n < 0 || n >= rep->length ()) | |
2109 | 345 return range_error ("T Array<T>::checkelem", n); |
2049 | 346 else |
2108 | 347 return xelem (n); |
2006 | 348 } |
1989 | 349 |
5275 | 350 T checkelem (octave_idx_type i, octave_idx_type j) const |
4513 | 351 { |
352 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
353 return range_error ("T Array<T>::checkelem", i, j); | |
354 else | |
355 return elem (dim1()*j+i); | |
356 } | |
357 | |
5275 | 358 T checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const |
4513 | 359 { |
360 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
361 return range_error ("T Array<T>::checkelem", i, j, k); | |
362 else | |
363 return Array<T>::elem (i, Array<T>::dim1()*k+j); | |
364 } | |
365 | |
6867 | 366 T checkelem (const Array<octave_idx_type>& ra_idx) const |
4513 | 367 { |
5275 | 368 octave_idx_type i = compute_index (ra_idx); |
4513 | 369 |
370 if (i < 0) | |
371 return range_error ("T Array<T>::checkelem", ra_idx); | |
372 else | |
373 return Array<T>::elem (i); | |
374 } | |
375 | |
5275 | 376 T elem (octave_idx_type n) const { return xelem (n); } |
2306 | 377 |
5275 | 378 T elem (octave_idx_type i, octave_idx_type j) const { return elem (dim1()*j+i); } |
4513 | 379 |
5275 | 380 T elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, dim2()*k+j); } |
4513 | 381 |
6867 | 382 T elem (const Array<octave_idx_type>& ra_idx) const |
4513 | 383 { return Array<T>::elem (compute_index (ra_idx)); } |
384 | |
2108 | 385 #if defined (BOUNDS_CHECKING) |
5275 | 386 T operator () (octave_idx_type n) const { return checkelem (n); } |
387 T operator () (octave_idx_type i, octave_idx_type j) const { return checkelem (i, j); } | |
388 T operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return checkelem (i, j, k); } | |
6867 | 389 T operator () (const Array<octave_idx_type>& ra_idx) const { return checkelem (ra_idx); } |
2006 | 390 #else |
5275 | 391 T operator () (octave_idx_type n) const { return elem (n); } |
392 T operator () (octave_idx_type i, octave_idx_type j) const { return elem (i, j); } | |
393 T operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, j, k); } | |
6867 | 394 T operator () (const Array<octave_idx_type>& ra_idx) const { return elem (ra_idx); } |
2006 | 395 #endif |
396 | |
4567 | 397 Array<T> reshape (const dim_vector& new_dims) const; |
398 | |
5275 | 399 Array<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const; |
400 Array<T> ipermute (const Array<octave_idx_type>& vec) const | |
4593 | 401 { return permute (vec, true); } |
402 | |
4513 | 403 bool is_square (void) const { return (dim1 () == dim2 ()); } |
404 | |
4559 | 405 bool is_empty (void) const { return numel () == 0; } |
406 | |
4513 | 407 Array<T> transpose (void) const; |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7717
diff
changeset
|
408 Array<T> hermitian (T (*fcn) (const T&) = 0) const; |
238 | 409 |
1550 | 410 const T *data (void) const { return rep->data; } |
228 | 411 |
3952 | 412 const T *fortran_vec (void) const { return data (); } |
413 | |
238 | 414 T *fortran_vec (void); |
1560 | 415 |
4513 | 416 int ndims (void) const { return dimensions.length (); } |
1560 | 417 |
4517 | 418 void maybe_delete_dims (void); |
419 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
420 // Indexing without resizing. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
421 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
422 Array<T> index (const idx_vector& i) const; |
1560 | 423 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
424 Array<T> index (const idx_vector& i, const idx_vector& j) const; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
425 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
426 Array<T> index (const Array<idx_vector>& ia) const; |
1560 | 427 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
428 static T resize_fill_value (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
429 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
430 // Resizing (with fill). |
1560 | 431 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
432 void resize_fill (octave_idx_type n, const T& rfv); |
1560 | 433 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
434 void resize_fill (octave_idx_type nr, octave_idx_type nc, const T& rfv); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
435 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
436 void resize_fill (const dim_vector& dv, const T& rfv); |
1560 | 437 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
438 // Resizing with default fill. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
439 // Rationale: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
440 // These use the default fill value rather than leaving memory uninitialized. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
441 // Resizing without fill leaves the resulting array in a rather weird state, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
442 // where part of the data is initialized an part isn't. |
4513 | 443 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
444 void resize (octave_idx_type n) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
445 { resize_fill (n, resize_fill_value ()); } |
4513 | 446 |
8333 | 447 // FIXME -- this method cannot be defined here because it would |
448 // clash with | |
449 // | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
450 // void resize (octave_idx_type, const T&) |
8333 | 451 // |
452 // (these become indistinguishable when T = octave_idx_type). | |
453 // In the future, I think the resize (.., const T& rfv) overloads | |
454 // should go away in favor of using resize_fill. | |
4513 | 455 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
456 // void resize (octave_idx_type nr, octave_idx_type nc) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
457 // { resize_fill (nr, nc, resize_fill_value ()); } |
4513 | 458 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
459 void resize (dim_vector dv) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
460 { resize_fill (dv, resize_fill_value ()); } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
461 |
8333 | 462 // FIXME -- these are here for backward compatibility. They should |
463 // go away in favor of using resize_fill directly. | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
464 void resize (octave_idx_type n, const T& rfv) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
465 { resize_fill (n, static_cast<T> (rfv)); } |
4513 | 466 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
467 void resize (octave_idx_type nr, octave_idx_type nc, const T& rfv) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
468 { resize_fill (nr, nc, rfv); } |
2382 | 469 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
470 void resize (dim_vector dv, const T& rfv) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
471 { resize_fill (dv, rfv); } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
472 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
473 // Indexing with possible resizing and fill |
8333 | 474 // FIXME -- this is really a corner case, that should better be |
475 // handled directly in liboctinterp. | |
3933 | 476 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
477 Array<T> index (const idx_vector& i, bool resize_ok, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
478 const T& rfv = resize_fill_value ()) const; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
479 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
480 Array<T> index (const idx_vector& i, const idx_vector& j, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
481 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
4513 | 482 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
483 Array<T> index (const Array<idx_vector>& ia, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
484 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
485 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
486 // Indexed assignment (always with resize & fill). |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
487 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
488 void assign (const idx_vector& i, const Array<T>& rhs, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
489 const T& rfv = resize_fill_value ()); |
4513 | 490 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
491 void assign (const idx_vector& i, const idx_vector& j, const Array<T>& rhs, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
492 const T& rfv = resize_fill_value ()); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
493 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
494 void assign (const Array<idx_vector>& ia, const Array<T>& rhs, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
495 const T& rfv = resize_fill_value ()); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
496 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
497 // Deleting elements. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
498 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
499 // A(I) = [] (with a single subscript) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
500 void delete_elements (const idx_vector& i); |
4530 | 501 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
502 // A(:,...,I,...,:) = [] (>= 2 subscripts, one of them is non-colon) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
503 void delete_elements (int dim, const idx_vector& i); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
504 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
505 // Dispatcher to the above two. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
506 void delete_elements (const Array<idx_vector>& ia); |
4513 | 507 |
8333 | 508 // FIXME -- are these required? What exactly are they supposed to do?. |
3928 | 509 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
510 Array<T>& insert (const Array<T>& a, octave_idx_type r, octave_idx_type c); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
511 Array<T>& insert2 (const Array<T>& a, octave_idx_type r, octave_idx_type c); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
512 Array<T>& insertN (const Array<T>& a, octave_idx_type r, octave_idx_type c); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
513 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
514 Array<T>& insert (const Array<T>& a, const Array<octave_idx_type>& idx); |
3933 | 515 |
4517 | 516 void print_info (std::ostream& os, const std::string& prefix) const; |
5900 | 517 |
518 // Unsafe. This function exists to support the MEX interface. | |
519 // You should not use it anywhere else. | |
520 void *mex_get_data (void) const { return const_cast<T *> (data ()); } | |
7433 | 521 |
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
522 Array<T> sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const; |
7433 | 523 Array<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
|
524 sortmode mode = ASCENDING) const; |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
525 |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
526 Array<T> diag (octave_idx_type k = 0) const; |
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
527 |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
528 template <class U, class F> |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
529 Array<U> |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
530 map (F fcn) const |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
531 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
532 octave_idx_type len = length (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
533 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
534 const T *m = data (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
535 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
536 Array<U> result (dims ()); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
537 U *p = result.fortran_vec (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
538 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
539 for (octave_idx_type i = 0; i < len; i++) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
540 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
541 OCTAVE_QUIT; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
542 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
543 p[i] = fcn (m[i]); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
544 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
545 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
546 return result; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
547 } |
4513 | 548 }; |
4459 | 549 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
550 #define INSTANTIATE_ARRAY(T, API) \ |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
551 template class API Array<T> |
4518 | 552 |
8333 | 553 // FIXME -- these are here for compatibility. In the current |
554 // implementation, only homogeneous array assignments are actually | |
555 // instantiated. I think heterogeneous indexed assignments are rare | |
556 // enough to be implemented via conversion first. This decision may | |
557 // still be revised, that's why these macros stay here. | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
558 #define INSTANTIATE_ARRAY_AND_ASSIGN(T, API) \ |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
559 INSTANTIATE_ARRAY(T, API) |
1560 | 560 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
561 #define INSTANTIATE_ARRAY_ASSIGN(LT, RT, API) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
562 // do nothing |
4594 | 563 |
7433 | 564 #define INSTANTIATE_ARRAY_SORT(T) \ |
565 template class octave_sort<T>; \ | |
566 template class vec_index<T>; \ | |
567 template class octave_sort<vec_index<T> *>; | |
568 | |
569 #define NO_INSTANTIATE_ARRAY_SORT(T) \ | |
570 template class vec_index<T>; \ | |
571 template <> bool ascending_compare (T, T) { return true; } \ | |
572 template <> bool ascending_compare (vec_index<T> *, vec_index<T> *) \ | |
573 { return true; } \ | |
574 template <> bool descending_compare (T, T) { return true; } \ | |
575 template <> bool descending_compare (vec_index<T> *, vec_index<T> *) \ | |
576 { return true; } \ | |
577 template <> Array<T> Array<T>::sort \ | |
578 (octave_idx_type, sortmode) const { return *this; } \ | |
579 template <> Array<T> Array<T>::sort (Array<octave_idx_type> &sidx, \ | |
580 octave_idx_type, sortmode) const \ | |
581 { sidx = Array<octave_idx_type> (); return *this; } | |
582 | |
228 | 583 #endif |
584 | |
585 /* | |
586 ;;; Local Variables: *** | |
587 ;;; mode: C++ *** | |
588 ;;; End: *** | |
589 */ |