Mercurial > octave-dspies
annotate liboctave/Array.h @ 8290:7cbe01c21986
improve dense array indexing
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Mon, 20 Oct 2008 16:54:28 +0200 |
| parents | 6c08e3921d3e |
| children | 9238637cb81c |
| 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 |
| 94 void qsort (int (*compare) (const void *, const void *)) | |
| 95 { | |
| 3613 | 96 octave_qsort (data, static_cast<size_t> (len), sizeof (T), compare); |
| 1756 | 97 } |
| 4517 | 98 |
| 99 private: | |
| 100 | |
| 101 // No assignment! | |
| 102 | |
| 103 ArrayRep& operator = (const ArrayRep& a); | |
| 1735 | 104 }; |
| 105 | |
| 4513 | 106 //-------------------------------------------------------------------- |
| 107 | |
| 6884 | 108 public: |
| 109 | |
| 110 // !!! WARNING !!! -- these should be protected, not public. You | |
| 111 // should not access these methods directly! | |
| 112 | |
| 2006 | 113 void make_unique (void) |
| 114 { | |
| 115 if (rep->count > 1) | |
| 116 { | |
| 117 --rep->count; | |
| 118 rep = new ArrayRep (*rep); | |
| 119 } | |
| 120 } | |
| 121 | |
| 4513 | 122 void make_unique (const T& val) |
| 123 { | |
| 124 if (rep->count > 1) | |
| 125 { | |
| 126 --rep->count; | |
| 127 rep = new ArrayRep (rep->length (), val); | |
| 128 } | |
| 129 else | |
| 130 rep->fill (val); | |
| 131 } | |
| 238 | 132 |
| 5900 | 133 typedef T element_type; |
| 134 | |
| 4902 | 135 // !!! WARNING !!! -- these should be protected, not public. You |
| 136 // should not access these data members directly! | |
| 137 | |
| 138 typename Array<T>::ArrayRep *rep; | |
| 4518 | 139 |
| 4513 | 140 dim_vector dimensions; |
| 141 | |
| 4518 | 142 protected: |
| 143 | |
| 5275 | 144 Array (T *d, octave_idx_type n) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
145 : rep (new typename Array<T>::ArrayRep (d, n)), dimensions (n) { } |
| 1619 | 146 |
| 4587 | 147 Array (T *d, const dim_vector& dv) |
| 148 : 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
|
149 dimensions (dv) { } |
| 4513 | 150 |
| 151 private: | |
| 152 | |
| 4585 | 153 typename Array<T>::ArrayRep *nil_rep (void) const |
| 4513 | 154 { |
| 155 static typename Array<T>::ArrayRep *nr | |
| 156 = new typename Array<T>::ArrayRep (); | |
| 157 | |
| 158 return nr; | |
| 1550 | 159 } |
| 238 | 160 |
| 4902 | 161 template <class U> |
| 162 T * | |
|
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
163 coerce (const U *a, octave_idx_type len) |
| 4902 | 164 { |
| 165 T *retval = new T [len]; | |
| 166 | |
|
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
167 for (octave_idx_type i = 0; i < len; i++) |
| 4902 | 168 retval[i] = T (a[i]); |
| 169 | |
| 170 return retval; | |
| 171 } | |
| 172 | |
| 228 | 173 public: |
| 238 | 174 |
| 1550 | 175 Array (void) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
176 : rep (nil_rep ()), dimensions () { rep->count++; } |
| 1550 | 177 |
| 5275 | 178 explicit Array (octave_idx_type n) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
179 : rep (new typename Array<T>::ArrayRep (n)), dimensions (n) { } |
| 1619 | 180 |
| 5275 | 181 explicit Array (octave_idx_type n, const T& val) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
182 : rep (new typename Array<T>::ArrayRep (n)), dimensions (n) |
| 4513 | 183 { |
| 184 fill (val); | |
| 185 } | |
| 186 | |
| 4902 | 187 // Type conversion case. |
| 188 template <class U> | |
| 189 Array (const Array<U>& a) | |
| 190 : 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
|
191 dimensions (a.dimensions) |
| 4902 | 192 { |
| 193 } | |
| 194 | |
| 195 // No type conversion case. | |
| 4513 | 196 Array (const Array<T>& a) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
197 : rep (a.rep), dimensions (a.dimensions) |
| 4513 | 198 { |
| 199 rep->count++; | |
| 1550 | 200 } |
| 201 | |
| 4513 | 202 public: |
| 203 | |
| 4587 | 204 Array (const dim_vector& dv) |
| 205 : rep (new typename Array<T>::ArrayRep (get_size (dv))), | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
206 dimensions (dv) { } |
| 238 | 207 |
| 4587 | 208 Array (const dim_vector& dv, const T& val) |
| 209 : rep (new typename Array<T>::ArrayRep (get_size (dv))), | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
210 dimensions (dv) |
| 1550 | 211 { |
| 4513 | 212 fill (val); |
| 213 } | |
| 214 | |
| 4834 | 215 Array (const Array<T>& a, const dim_vector& dv); |
| 228 | 216 |
| 4979 | 217 virtual ~Array (void); |
| 228 | 218 |
|
7717
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
219 Array<T>& operator = (const Array<T>& a); |
| 4513 | 220 |
| 221 void fill (const T& val) { make_unique (val); } | |
| 238 | 222 |
| 5275 | 223 octave_idx_type capacity (void) const { return rep->length (); } |
| 224 octave_idx_type length (void) const { return capacity (); } | |
| 225 octave_idx_type nelem (void) const { return capacity (); } | |
| 226 octave_idx_type numel (void) const { return nelem (); } | |
| 4513 | 227 |
| 5275 | 228 octave_idx_type dim1 (void) const { return dimensions(0); } |
| 229 octave_idx_type dim2 (void) const { return dimensions(1); } | |
| 230 octave_idx_type dim3 (void) const { return dimensions(2); } | |
| 4513 | 231 |
| 5275 | 232 octave_idx_type rows (void) const { return dim1 (); } |
| 233 octave_idx_type cols (void) const { return dim2 (); } | |
| 234 octave_idx_type columns (void) const { return dim2 (); } | |
| 235 octave_idx_type pages (void) const { return dim3 (); } | |
| 4513 | 236 |
| 4902 | 237 size_t byte_size (void) const { return numel () * sizeof (T); } |
| 238 | |
| 4513 | 239 dim_vector dims (void) const { return dimensions; } |
| 240 | |
| 4532 | 241 Array<T> squeeze (void) const; |
| 4703 | 242 |
| 243 void chop_trailing_singletons (void) | |
| 244 { dimensions.chop_trailing_singletons (); } | |
| 245 | |
| 5275 | 246 static octave_idx_type get_size (octave_idx_type r, octave_idx_type c); |
| 247 static octave_idx_type get_size (octave_idx_type r, octave_idx_type c, octave_idx_type p); | |
| 248 static octave_idx_type get_size (const dim_vector& dv); | |
| 228 | 249 |
| 5275 | 250 octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx) const; |
| 4517 | 251 |
| 5275 | 252 T range_error (const char *fcn, octave_idx_type n) const; |
| 253 T& range_error (const char *fcn, octave_idx_type n); | |
| 3665 | 254 |
| 5275 | 255 T range_error (const char *fcn, octave_idx_type i, octave_idx_type j) const; |
| 256 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j); | |
| 4513 | 257 |
| 5275 | 258 T range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k) const; |
| 259 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k); | |
| 4513 | 260 |
| 6867 | 261 T range_error (const char *fcn, const Array<octave_idx_type>& ra_idx) const; |
| 262 T& range_error (const char *fcn, const Array<octave_idx_type>& ra_idx); | |
| 4513 | 263 |
| 2108 | 264 // No checking, even for multiple references, ever. |
| 265 | |
| 5275 | 266 T& xelem (octave_idx_type n) { return rep->elem (n); } |
| 267 T xelem (octave_idx_type n) const { return rep->elem (n); } | |
| 2108 | 268 |
| 5275 | 269 T& xelem (octave_idx_type i, octave_idx_type j) { return xelem (dim1()*j+i); } |
| 270 T xelem (octave_idx_type i, octave_idx_type j) const { return xelem (dim1()*j+i); } | |
| 4513 | 271 |
| 5275 | 272 T& xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return xelem (i, dim2()*k+j); } |
| 273 T xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return xelem (i, dim2()*k+j); } | |
| 4513 | 274 |
| 6867 | 275 T& xelem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 276 { return xelem (compute_index (ra_idx)); } |
| 277 | |
| 6867 | 278 T xelem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 279 { return xelem (compute_index (ra_idx)); } |
| 280 | |
| 5775 | 281 // FIXME -- would be nice to fix this so that we don't |
| 2006 | 282 // unnecessarily force a copy, but that is not so easy, and I see no |
| 283 // clean way to do it. | |
| 284 | |
| 5275 | 285 T& checkelem (octave_idx_type n) |
| 2006 | 286 { |
| 287 if (n < 0 || n >= rep->length ()) | |
| 2109 | 288 return range_error ("T& Array<T>::checkelem", n); |
| 2006 | 289 else |
| 2108 | 290 { |
| 291 make_unique (); | |
| 292 return xelem (n); | |
| 293 } | |
| 2006 | 294 } |
| 295 | |
| 5275 | 296 T& checkelem (octave_idx_type i, octave_idx_type j) |
| 4513 | 297 { |
| 298 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
| 299 return range_error ("T& Array<T>::checkelem", i, j); | |
| 300 else | |
| 301 return elem (dim1()*j+i); | |
| 302 } | |
| 303 | |
| 5275 | 304 T& checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) |
| 4513 | 305 { |
| 306 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
| 307 return range_error ("T& Array<T>::checkelem", i, j, k); | |
| 308 else | |
| 309 return elem (i, dim2()*k+j); | |
| 310 } | |
| 311 | |
| 6867 | 312 T& checkelem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 313 { |
| 5275 | 314 octave_idx_type i = compute_index (ra_idx); |
| 4513 | 315 |
| 316 if (i < 0) | |
| 317 return range_error ("T& Array<T>::checkelem", ra_idx); | |
| 318 else | |
| 319 return elem (i); | |
| 320 } | |
| 321 | |
| 5275 | 322 T& elem (octave_idx_type n) |
| 2108 | 323 { |
| 324 make_unique (); | |
| 2109 | 325 return xelem (n); |
| 2108 | 326 } |
| 2306 | 327 |
| 5275 | 328 T& elem (octave_idx_type i, octave_idx_type j) { return elem (dim1()*j+i); } |
| 4513 | 329 |
| 5275 | 330 T& elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, dim2()*k+j); } |
| 4513 | 331 |
| 6867 | 332 T& elem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 333 { return Array<T>::elem (compute_index (ra_idx)); } |
| 334 | |
| 2306 | 335 #if defined (BOUNDS_CHECKING) |
| 5275 | 336 T& operator () (octave_idx_type n) { return checkelem (n); } |
| 337 T& operator () (octave_idx_type i, octave_idx_type j) { return checkelem (i, j); } | |
| 338 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return checkelem (i, j, k); } | |
| 6867 | 339 T& operator () (const Array<octave_idx_type>& ra_idx) { return checkelem (ra_idx); } |
| 2306 | 340 #else |
| 5275 | 341 T& operator () (octave_idx_type n) { return elem (n); } |
| 342 T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); } | |
| 343 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, j, k); } | |
| 6867 | 344 T& operator () (const Array<octave_idx_type>& ra_idx) { return elem (ra_idx); } |
| 2006 | 345 #endif |
| 346 | |
| 5275 | 347 T checkelem (octave_idx_type n) const |
| 2006 | 348 { |
| 349 if (n < 0 || n >= rep->length ()) | |
| 2109 | 350 return range_error ("T Array<T>::checkelem", n); |
| 2049 | 351 else |
| 2108 | 352 return xelem (n); |
| 2006 | 353 } |
| 1989 | 354 |
| 5275 | 355 T checkelem (octave_idx_type i, octave_idx_type j) const |
| 4513 | 356 { |
| 357 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
| 358 return range_error ("T Array<T>::checkelem", i, j); | |
| 359 else | |
| 360 return elem (dim1()*j+i); | |
| 361 } | |
| 362 | |
| 5275 | 363 T checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const |
| 4513 | 364 { |
| 365 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
| 366 return range_error ("T Array<T>::checkelem", i, j, k); | |
| 367 else | |
| 368 return Array<T>::elem (i, Array<T>::dim1()*k+j); | |
| 369 } | |
| 370 | |
| 6867 | 371 T checkelem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 372 { |
| 5275 | 373 octave_idx_type i = compute_index (ra_idx); |
| 4513 | 374 |
| 375 if (i < 0) | |
| 376 return range_error ("T Array<T>::checkelem", ra_idx); | |
| 377 else | |
| 378 return Array<T>::elem (i); | |
| 379 } | |
| 380 | |
| 5275 | 381 T elem (octave_idx_type n) const { return xelem (n); } |
| 2306 | 382 |
| 5275 | 383 T elem (octave_idx_type i, octave_idx_type j) const { return elem (dim1()*j+i); } |
| 4513 | 384 |
| 5275 | 385 T elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, dim2()*k+j); } |
| 4513 | 386 |
| 6867 | 387 T elem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 388 { return Array<T>::elem (compute_index (ra_idx)); } |
| 389 | |
| 2108 | 390 #if defined (BOUNDS_CHECKING) |
| 5275 | 391 T operator () (octave_idx_type n) const { return checkelem (n); } |
| 392 T operator () (octave_idx_type i, octave_idx_type j) const { return checkelem (i, j); } | |
| 393 T operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return checkelem (i, j, k); } | |
| 6867 | 394 T operator () (const Array<octave_idx_type>& ra_idx) const { return checkelem (ra_idx); } |
| 2006 | 395 #else |
| 5275 | 396 T operator () (octave_idx_type n) const { return elem (n); } |
| 397 T operator () (octave_idx_type i, octave_idx_type j) const { return elem (i, j); } | |
| 398 T operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, j, k); } | |
| 6867 | 399 T operator () (const Array<octave_idx_type>& ra_idx) const { return elem (ra_idx); } |
| 2006 | 400 #endif |
| 401 | |
| 4567 | 402 Array<T> reshape (const dim_vector& new_dims) const; |
| 403 | |
| 5275 | 404 Array<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const; |
| 405 Array<T> ipermute (const Array<octave_idx_type>& vec) const | |
| 4593 | 406 { return permute (vec, true); } |
| 407 | |
| 4513 | 408 bool is_square (void) const { return (dim1 () == dim2 ()); } |
| 409 | |
| 4559 | 410 bool is_empty (void) const { return numel () == 0; } |
| 411 | |
| 4513 | 412 Array<T> transpose (void) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7717
diff
changeset
|
413 Array<T> hermitian (T (*fcn) (const T&) = 0) const; |
| 238 | 414 |
| 1550 | 415 const T *data (void) const { return rep->data; } |
| 228 | 416 |
| 3952 | 417 const T *fortran_vec (void) const { return data (); } |
| 418 | |
| 238 | 419 T *fortran_vec (void); |
| 1560 | 420 |
| 1781 | 421 Array<T>& qsort (int (*compare) (const void *, const void *)) |
| 1756 | 422 { |
| 2347 | 423 make_unique (); |
| 1756 | 424 |
| 425 rep->qsort (compare); | |
| 1781 | 426 |
| 427 return *this; | |
| 1756 | 428 } |
| 429 | |
| 4513 | 430 int ndims (void) const { return dimensions.length (); } |
| 1560 | 431 |
| 4517 | 432 void maybe_delete_dims (void); |
| 433 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
434 // Indexing without resizing. |
|
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 Array<T> index (const idx_vector& i) const; |
| 1560 | 437 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
438 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
|
439 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
440 Array<T> index (const Array<idx_vector>& ia) const; |
| 1560 | 441 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
442 static T resize_fill_value (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
443 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
444 // Resizing (with fill). |
| 1560 | 445 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
446 void resize_fill (octave_idx_type n, const T& rfv); |
| 1560 | 447 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
448 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
|
449 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
450 void resize_fill (const dim_vector& dv, const T& rfv); |
| 1560 | 451 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
452 // Resizing with default fill. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
453 // Rationale: |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
454 // 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
|
455 // 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
|
456 // where part of the data is initialized an part isn't. |
| 4513 | 457 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
458 void resize (octave_idx_type n) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
459 { resize_fill (n, resize_fill_value ()); } |
| 4513 | 460 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
461 // FIXME: This method cannot be defined here because it would clash with |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
462 // void resize (octave_idx_type, const T&) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
463 // (these become undistinguishable when T = octave_idx_type). |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
464 // In the future, I think the resize (.., const T& rfv) overloads should go away |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
465 // in favor of using resize_fill. |
| 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) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
468 // { resize_fill (nr, nc, resize_fill_value ()); } |
| 4513 | 469 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
470 void resize (dim_vector dv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
471 { resize_fill (dv, resize_fill_value ()); } |
|
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 // FIXME: these are here for backward compatibility. They should go away in favor |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
474 // of using resize_fill directly. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
475 void resize (octave_idx_type n, const T& rfv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
476 { resize_fill (n, static_cast<T> (rfv)); } |
| 4513 | 477 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
478 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
|
479 { resize_fill (nr, nc, rfv); } |
| 2382 | 480 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
481 void resize (dim_vector dv, const T& rfv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
482 { resize_fill (dv, rfv); } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
483 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
484 // Indexing with possible resizing and fill |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
485 // FIXME: This is really a corner case, that should better be handled |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
486 // directly in liboctinterp. |
| 3933 | 487 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
488 Array<T> index (const idx_vector& i, bool resize_ok, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
489 const T& rfv = resize_fill_value ()) const; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
490 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
491 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
|
492 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
| 4513 | 493 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
494 Array<T> index (const Array<idx_vector>& ia, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
495 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
|
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 // Indexed assignment (always with resize & fill). |
|
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 void assign (const idx_vector& i, const Array<T>& rhs, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
500 const T& rfv = resize_fill_value ()); |
| 4513 | 501 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
502 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
|
503 const T& rfv = resize_fill_value ()); |
|
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 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
|
506 const T& rfv = resize_fill_value ()); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
507 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
508 // Deleting elements. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
509 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
510 // A(I) = [] (with a single subscript) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
511 void delete_elements (const idx_vector& i); |
| 4530 | 512 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
513 // A(:,...,I,...,:) = [] (>= 2 subscripts, one of them is non-colon) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
514 void delete_elements (int dim, const idx_vector& i); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
515 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
516 // Dispatcher to the above two. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
517 void delete_elements (const Array<idx_vector>& ia); |
| 4513 | 518 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
519 // FIXME: are these required? What exactly are they supposed to do?. |
| 3928 | 520 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
521 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
|
522 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
|
523 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
|
524 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
525 Array<T>& insert (const Array<T>& a, const Array<octave_idx_type>& idx); |
| 3933 | 526 |
| 4517 | 527 void print_info (std::ostream& os, const std::string& prefix) const; |
| 5900 | 528 |
| 529 // Unsafe. This function exists to support the MEX interface. | |
| 530 // You should not use it anywhere else. | |
| 531 void *mex_get_data (void) const { return const_cast<T *> (data ()); } | |
| 7433 | 532 |
|
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
533 Array<T> sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const; |
| 7433 | 534 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
|
535 sortmode mode = ASCENDING) const; |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
536 |
|
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
537 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
|
538 |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
539 template <class U, class F> |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
540 Array<U> |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
541 map (F fcn) const |
|
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 octave_idx_type len = length (); |
|
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 const T *m = data (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
546 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
547 Array<U> result (dims ()); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
548 U *p = result.fortran_vec (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
549 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
550 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
|
551 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
552 OCTAVE_QUIT; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
553 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
554 p[i] = fcn (m[i]); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
555 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
556 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
557 return result; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
558 } |
| 4513 | 559 }; |
| 4459 | 560 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
561 #define INSTANTIATE_ARRAY(T, API) \ |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
562 template class API Array<T> |
| 4518 | 563 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
564 // FIXME: These are here for compatibility. In current implementation, only |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
565 // homogeneous array assignments are actually instantiated. I think heterogeneous |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
566 // indexed assignments are rare enough to be implemented via conversion first. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
567 // This decision may still be revised, that's why these macros stay here. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
568 #define INSTANTIATE_ARRAY_AND_ASSIGN(T, API) \ |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
569 INSTANTIATE_ARRAY(T, API) |
| 1560 | 570 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
571 #define INSTANTIATE_ARRAY_ASSIGN(LT, RT, API) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
572 // do nothing |
| 4594 | 573 |
| 7433 | 574 #define INSTANTIATE_ARRAY_SORT(T) \ |
| 575 template class octave_sort<T>; \ | |
| 576 template class vec_index<T>; \ | |
| 577 template class octave_sort<vec_index<T> *>; | |
| 578 | |
| 579 #define NO_INSTANTIATE_ARRAY_SORT(T) \ | |
| 580 template class vec_index<T>; \ | |
| 581 template <> bool ascending_compare (T, T) { return true; } \ | |
| 582 template <> bool ascending_compare (vec_index<T> *, vec_index<T> *) \ | |
| 583 { return true; } \ | |
| 584 template <> bool descending_compare (T, T) { return true; } \ | |
| 585 template <> bool descending_compare (vec_index<T> *, vec_index<T> *) \ | |
| 586 { return true; } \ | |
| 587 template <> Array<T> Array<T>::sort \ | |
| 588 (octave_idx_type, sortmode) const { return *this; } \ | |
| 589 template <> Array<T> Array<T>::sort (Array<octave_idx_type> &sidx, \ | |
| 590 octave_idx_type, sortmode) const \ | |
| 591 { sidx = Array<octave_idx_type> (); return *this; } | |
| 592 | |
| 228 | 593 #endif |
| 594 | |
| 595 /* | |
| 596 ;;; Local Variables: *** | |
| 597 ;;; mode: C++ *** | |
| 598 ;;; End: *** | |
| 599 */ |