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