Mercurial > octave-dspies
annotate liboctave/Array.h @ 9341:9fd5c56ce57a
extend lookup capabilities
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Fri, 12 Jun 2009 16:01:53 +0200 |
| parents | 472f0e22aa60 |
| children | 1beb23d2b892 |
| rev | line source |
|---|---|
| 1993 | 1 // Template array classes |
| 228 | 2 /* |
| 3 | |
| 8920 | 4 Copyright (C) 2008, 2009 Jaroslav Hajek |
| 7017 | 5 Copyright (C) 1993, 1994, 1995, 1996, 1997, 2000, 2001, 2002, 2003, |
| 6 2004, 2005, 2006, 2007 John W. Eaton | |
| 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 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
32 #include <algorithm> |
|
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
33 #include <iosfwd> |
| 3933 | 34 |
| 4513 | 35 #include "dim-vector.h" |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
36 #include "idx-vector.h" |
| 8725 | 37 #include "lo-traits.h" |
| 3613 | 38 #include "lo-utils.h" |
| 7433 | 39 #include "oct-sort.h" |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
40 #include "quit.h" |
| 7433 | 41 |
| 1359 | 42 // One dimensional array class. Handles the reference counting for |
| 43 // all the derived classes. | |
| 238 | 44 |
| 228 | 45 template <class T> |
| 3585 | 46 class |
| 47 Array | |
| 228 | 48 { |
| 3504 | 49 protected: |
| 1619 | 50 |
| 4513 | 51 //-------------------------------------------------------------------- |
| 52 // The real representation of all arrays. | |
| 53 //-------------------------------------------------------------------- | |
| 1735 | 54 |
| 55 class ArrayRep | |
| 56 { | |
| 57 public: | |
| 58 | |
| 59 T *data; | |
| 5275 | 60 octave_idx_type len; |
| 1735 | 61 int count; |
| 62 | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
63 ArrayRep (T *d, octave_idx_type l, bool copy = false) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
64 : data (copy ? new T [l] : d), len (l), count (1) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
65 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
66 if (copy) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
67 std::copy (d, d + l, data); |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
68 } |
| 1735 | 69 |
| 70 ArrayRep (void) : data (0), len (0), count (1) { } | |
| 71 | |
| 5275 | 72 explicit ArrayRep (octave_idx_type n) : data (new T [n]), len (n), count (1) { } |
| 1735 | 73 |
| 5275 | 74 explicit ArrayRep (octave_idx_type n, const T& val) |
| 4513 | 75 : data (new T [n]), len (n), count (1) |
| 76 { | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
77 std::fill (data, data + n, val); |
| 4513 | 78 } |
| 79 | |
| 1735 | 80 ArrayRep (const ArrayRep& a) |
| 81 : data (new T [a.len]), len (a.len), count (1) | |
| 4513 | 82 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
83 std::copy (a.data, a.data + a.len, data); |
| 4513 | 84 } |
| 4517 | 85 |
| 1735 | 86 ~ArrayRep (void) { delete [] data; } |
| 87 | |
| 5275 | 88 octave_idx_type length (void) const { return len; } |
| 1735 | 89 |
| 4517 | 90 private: |
| 91 | |
| 92 // No assignment! | |
| 93 | |
| 94 ArrayRep& operator = (const ArrayRep& a); | |
| 1735 | 95 }; |
| 96 | |
| 4513 | 97 //-------------------------------------------------------------------- |
| 98 | |
| 6884 | 99 public: |
| 100 | |
|
8524
937921654627
clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
101 void make_unique (void); |
| 238 | 102 |
| 5900 | 103 typedef T element_type; |
| 104 | |
| 8725 | 105 typedef bool (*compare_fcn_type) (typename ref_param<T>::type, |
| 106 typename ref_param<T>::type); | |
| 107 | |
|
8524
937921654627
clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
108 protected: |
| 4902 | 109 |
| 110 typename Array<T>::ArrayRep *rep; | |
| 4518 | 111 |
| 4513 | 112 dim_vector dimensions; |
| 113 | |
|
8531
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
114 // Rationale: |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
115 // slice_data is a pointer to rep->data, denoting together with slice_len the |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
116 // actual portion of the data referenced by this Array<T> object. This allows |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
117 // to make shallow copies not only of a whole array, but also of contiguous |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
118 // subranges. Every time rep is directly manipulated, slice_data and slice_len |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
119 // need to be properly updated. |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
120 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
121 T* slice_data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
122 octave_idx_type slice_len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
123 |
| 5275 | 124 Array (T *d, octave_idx_type n) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
125 : rep (new typename Array<T>::ArrayRep (d, n)), dimensions (n) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
126 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
127 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
128 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
129 } |
| 1619 | 130 |
| 4587 | 131 Array (T *d, const dim_vector& dv) |
| 132 : rep (new typename Array<T>::ArrayRep (d, get_size (dv))), | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
133 dimensions (dv) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
134 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
135 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
136 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
137 } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
138 |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
139 // slice constructor |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
140 Array (const Array<T>& a, const dim_vector& dv, |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
141 octave_idx_type l, octave_idx_type u) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
142 : rep(a.rep), dimensions (dv) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
143 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
144 rep->count++; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
145 slice_data = a.slice_data + l; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
146 slice_len = std::min (u, a.slice_len) - l; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
147 } |
| 4513 | 148 |
| 149 private: | |
| 150 | |
| 4585 | 151 typename Array<T>::ArrayRep *nil_rep (void) const |
| 4513 | 152 { |
| 153 static typename Array<T>::ArrayRep *nr | |
| 154 = new typename Array<T>::ArrayRep (); | |
| 155 | |
| 156 return nr; | |
| 1550 | 157 } |
| 238 | 158 |
| 4902 | 159 template <class U> |
| 160 T * | |
|
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
161 coerce (const U *a, octave_idx_type len) |
| 4902 | 162 { |
| 163 T *retval = new T [len]; | |
| 164 | |
|
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
165 for (octave_idx_type i = 0; i < len; i++) |
| 4902 | 166 retval[i] = T (a[i]); |
| 167 | |
| 168 return retval; | |
| 169 } | |
| 170 | |
| 228 | 171 public: |
| 238 | 172 |
| 1550 | 173 Array (void) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
174 : rep (nil_rep ()), dimensions () |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
175 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
176 rep->count++; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
177 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
178 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
179 } |
| 1550 | 180 |
| 5275 | 181 explicit Array (octave_idx_type n) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
182 : rep (new typename Array<T>::ArrayRep (n)), dimensions (n) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
183 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
184 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
185 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
186 } |
| 1619 | 187 |
| 5275 | 188 explicit Array (octave_idx_type n, const T& val) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
189 : rep (new typename Array<T>::ArrayRep (n)), dimensions (n) |
| 4513 | 190 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
191 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
192 slice_len = rep->len; |
| 4513 | 193 fill (val); |
| 194 } | |
| 195 | |
| 4902 | 196 // Type conversion case. |
| 197 template <class U> | |
| 198 Array (const Array<U>& a) | |
| 199 : rep (new typename Array<T>::ArrayRep (coerce (a.data (), a.length ()), a.length ())), | |
|
8524
937921654627
clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
200 dimensions (a.dims ()) |
| 4902 | 201 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
202 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
203 slice_len = rep->len; |
| 4902 | 204 } |
| 205 | |
| 206 // No type conversion case. | |
| 4513 | 207 Array (const Array<T>& a) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
208 : rep (a.rep), dimensions (a.dimensions) |
| 4513 | 209 { |
| 210 rep->count++; | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
211 slice_data = a.slice_data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
212 slice_len = a.slice_len; |
| 1550 | 213 } |
| 214 | |
| 4513 | 215 public: |
| 216 | |
| 4587 | 217 Array (const dim_vector& dv) |
| 218 : rep (new typename Array<T>::ArrayRep (get_size (dv))), | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
219 dimensions (dv) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
220 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
221 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
222 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
223 } |
| 238 | 224 |
| 4587 | 225 Array (const dim_vector& dv, const T& val) |
| 226 : rep (new typename Array<T>::ArrayRep (get_size (dv))), | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
227 dimensions (dv) |
| 1550 | 228 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
229 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
230 slice_len = rep->len; |
| 4513 | 231 fill (val); |
| 232 } | |
| 233 | |
| 4834 | 234 Array (const Array<T>& a, const dim_vector& dv); |
| 228 | 235 |
| 4979 | 236 virtual ~Array (void); |
| 228 | 237 |
|
7717
ff918ee1a983
Delete idx in Sparse<T> and Array<T> operator =
David Bateman <dbateman@free.fr>
parents:
7620
diff
changeset
|
238 Array<T>& operator = (const Array<T>& a); |
| 4513 | 239 |
|
8524
937921654627
clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
240 void fill (const T& val); |
| 238 | 241 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
242 octave_idx_type capacity (void) const { return slice_len; } |
| 5275 | 243 octave_idx_type length (void) const { return capacity (); } |
| 244 octave_idx_type nelem (void) const { return capacity (); } | |
| 245 octave_idx_type numel (void) const { return nelem (); } | |
| 4513 | 246 |
| 5275 | 247 octave_idx_type dim1 (void) const { return dimensions(0); } |
| 248 octave_idx_type dim2 (void) const { return dimensions(1); } | |
| 249 octave_idx_type dim3 (void) const { return dimensions(2); } | |
| 4513 | 250 |
| 5275 | 251 octave_idx_type rows (void) const { return dim1 (); } |
| 252 octave_idx_type cols (void) const { return dim2 (); } | |
| 253 octave_idx_type columns (void) const { return dim2 (); } | |
| 254 octave_idx_type pages (void) const { return dim3 (); } | |
| 4513 | 255 |
| 4902 | 256 size_t byte_size (void) const { return numel () * sizeof (T); } |
| 257 | |
|
9026
6890d411a0b8
adjust some array dim query methods
Jaroslav Hajek <highegg@gmail.com>
parents:
9025
diff
changeset
|
258 // Return a const-reference so that dims ()(i) works efficiently. |
|
6890d411a0b8
adjust some array dim query methods
Jaroslav Hajek <highegg@gmail.com>
parents:
9025
diff
changeset
|
259 const dim_vector& dims (void) const { return dimensions; } |
| 4513 | 260 |
| 4532 | 261 Array<T> squeeze (void) const; |
| 4703 | 262 |
| 263 void chop_trailing_singletons (void) | |
| 264 { dimensions.chop_trailing_singletons (); } | |
| 265 | |
| 5275 | 266 static octave_idx_type get_size (octave_idx_type r, octave_idx_type c); |
| 267 static octave_idx_type get_size (octave_idx_type r, octave_idx_type c, octave_idx_type p); | |
| 268 static octave_idx_type get_size (const dim_vector& dv); | |
| 228 | 269 |
| 5275 | 270 octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx) const; |
| 4517 | 271 |
| 5275 | 272 T range_error (const char *fcn, octave_idx_type n) const; |
| 273 T& range_error (const char *fcn, octave_idx_type n); | |
| 3665 | 274 |
| 5275 | 275 T range_error (const char *fcn, octave_idx_type i, octave_idx_type j) const; |
| 276 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j); | |
| 4513 | 277 |
| 5275 | 278 T range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k) const; |
| 279 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k); | |
| 4513 | 280 |
| 6867 | 281 T range_error (const char *fcn, const Array<octave_idx_type>& ra_idx) const; |
| 282 T& range_error (const char *fcn, const Array<octave_idx_type>& ra_idx); | |
| 4513 | 283 |
| 2108 | 284 // No checking, even for multiple references, ever. |
| 285 | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
286 T& xelem (octave_idx_type n) { return slice_data [n]; } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
287 T xelem (octave_idx_type n) const { return slice_data [n]; } |
| 2108 | 288 |
| 5275 | 289 T& xelem (octave_idx_type i, octave_idx_type j) { return xelem (dim1()*j+i); } |
| 290 T xelem (octave_idx_type i, octave_idx_type j) const { return xelem (dim1()*j+i); } | |
| 4513 | 291 |
| 5275 | 292 T& xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return xelem (i, dim2()*k+j); } |
| 293 T xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return xelem (i, dim2()*k+j); } | |
| 4513 | 294 |
| 6867 | 295 T& xelem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 296 { return xelem (compute_index (ra_idx)); } |
| 297 | |
| 6867 | 298 T xelem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 299 { return xelem (compute_index (ra_idx)); } |
| 300 | |
| 5775 | 301 // FIXME -- would be nice to fix this so that we don't |
| 2006 | 302 // unnecessarily force a copy, but that is not so easy, and I see no |
| 303 // clean way to do it. | |
| 304 | |
| 5275 | 305 T& checkelem (octave_idx_type n) |
| 2006 | 306 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
307 if (n < 0 || n >= slice_len) |
| 2109 | 308 return range_error ("T& Array<T>::checkelem", n); |
| 2006 | 309 else |
| 2108 | 310 { |
| 311 make_unique (); | |
| 312 return xelem (n); | |
| 313 } | |
| 2006 | 314 } |
| 315 | |
| 5275 | 316 T& checkelem (octave_idx_type i, octave_idx_type j) |
| 4513 | 317 { |
| 318 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
| 319 return range_error ("T& Array<T>::checkelem", i, j); | |
| 320 else | |
| 321 return elem (dim1()*j+i); | |
| 322 } | |
| 323 | |
| 5275 | 324 T& checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) |
| 4513 | 325 { |
| 326 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
| 327 return range_error ("T& Array<T>::checkelem", i, j, k); | |
| 328 else | |
| 329 return elem (i, dim2()*k+j); | |
| 330 } | |
| 331 | |
| 6867 | 332 T& checkelem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 333 { |
| 5275 | 334 octave_idx_type i = compute_index (ra_idx); |
| 4513 | 335 |
| 336 if (i < 0) | |
| 337 return range_error ("T& Array<T>::checkelem", ra_idx); | |
| 338 else | |
| 339 return elem (i); | |
| 340 } | |
| 341 | |
| 5275 | 342 T& elem (octave_idx_type n) |
| 2108 | 343 { |
| 344 make_unique (); | |
| 2109 | 345 return xelem (n); |
| 2108 | 346 } |
| 2306 | 347 |
| 5275 | 348 T& elem (octave_idx_type i, octave_idx_type j) { return elem (dim1()*j+i); } |
| 4513 | 349 |
| 5275 | 350 T& elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, dim2()*k+j); } |
| 4513 | 351 |
| 6867 | 352 T& elem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 353 { return Array<T>::elem (compute_index (ra_idx)); } |
| 354 | |
| 2306 | 355 #if defined (BOUNDS_CHECKING) |
| 5275 | 356 T& operator () (octave_idx_type n) { return checkelem (n); } |
| 357 T& operator () (octave_idx_type i, octave_idx_type j) { return checkelem (i, j); } | |
| 358 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return checkelem (i, j, k); } | |
| 6867 | 359 T& operator () (const Array<octave_idx_type>& ra_idx) { return checkelem (ra_idx); } |
| 2306 | 360 #else |
| 5275 | 361 T& operator () (octave_idx_type n) { return elem (n); } |
| 362 T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); } | |
| 363 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, j, k); } | |
| 6867 | 364 T& operator () (const Array<octave_idx_type>& ra_idx) { return elem (ra_idx); } |
| 2006 | 365 #endif |
| 366 | |
| 5275 | 367 T checkelem (octave_idx_type n) const |
| 2006 | 368 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
369 if (n < 0 || n >= slice_len) |
| 2109 | 370 return range_error ("T Array<T>::checkelem", n); |
| 2049 | 371 else |
| 2108 | 372 return xelem (n); |
| 2006 | 373 } |
| 1989 | 374 |
| 5275 | 375 T checkelem (octave_idx_type i, octave_idx_type j) const |
| 4513 | 376 { |
| 377 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
| 378 return range_error ("T Array<T>::checkelem", i, j); | |
| 379 else | |
| 380 return elem (dim1()*j+i); | |
| 381 } | |
| 382 | |
| 5275 | 383 T checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const |
| 4513 | 384 { |
| 385 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
| 386 return range_error ("T Array<T>::checkelem", i, j, k); | |
| 387 else | |
| 388 return Array<T>::elem (i, Array<T>::dim1()*k+j); | |
| 389 } | |
| 390 | |
| 6867 | 391 T checkelem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 392 { |
| 5275 | 393 octave_idx_type i = compute_index (ra_idx); |
| 4513 | 394 |
| 395 if (i < 0) | |
| 396 return range_error ("T Array<T>::checkelem", ra_idx); | |
| 397 else | |
| 398 return Array<T>::elem (i); | |
| 399 } | |
| 400 | |
| 5275 | 401 T elem (octave_idx_type n) const { return xelem (n); } |
| 2306 | 402 |
| 5275 | 403 T elem (octave_idx_type i, octave_idx_type j) const { return elem (dim1()*j+i); } |
| 4513 | 404 |
| 5275 | 405 T elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, dim2()*k+j); } |
| 4513 | 406 |
| 6867 | 407 T elem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 408 { return Array<T>::elem (compute_index (ra_idx)); } |
| 409 | |
| 2108 | 410 #if defined (BOUNDS_CHECKING) |
| 5275 | 411 T operator () (octave_idx_type n) const { return checkelem (n); } |
| 412 T operator () (octave_idx_type i, octave_idx_type j) const { return checkelem (i, j); } | |
| 413 T operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return checkelem (i, j, k); } | |
| 6867 | 414 T operator () (const Array<octave_idx_type>& ra_idx) const { return checkelem (ra_idx); } |
| 2006 | 415 #else |
| 5275 | 416 T operator () (octave_idx_type n) const { return elem (n); } |
| 417 T operator () (octave_idx_type i, octave_idx_type j) const { return elem (i, j); } | |
| 418 T operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, j, k); } | |
| 6867 | 419 T operator () (const Array<octave_idx_type>& ra_idx) const { return elem (ra_idx); } |
| 2006 | 420 #endif |
| 421 | |
| 4567 | 422 Array<T> reshape (const dim_vector& new_dims) const; |
| 423 | |
| 5275 | 424 Array<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const; |
| 425 Array<T> ipermute (const Array<octave_idx_type>& vec) const | |
| 4593 | 426 { return permute (vec, true); } |
| 427 | |
| 4513 | 428 bool is_square (void) const { return (dim1 () == dim2 ()); } |
| 429 | |
| 4559 | 430 bool is_empty (void) const { return numel () == 0; } |
| 431 | |
|
9026
6890d411a0b8
adjust some array dim query methods
Jaroslav Hajek <highegg@gmail.com>
parents:
9025
diff
changeset
|
432 bool is_vector (void) const { return dimensions.is_vector (); } |
|
6890d411a0b8
adjust some array dim query methods
Jaroslav Hajek <highegg@gmail.com>
parents:
9025
diff
changeset
|
433 |
| 4513 | 434 Array<T> transpose (void) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7717
diff
changeset
|
435 Array<T> hermitian (T (*fcn) (const T&) = 0) const; |
| 238 | 436 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
437 const T *data (void) const { return slice_data; } |
| 228 | 438 |
| 3952 | 439 const T *fortran_vec (void) const { return data (); } |
| 440 | |
| 238 | 441 T *fortran_vec (void); |
| 1560 | 442 |
| 4513 | 443 int ndims (void) const { return dimensions.length (); } |
| 1560 | 444 |
| 4517 | 445 void maybe_delete_dims (void); |
| 446 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
447 // Indexing without resizing. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
448 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
449 Array<T> index (const idx_vector& i) const; |
| 1560 | 450 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
451 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
|
452 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
453 Array<T> index (const Array<idx_vector>& ia) const; |
| 1560 | 454 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
455 static T resize_fill_value (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
456 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
457 // Resizing (with fill). |
| 1560 | 458 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
459 void resize_fill (octave_idx_type n, const T& rfv); |
| 1560 | 460 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
461 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
|
462 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
463 void resize_fill (const dim_vector& dv, const T& rfv); |
| 1560 | 464 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
465 // Resizing with default fill. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
466 // Rationale: |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
467 // 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
|
468 // 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
|
469 // where part of the data is initialized an part isn't. |
| 4513 | 470 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
471 void resize (octave_idx_type n) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
472 { resize_fill (n, resize_fill_value ()); } |
| 4513 | 473 |
| 8333 | 474 // FIXME -- this method cannot be defined here because it would |
| 475 // clash with | |
| 476 // | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
477 // void resize (octave_idx_type, const T&) |
| 8333 | 478 // |
| 479 // (these become indistinguishable when T = octave_idx_type). | |
| 480 // In the future, I think the resize (.., const T& rfv) overloads | |
| 481 // should go away in favor of using resize_fill. | |
| 4513 | 482 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
483 // void resize (octave_idx_type nr, octave_idx_type nc) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
484 // { resize_fill (nr, nc, resize_fill_value ()); } |
| 4513 | 485 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
486 void resize (dim_vector dv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
487 { resize_fill (dv, resize_fill_value ()); } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
488 |
| 8333 | 489 // FIXME -- these are here for backward compatibility. They should |
| 490 // go away in favor of using resize_fill directly. | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
491 void resize (octave_idx_type n, const T& rfv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
492 { resize_fill (n, static_cast<T> (rfv)); } |
| 4513 | 493 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
494 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
|
495 { resize_fill (nr, nc, rfv); } |
| 2382 | 496 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
497 void resize (dim_vector dv, const T& rfv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
498 { resize_fill (dv, rfv); } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
499 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
500 // Indexing with possible resizing and fill |
| 8333 | 501 // FIXME -- this is really a corner case, that should better be |
| 502 // handled directly in liboctinterp. | |
| 3933 | 503 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
504 Array<T> index (const idx_vector& i, bool resize_ok, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
505 const T& rfv = resize_fill_value ()) const; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
506 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
507 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
|
508 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
| 4513 | 509 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
510 Array<T> index (const Array<idx_vector>& ia, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
511 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
512 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
513 // Indexed assignment (always with resize & fill). |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
514 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
515 void assign (const idx_vector& i, const Array<T>& rhs, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
516 const T& rfv = resize_fill_value ()); |
| 4513 | 517 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
518 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
|
519 const T& rfv = resize_fill_value ()); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
520 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
521 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
|
522 const T& rfv = resize_fill_value ()); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
523 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
524 // Deleting elements. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
525 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
526 // A(I) = [] (with a single subscript) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
527 void delete_elements (const idx_vector& i); |
| 4530 | 528 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
529 // A(:,...,I,...,:) = [] (>= 2 subscripts, one of them is non-colon) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
530 void delete_elements (int dim, const idx_vector& i); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
531 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
532 // Dispatcher to the above two. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
533 void delete_elements (const Array<idx_vector>& ia); |
| 4513 | 534 |
| 8333 | 535 // FIXME -- are these required? What exactly are they supposed to do?. |
| 3928 | 536 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
537 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
|
538 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
|
539 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
|
540 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
541 Array<T>& insert (const Array<T>& a, const Array<octave_idx_type>& idx); |
| 3933 | 542 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
543 void maybe_economize (void) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
544 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
545 if (rep->count == 1 && slice_len != rep->len) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
546 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
547 ArrayRep *new_rep = new ArrayRep (slice_data, slice_len, true); |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
548 delete rep; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
549 rep = new_rep; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
550 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
551 } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
552 } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
553 |
| 4517 | 554 void print_info (std::ostream& os, const std::string& prefix) const; |
| 5900 | 555 |
| 556 // Unsafe. This function exists to support the MEX interface. | |
| 557 // You should not use it anywhere else. | |
| 558 void *mex_get_data (void) const { return const_cast<T *> (data ()); } | |
| 7433 | 559 |
|
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
560 Array<T> sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const; |
| 7433 | 561 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
|
562 sortmode mode = ASCENDING) const; |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
563 |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
564 // Ordering is auto-detected or can be specified. |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
565 sortmode is_sorted (sortmode mode = UNSORTED) const; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
566 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
567 // Sort by rows returns only indices. |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
568 Array<octave_idx_type> sort_rows_idx (sortmode mode = ASCENDING) const; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
569 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
570 // Ordering is auto-detected or can be specified. |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
571 sortmode is_sorted_rows (sortmode mode = UNSORTED) const; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
572 |
|
8814
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
573 // Do a binary lookup in a sorted array. |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
574 // Mode can be specified or is auto-detected by comparing 1st and last element. |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
575 octave_idx_type lookup (const T& value, sortmode mode = UNSORTED) const; |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
576 |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
577 // Ditto, but for an array of values, specializing on long runs. |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
578 // If linf is true, the leftmost interval is extended to infinity |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
579 // (indices will be >= 1). |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
580 // If rinf is true, the rightmost interval is extended to infinity |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
581 // (indices will be <= length ()-1). |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
582 Array<octave_idx_type> lookup (const Array<T>& values, sortmode mode = UNSORTED, |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
583 bool linf = false, bool rinf = false) const; |
|
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
584 |
|
9341
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
585 // This looks up only exact matches, giving their indices. Non-exact matches get |
|
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
586 // the value -1. |
|
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
587 Array<octave_idx_type> lookupm (const Array<T>& values, sortmode mode = UNSORTED) const; |
|
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
588 |
|
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
589 // This looks up only exact matches, returning true/false if match. |
|
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
590 Array<bool> lookupb (const Array<T>& values, sortmode mode = UNSORTED) const; |
|
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
591 |
| 9025 | 592 // Find indices of (at most n) nonzero elements. If n is specified, backward |
| 593 // specifies search from backward. | |
| 594 Array<octave_idx_type> find (octave_idx_type n = -1, bool backward = false) const; | |
| 595 | |
|
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
596 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
|
597 |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
598 template <class U, class F> |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
599 Array<U> |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
600 map (F fcn) const |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
601 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
602 octave_idx_type len = length (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
603 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
604 const T *m = data (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
605 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
606 Array<U> result (dims ()); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
607 U *p = result.fortran_vec (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
608 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
609 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
|
610 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
611 OCTAVE_QUIT; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
612 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
613 p[i] = fcn (m[i]); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
614 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
615 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
616 return result; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
617 } |
|
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
618 |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
619 // This is non-breakable map, suitable for fast functions. Efficiency |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
620 // relies on compiler's ability to inline a function pointer. This seems |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
621 // to be OK with recent GCC. |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
622 template <class U> |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
623 Array<U> |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
624 fastmap (U (*fcn) (typename ref_param<T>::type)) const |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
625 { |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
626 octave_idx_type len = length (); |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
627 |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
628 const T *m = data (); |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
629 |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
630 Array<U> result (dims ()); |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
631 U *p = result.fortran_vec (); |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
632 |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
633 std::transform (m, m + len, p, fcn); |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
634 |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
635 return result; |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
636 } |
|
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
637 |
|
9046
88bf56bbccca
make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents:
9026
diff
changeset
|
638 template <class U> friend class Array; |
|
9201
472f0e22aa60
guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents:
9046
diff
changeset
|
639 |
|
472f0e22aa60
guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents:
9046
diff
changeset
|
640 private: |
|
472f0e22aa60
guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents:
9046
diff
changeset
|
641 static void instantiation_guard (); |
| 4513 | 642 }; |
| 4459 | 643 |
| 228 | 644 #endif |
| 645 | |
| 646 /* | |
| 647 ;;; Local Variables: *** | |
| 648 ;;; mode: C++ *** | |
| 649 ;;; End: *** | |
| 650 */ |