Mercurial > octave
annotate liboctave/Array.h @ 10142:829e69ec3110
make OCTAVE_QUIT a function
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Wed, 20 Jan 2010 10:38:00 +0100 |
| parents | ed49cef7e005 |
| children | 4c0cdbe0acca |
| 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" |
|
9773
01f897d8a130
optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
41 #include "oct-mem.h" |
| 7433 | 42 |
| 1359 | 43 // One dimensional array class. Handles the reference counting for |
| 44 // all the derived classes. | |
| 238 | 45 |
| 228 | 46 template <class T> |
| 3585 | 47 class |
| 48 Array | |
| 228 | 49 { |
| 3504 | 50 protected: |
| 1619 | 51 |
| 4513 | 52 //-------------------------------------------------------------------- |
| 53 // The real representation of all arrays. | |
| 54 //-------------------------------------------------------------------- | |
| 1735 | 55 |
| 56 class ArrayRep | |
| 57 { | |
| 58 public: | |
| 59 | |
| 60 T *data; | |
| 5275 | 61 octave_idx_type len; |
| 1735 | 62 int count; |
| 63 | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
64 ArrayRep (T *d, octave_idx_type l, bool copy = false) |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
65 : data (copy ? no_ctor_new<T> (l) : d), len (l), count (1) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
66 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
67 if (copy) |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
68 copy_or_memcpy (l, d, data); |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
69 } |
| 1735 | 70 |
| 71 ArrayRep (void) : data (0), len (0), count (1) { } | |
| 72 | |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
73 explicit ArrayRep (octave_idx_type n) : data (no_ctor_new<T> (n)), len (n), count (1) { } |
| 1735 | 74 |
| 5275 | 75 explicit ArrayRep (octave_idx_type n, const T& val) |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
76 : data (no_ctor_new<T> (n)), len (n), count (1) |
| 4513 | 77 { |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
78 fill_or_memset (n, val, data); |
| 4513 | 79 } |
| 80 | |
| 1735 | 81 ArrayRep (const ArrayRep& a) |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
82 : data (no_ctor_new<T> (a.len)), len (a.len), count (1) |
| 4513 | 83 { |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
84 copy_or_memcpy (a.len, a.data, data); |
| 4513 | 85 } |
| 4517 | 86 |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
87 ~ArrayRep (void) { no_ctor_delete<T> (data); } |
| 1735 | 88 |
| 5275 | 89 octave_idx_type length (void) const { return len; } |
| 1735 | 90 |
| 4517 | 91 private: |
| 92 | |
| 93 // No assignment! | |
| 94 | |
| 95 ArrayRep& operator = (const ArrayRep& a); | |
| 1735 | 96 }; |
| 97 | |
| 4513 | 98 //-------------------------------------------------------------------- |
| 99 | |
| 6884 | 100 public: |
| 101 | |
|
9556
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
102 void make_unique (void) |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
103 { |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
104 if (rep->count > 1) |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
105 { |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
106 --rep->count; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
107 rep = new ArrayRep (slice_data, slice_len, true); |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
108 slice_data = rep->data; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
109 } |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
110 } |
| 238 | 111 |
| 5900 | 112 typedef T element_type; |
| 113 | |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
114 typedef typename ref_param<T>::type crefT; |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
115 |
| 8725 | 116 typedef bool (*compare_fcn_type) (typename ref_param<T>::type, |
| 117 typename ref_param<T>::type); | |
| 118 | |
|
8524
937921654627
clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
119 protected: |
| 4902 | 120 |
| 121 typename Array<T>::ArrayRep *rep; | |
| 4518 | 122 |
| 4513 | 123 dim_vector dimensions; |
| 124 | |
|
8531
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
125 // Rationale: |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
126 // 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
|
127 // 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
|
128 // 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
|
129 // 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
|
130 // need to be properly updated. |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8524
diff
changeset
|
131 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
132 T* slice_data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
133 octave_idx_type slice_len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
134 |
| 5275 | 135 Array (T *d, octave_idx_type n) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
136 : 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
|
137 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
138 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
139 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
140 } |
| 1619 | 141 |
| 4587 | 142 Array (T *d, const dim_vector& dv) |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
143 : rep (new typename Array<T>::ArrayRep (d, dv.numel ())), |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
144 dimensions (dv) |
|
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 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
147 slice_len = rep->len; |
|
10095
eb8ac0eed9f1
always chop dimension vector when constructing Arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
10075
diff
changeset
|
148 dimensions.chop_trailing_singletons (); |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
149 } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
150 |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
151 // slice constructor |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
152 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
|
153 octave_idx_type l, octave_idx_type u) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
154 : rep(a.rep), dimensions (dv) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
155 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
156 rep->count++; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
157 slice_data = a.slice_data + l; |
| 9731 | 158 slice_len = u - l; |
|
10095
eb8ac0eed9f1
always chop dimension vector when constructing Arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
10075
diff
changeset
|
159 dimensions.chop_trailing_singletons (); |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
160 } |
| 4513 | 161 |
| 162 private: | |
| 163 | |
| 4585 | 164 typename Array<T>::ArrayRep *nil_rep (void) const |
| 4513 | 165 { |
| 166 static typename Array<T>::ArrayRep *nr | |
| 167 = new typename Array<T>::ArrayRep (); | |
| 168 | |
| 169 return nr; | |
| 1550 | 170 } |
| 238 | 171 |
| 4902 | 172 template <class U> |
| 173 T * | |
|
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
174 coerce (const U *a, octave_idx_type len) |
| 4902 | 175 { |
|
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
176 T *retval = no_ctor_new<T> (len); |
| 4902 | 177 |
|
8118
311c9b36df8f
replace int->octave_idx_type in Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
178 for (octave_idx_type i = 0; i < len; i++) |
| 4902 | 179 retval[i] = T (a[i]); |
| 180 | |
| 181 return retval; | |
| 182 } | |
| 183 | |
| 228 | 184 public: |
| 238 | 185 |
| 1550 | 186 Array (void) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
187 : rep (nil_rep ()), dimensions () |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
188 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
189 rep->count++; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
190 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
191 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
192 } |
| 1550 | 193 |
| 5275 | 194 explicit Array (octave_idx_type n) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
195 : 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
|
196 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
197 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
198 slice_len = rep->len; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
199 } |
| 1619 | 200 |
| 5275 | 201 explicit Array (octave_idx_type n, const T& val) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
202 : rep (new typename Array<T>::ArrayRep (n)), dimensions (n) |
| 4513 | 203 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
204 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
205 slice_len = rep->len; |
| 4513 | 206 fill (val); |
| 207 } | |
| 208 | |
| 4902 | 209 // Type conversion case. |
| 210 template <class U> | |
| 211 Array (const Array<U>& a) | |
| 212 : 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
|
213 dimensions (a.dims ()) |
| 4902 | 214 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
215 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
216 slice_len = rep->len; |
| 4902 | 217 } |
| 218 | |
| 219 // No type conversion case. | |
| 4513 | 220 Array (const Array<T>& a) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
221 : rep (a.rep), dimensions (a.dimensions) |
| 4513 | 222 { |
| 223 rep->count++; | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
224 slice_data = a.slice_data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
225 slice_len = a.slice_len; |
| 1550 | 226 } |
| 227 | |
| 4513 | 228 public: |
| 229 | |
| 4587 | 230 Array (const dim_vector& dv) |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
231 : rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
232 dimensions (dv) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
233 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
234 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
235 slice_len = rep->len; |
|
10095
eb8ac0eed9f1
always chop dimension vector when constructing Arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
10075
diff
changeset
|
236 dimensions.chop_trailing_singletons (); |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
237 } |
| 238 | 238 |
| 4587 | 239 Array (const dim_vector& dv, const T& val) |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
240 : rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
241 dimensions (dv) |
| 1550 | 242 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
243 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
244 slice_len = rep->len; |
| 4513 | 245 fill (val); |
|
10095
eb8ac0eed9f1
always chop dimension vector when constructing Arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
10075
diff
changeset
|
246 dimensions.chop_trailing_singletons (); |
| 4513 | 247 } |
| 248 | |
| 9731 | 249 // Reshape constructor. |
| 4834 | 250 Array (const Array<T>& a, const dim_vector& dv); |
| 228 | 251 |
|
9556
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
252 ~Array (void) |
|
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 } |
| 228 | 257 |
|
9556
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
258 Array<T>& operator = (const Array<T>& a) |
|
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 if (this != &a) |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
261 { |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
262 if (--rep->count <= 0) |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
263 delete rep; |
|
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 rep = a.rep; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
266 rep->count++; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
267 |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
268 dimensions = a.dimensions; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
269 slice_data = a.slice_data; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
270 slice_len = a.slice_len; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
271 } |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
272 |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
273 return *this; |
|
948795dc1974
make a few Array methods inline
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
274 } |
| 4513 | 275 |
|
8524
937921654627
clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
276 void fill (const T& val); |
|
9624
3fc7272937ce
implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents:
9556
diff
changeset
|
277 |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9341
diff
changeset
|
278 void clear (void); |
|
9624
3fc7272937ce
implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents:
9556
diff
changeset
|
279 void clear (const dim_vector& dv); |
|
3fc7272937ce
implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents:
9556
diff
changeset
|
280 void clear (octave_idx_type n) |
|
3fc7272937ce
implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents:
9556
diff
changeset
|
281 { clear (dim_vector (n)); } |
|
3fc7272937ce
implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents:
9556
diff
changeset
|
282 |
|
3fc7272937ce
implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents:
9556
diff
changeset
|
283 void clear (octave_idx_type r, octave_idx_type c) |
|
3fc7272937ce
implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents:
9556
diff
changeset
|
284 { clear (dim_vector (r, c)); } |
| 238 | 285 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
286 octave_idx_type capacity (void) const { return slice_len; } |
| 5275 | 287 octave_idx_type length (void) const { return capacity (); } |
| 288 octave_idx_type nelem (void) const { return capacity (); } | |
| 289 octave_idx_type numel (void) const { return nelem (); } | |
| 4513 | 290 |
| 5275 | 291 octave_idx_type dim1 (void) const { return dimensions(0); } |
| 292 octave_idx_type dim2 (void) const { return dimensions(1); } | |
| 293 octave_idx_type dim3 (void) const { return dimensions(2); } | |
| 4513 | 294 |
| 5275 | 295 octave_idx_type rows (void) const { return dim1 (); } |
| 296 octave_idx_type cols (void) const { return dim2 (); } | |
| 297 octave_idx_type columns (void) const { return dim2 (); } | |
| 298 octave_idx_type pages (void) const { return dim3 (); } | |
| 4513 | 299 |
| 4902 | 300 size_t byte_size (void) const { return numel () * sizeof (T); } |
| 301 | |
|
9026
6890d411a0b8
adjust some array dim query methods
Jaroslav Hajek <highegg@gmail.com>
parents:
9025
diff
changeset
|
302 // 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
|
303 const dim_vector& dims (void) const { return dimensions; } |
| 4513 | 304 |
| 4532 | 305 Array<T> squeeze (void) const; |
| 4703 | 306 |
|
10095
eb8ac0eed9f1
always chop dimension vector when constructing Arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
10075
diff
changeset
|
307 void chop_trailing_singletons (void) GCC_ATTR_DEPRECATED |
| 4703 | 308 { dimensions.chop_trailing_singletons (); } |
| 309 | |
| 5275 | 310 octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx) const; |
| 4517 | 311 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
312 T& range_error (const char *fcn, octave_idx_type n) const; |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
313 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j) const; |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
314 T& range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k) const; |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
315 T& range_error (const char *fcn, const Array<octave_idx_type>& ra_idx) const; |
| 4513 | 316 |
| 2108 | 317 // No checking, even for multiple references, ever. |
| 318 | |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
319 T& xelem (octave_idx_type n) { return slice_data [n]; } |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
320 crefT xelem (octave_idx_type n) const { return slice_data [n]; } |
| 2108 | 321 |
| 5275 | 322 T& xelem (octave_idx_type i, octave_idx_type j) { return xelem (dim1()*j+i); } |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
323 crefT xelem (octave_idx_type i, octave_idx_type j) const { return xelem (dim1()*j+i); } |
| 4513 | 324 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
325 T& xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
326 { return xelem (i, dim2()*k+j); } |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
327 crefT xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
328 { return xelem (i, dim2()*k+j); } |
| 4513 | 329 |
| 6867 | 330 T& xelem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 331 { return xelem (compute_index (ra_idx)); } |
| 332 | |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
333 crefT xelem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 334 { return xelem (compute_index (ra_idx)); } |
| 335 | |
| 5775 | 336 // FIXME -- would be nice to fix this so that we don't |
| 2006 | 337 // unnecessarily force a copy, but that is not so easy, and I see no |
| 338 // clean way to do it. | |
| 339 | |
| 5275 | 340 T& checkelem (octave_idx_type n) |
| 2006 | 341 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
342 if (n < 0 || n >= slice_len) |
| 2109 | 343 return range_error ("T& Array<T>::checkelem", n); |
| 2006 | 344 else |
| 2108 | 345 { |
| 346 make_unique (); | |
| 347 return xelem (n); | |
| 348 } | |
| 2006 | 349 } |
| 350 | |
| 5275 | 351 T& checkelem (octave_idx_type i, octave_idx_type j) |
| 4513 | 352 { |
| 353 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
| 354 return range_error ("T& Array<T>::checkelem", i, j); | |
| 355 else | |
| 356 return elem (dim1()*j+i); | |
| 357 } | |
| 358 | |
| 5275 | 359 T& checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) |
| 4513 | 360 { |
| 361 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
| 362 return range_error ("T& Array<T>::checkelem", i, j, k); | |
| 363 else | |
| 364 return elem (i, dim2()*k+j); | |
| 365 } | |
| 366 | |
| 6867 | 367 T& checkelem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 368 { |
| 5275 | 369 octave_idx_type i = compute_index (ra_idx); |
| 4513 | 370 |
| 371 if (i < 0) | |
| 372 return range_error ("T& Array<T>::checkelem", ra_idx); | |
| 373 else | |
| 374 return elem (i); | |
| 375 } | |
| 376 | |
| 5275 | 377 T& elem (octave_idx_type n) |
| 2108 | 378 { |
| 379 make_unique (); | |
| 2109 | 380 return xelem (n); |
| 2108 | 381 } |
| 2306 | 382 |
| 5275 | 383 T& elem (octave_idx_type i, octave_idx_type j) { return elem (dim1()*j+i); } |
| 4513 | 384 |
| 5275 | 385 T& elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, dim2()*k+j); } |
| 4513 | 386 |
| 6867 | 387 T& elem (const Array<octave_idx_type>& ra_idx) |
| 4513 | 388 { return Array<T>::elem (compute_index (ra_idx)); } |
| 389 | |
| 2306 | 390 #if defined (BOUNDS_CHECKING) |
| 5275 | 391 T& operator () (octave_idx_type n) { return checkelem (n); } |
| 392 T& operator () (octave_idx_type i, octave_idx_type j) { return checkelem (i, j); } | |
| 393 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return checkelem (i, j, k); } | |
| 6867 | 394 T& operator () (const Array<octave_idx_type>& ra_idx) { return checkelem (ra_idx); } |
| 2306 | 395 #else |
| 5275 | 396 T& operator () (octave_idx_type n) { return elem (n); } |
| 397 T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); } | |
| 398 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, j, k); } | |
| 6867 | 399 T& operator () (const Array<octave_idx_type>& ra_idx) { return elem (ra_idx); } |
| 2006 | 400 #endif |
| 401 | |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
402 crefT checkelem (octave_idx_type n) const |
| 2006 | 403 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
404 if (n < 0 || n >= slice_len) |
| 2109 | 405 return range_error ("T Array<T>::checkelem", n); |
| 2049 | 406 else |
| 2108 | 407 return xelem (n); |
| 2006 | 408 } |
| 1989 | 409 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
410 crefT checkelem (octave_idx_type i, octave_idx_type j) const |
| 4513 | 411 { |
| 412 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ()) | |
| 413 return range_error ("T Array<T>::checkelem", i, j); | |
| 414 else | |
| 415 return elem (dim1()*j+i); | |
| 416 } | |
| 417 | |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
418 crefT checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const |
| 4513 | 419 { |
| 420 if (i < 0 || j < 0 || k < 0 || i >= dim1 () || j >= dim2 () || k >= dim3 ()) | |
| 421 return range_error ("T Array<T>::checkelem", i, j, k); | |
| 422 else | |
| 423 return Array<T>::elem (i, Array<T>::dim1()*k+j); | |
| 424 } | |
| 425 | |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
426 crefT checkelem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 427 { |
| 5275 | 428 octave_idx_type i = compute_index (ra_idx); |
| 4513 | 429 |
| 430 if (i < 0) | |
| 431 return range_error ("T Array<T>::checkelem", ra_idx); | |
| 432 else | |
| 433 return Array<T>::elem (i); | |
| 434 } | |
| 435 | |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
436 crefT elem (octave_idx_type n) const { return xelem (n); } |
| 2306 | 437 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
438 crefT elem (octave_idx_type i, octave_idx_type j) const { return elem (dim1()*j+i); } |
| 4513 | 439 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
440 crefT elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, dim2()*k+j); } |
| 4513 | 441 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
442 crefT elem (const Array<octave_idx_type>& ra_idx) const |
| 4513 | 443 { return Array<T>::elem (compute_index (ra_idx)); } |
| 444 | |
| 2108 | 445 #if defined (BOUNDS_CHECKING) |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
446 crefT operator () (octave_idx_type n) const { return checkelem (n); } |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
447 crefT operator () (octave_idx_type i, octave_idx_type j) const { return checkelem (i, j); } |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
448 crefT operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return checkelem (i, j, k); } |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
449 crefT operator () (const Array<octave_idx_type>& ra_idx) const { return checkelem (ra_idx); } |
| 2006 | 450 #else |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
451 crefT operator () (octave_idx_type n) const { return elem (n); } |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
452 crefT operator () (octave_idx_type i, octave_idx_type j) const { return elem (i, j); } |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
453 crefT operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, j, k); } |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9921
diff
changeset
|
454 crefT operator () (const Array<octave_idx_type>& ra_idx) const { return elem (ra_idx); } |
| 2006 | 455 #endif |
| 456 | |
| 9731 | 457 // Fast extractors. All of these produce shallow copies. |
| 458 // Warning: none of these do check bounds, unless BOUNDS_CHECKING is on! | |
| 459 | |
| 460 // Extract column: A(:,k+1). | |
| 461 Array<T> column (octave_idx_type k) const; | |
| 462 // Extract page: A(:,:,k+1). | |
| 463 Array<T> page (octave_idx_type k) const; | |
| 464 | |
| 465 // Give this array as a column vector: A(:). | |
| 466 Array<T> linearize (void) const; | |
| 467 | |
| 468 // Extract a slice from this array as a column vector: A(:)(lo+1:up). | |
| 469 // Must be 0 <= lo && up <= numel. May be up < lo. | |
| 470 Array<T> linear_slice (octave_idx_type lo, octave_idx_type up) const; | |
| 471 | |
| 472 Array<T> reshape (const dim_vector& new_dims) const | |
| 473 { return Array<T> (*this, new_dims); } | |
| 4567 | 474 |
| 5275 | 475 Array<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const; |
| 476 Array<T> ipermute (const Array<octave_idx_type>& vec) const | |
| 4593 | 477 { return permute (vec, true); } |
| 478 | |
| 4513 | 479 bool is_square (void) const { return (dim1 () == dim2 ()); } |
| 480 | |
| 4559 | 481 bool is_empty (void) const { return numel () == 0; } |
| 482 | |
|
9026
6890d411a0b8
adjust some array dim query methods
Jaroslav Hajek <highegg@gmail.com>
parents:
9025
diff
changeset
|
483 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
|
484 |
| 4513 | 485 Array<T> transpose (void) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7717
diff
changeset
|
486 Array<T> hermitian (T (*fcn) (const T&) = 0) const; |
| 238 | 487 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
488 const T *data (void) const { return slice_data; } |
| 228 | 489 |
| 3952 | 490 const T *fortran_vec (void) const { return data (); } |
| 491 | |
| 238 | 492 T *fortran_vec (void); |
| 1560 | 493 |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9341
diff
changeset
|
494 bool is_shared (void) { return rep->count > 1; } |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9341
diff
changeset
|
495 |
| 4513 | 496 int ndims (void) const { return dimensions.length (); } |
| 1560 | 497 |
| 4517 | 498 void maybe_delete_dims (void); |
| 499 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
500 // Indexing without resizing. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
501 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
502 Array<T> index (const idx_vector& i) const; |
| 1560 | 503 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
504 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
|
505 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
506 Array<T> index (const Array<idx_vector>& ia) const; |
| 1560 | 507 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
508 static T resize_fill_value (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
509 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
510 // Resizing (with fill). |
| 1560 | 511 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
512 void resize_fill (octave_idx_type n, const T& rfv); |
| 1560 | 513 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
514 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
|
515 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
516 void resize_fill (const dim_vector& dv, const T& rfv); |
| 1560 | 517 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
518 // Resizing with default fill. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
519 // Rationale: |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
520 // 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
|
521 // 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
|
522 // where part of the data is initialized an part isn't. |
| 4513 | 523 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
524 void resize (octave_idx_type n) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
525 { resize_fill (n, resize_fill_value ()); } |
| 4513 | 526 |
| 8333 | 527 // FIXME -- this method cannot be defined here because it would |
| 528 // clash with | |
| 529 // | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
530 // void resize (octave_idx_type, const T&) |
| 8333 | 531 // |
| 532 // (these become indistinguishable when T = octave_idx_type). | |
| 533 // In the future, I think the resize (.., const T& rfv) overloads | |
| 534 // should go away in favor of using resize_fill. | |
| 4513 | 535 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
536 // void resize (octave_idx_type nr, octave_idx_type nc) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
537 // { resize_fill (nr, nc, resize_fill_value ()); } |
| 4513 | 538 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
539 void resize (dim_vector dv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
540 { resize_fill (dv, resize_fill_value ()); } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
541 |
| 8333 | 542 // FIXME -- these are here for backward compatibility. They should |
| 543 // go away in favor of using resize_fill directly. | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
544 void resize (octave_idx_type n, const T& rfv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
545 { resize_fill (n, static_cast<T> (rfv)); } |
| 4513 | 546 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
547 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
|
548 { resize_fill (nr, nc, rfv); } |
| 2382 | 549 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
550 void resize (dim_vector dv, const T& rfv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
551 { resize_fill (dv, rfv); } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
552 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
553 // Indexing with possible resizing and fill |
| 8333 | 554 // FIXME -- this is really a corner case, that should better be |
| 555 // handled directly in liboctinterp. | |
| 3933 | 556 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
557 Array<T> index (const idx_vector& i, bool resize_ok, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
558 const T& rfv = resize_fill_value ()) const; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
559 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
560 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
|
561 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
| 4513 | 562 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
563 Array<T> index (const Array<idx_vector>& ia, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
564 bool resize_ok, const T& rfv = resize_fill_value ()) const; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
565 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
566 // Indexed assignment (always with resize & fill). |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
567 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
568 void assign (const idx_vector& i, const Array<T>& rhs, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
569 const T& rfv = resize_fill_value ()); |
| 4513 | 570 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
571 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
|
572 const T& rfv = resize_fill_value ()); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
573 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
574 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
|
575 const T& rfv = resize_fill_value ()); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
576 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
577 // Deleting elements. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
578 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
579 // A(I) = [] (with a single subscript) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
580 void delete_elements (const idx_vector& i); |
| 4530 | 581 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
582 // A(:,...,I,...,:) = [] (>= 2 subscripts, one of them is non-colon) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
583 void delete_elements (int dim, const idx_vector& i); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
584 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
585 // Dispatcher to the above two. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
586 void delete_elements (const Array<idx_vector>& ia); |
| 4513 | 587 |
|
10115
ed49cef7e005
simplify Array::insert methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10095
diff
changeset
|
588 // Insert an array into another at a specified position. |
|
ed49cef7e005
simplify Array::insert methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10095
diff
changeset
|
589 // If size (a) is [d1 d2 ... dN] and idx is [i1 i2 ... iN], |
|
ed49cef7e005
simplify Array::insert methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10095
diff
changeset
|
590 // this method is equivalent to |
|
ed49cef7e005
simplify Array::insert methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10095
diff
changeset
|
591 // x(i1:i1+d1-1, i2:i2+d2-1, ... , iN:iN+dN-1) = a. |
|
ed49cef7e005
simplify Array::insert methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10095
diff
changeset
|
592 Array<T>& insert (const Array<T>& a, const Array<octave_idx_type>& idx); |
| 3928 | 593 |
|
10115
ed49cef7e005
simplify Array::insert methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10095
diff
changeset
|
594 // This is just a special case for idx = [r c 0 ...] |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
595 Array<T>& insert (const Array<T>& a, octave_idx_type r, octave_idx_type c); |
| 3933 | 596 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
597 void maybe_economize (void) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
598 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
599 if (rep->count == 1 && slice_len != rep->len) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
600 { |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
601 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
|
602 delete rep; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
603 rep = new_rep; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
604 slice_data = rep->data; |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
605 } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
606 } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8503
diff
changeset
|
607 |
| 4517 | 608 void print_info (std::ostream& os, const std::string& prefix) const; |
| 5900 | 609 |
| 610 // Unsafe. This function exists to support the MEX interface. | |
| 611 // You should not use it anywhere else. | |
| 612 void *mex_get_data (void) const { return const_cast<T *> (data ()); } | |
| 7433 | 613 |
| 9725 | 614 Array<T> sort (int dim = 0, sortmode mode = ASCENDING) const; |
| 615 Array<T> sort (Array<octave_idx_type> &sidx, int dim = 0, | |
|
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
616 sortmode mode = ASCENDING) const; |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
617 |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
618 // Ordering is auto-detected or can be specified. |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
619 sortmode is_sorted (sortmode mode = UNSORTED) const; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
620 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
621 // Sort by rows returns only indices. |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
622 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
|
623 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
624 // Ordering is auto-detected or can be specified. |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
625 sortmode is_sorted_rows (sortmode mode = UNSORTED) const; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8700
diff
changeset
|
626 |
|
9921
7c8392a034e6
fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents:
9878
diff
changeset
|
627 // Do a binary lookup in a sorted array. Must not contain NaNs. |
|
8814
de16ebeef93d
improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8725
diff
changeset
|
628 // 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
|
629 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
|
630 |
|
9921
7c8392a034e6
fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents:
9878
diff
changeset
|
631 // Ditto, but for an array of values, specializing on the case when values |
|
7c8392a034e6
fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents:
9878
diff
changeset
|
632 // are sorted. NaNs get the value N. |
|
7c8392a034e6
fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents:
9878
diff
changeset
|
633 Array<octave_idx_type> lookup (const Array<T>& values, sortmode mode = UNSORTED) const; |
|
9341
9fd5c56ce57a
extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
9201
diff
changeset
|
634 |
|
9878
ead4f9c82a9a
implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
635 // Count nonzero elements. |
|
ead4f9c82a9a
implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
636 octave_idx_type nnz (void) const; |
|
ead4f9c82a9a
implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
637 |
| 9025 | 638 // Find indices of (at most n) nonzero elements. If n is specified, backward |
| 639 // specifies search from backward. | |
| 640 Array<octave_idx_type> find (octave_idx_type n = -1, bool backward = false) const; | |
| 641 | |
| 9725 | 642 // Returns the n-th element in increasing order, using the same ordering as |
| 643 // used for sort. n can either be a scalar index or a contiguous range. | |
| 644 Array<T> nth_element (const idx_vector& n, int dim = 0) const; | |
| 645 | |
|
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
646 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
|
647 |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
648 template <class U, class F> |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
649 Array<U> |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
650 map (F fcn) const |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
651 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
652 octave_idx_type len = length (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
653 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
654 const T *m = data (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
655 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
656 Array<U> result (dims ()); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
657 U *p = result.fortran_vec (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
658 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
659 octave_idx_type i; |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
660 for (i = 0; i < len - 3; i += 4) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
661 { |
|
10142
829e69ec3110
make OCTAVE_QUIT a function
Jaroslav Hajek <highegg@gmail.com>
parents:
10115
diff
changeset
|
662 octave_quit (); |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
663 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
664 p[i] = fcn (m[i]); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
665 p[i+1] = fcn (m[i+1]); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
666 p[i+2] = fcn (m[i+2]); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
667 p[i+3] = fcn (m[i+3]); |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
668 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
669 |
|
10142
829e69ec3110
make OCTAVE_QUIT a function
Jaroslav Hajek <highegg@gmail.com>
parents:
10115
diff
changeset
|
670 octave_quit (); |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
671 |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
672 for (; i < len; i++) |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
673 p[i] = fcn (m[i]); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
674 |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
675 return result; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7463
diff
changeset
|
676 } |
|
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
677 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
678 // Overloads for function references. |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
679 template <class U> |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
680 Array<U> |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
681 map (U (&fcn) (T)) const |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
682 { return map<U, U (&) (T)> (fcn); } |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
683 |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
684 template <class U> |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
685 Array<U> |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
686 map (U (&fcn) (const T&)) const |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
687 { return map<U, U (&) (const T&)> (fcn); } |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
688 |
|
9046
88bf56bbccca
make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents:
9026
diff
changeset
|
689 template <class U> friend class Array; |
|
9201
472f0e22aa60
guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents:
9046
diff
changeset
|
690 |
|
472f0e22aa60
guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents:
9046
diff
changeset
|
691 private: |
|
472f0e22aa60
guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents:
9046
diff
changeset
|
692 static void instantiation_guard (); |
| 4513 | 693 }; |
| 4459 | 694 |
|
9653
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
695 // This is a simple wrapper template that will subclass an Array<T> type or any |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
696 // later type derived from it and override the default non-const operator() to |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
697 // not check for the array's uniqueness. It is, however, the user's |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
698 // responsibility to ensure the array is actually unaliased whenever elements |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
699 // are accessed. |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
700 |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
701 template<class ArrayClass> |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
702 class NoAlias : public ArrayClass |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
703 { |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
704 typedef typename ArrayClass::element_type T; |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
705 public: |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
706 NoAlias () : ArrayClass () { } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
707 |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
708 // FIXME: this would be simpler once C++0x is available |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
709 template <class X> |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
710 explicit NoAlias (X x) : ArrayClass (x) { } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
711 |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
712 template <class X, class Y> |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
713 explicit NoAlias (X x, Y y) : ArrayClass (x, y) { } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
714 |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
715 template <class X, class Y, class Z> |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
716 explicit NoAlias (X x, Y y, Z z) : ArrayClass (x, y, z) { } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
717 |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
718 T& operator () (octave_idx_type n) |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
719 { return ArrayClass::xelem (n); } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
720 T& operator () (octave_idx_type i, octave_idx_type j) |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
721 { return ArrayClass::xelem (i, j); } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
722 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
723 { return ArrayClass::xelem (i, j, k); } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
724 T& operator () (const Array<octave_idx_type>& ra_idx) |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
725 { return ArrayClass::xelem (ra_idx); } |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
726 }; |
|
e087d7c77ff9
improve linspace in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9624
diff
changeset
|
727 |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9731
diff
changeset
|
728 template <class T> |
|
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9731
diff
changeset
|
729 std::ostream& |
|
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9731
diff
changeset
|
730 operator << (std::ostream& os, const Array<T>& a); |
|
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9731
diff
changeset
|
731 |
|
9773
01f897d8a130
optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
732 #endif |
|
01f897d8a130
optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
733 |
| 228 | 734 /* |
| 735 ;;; Local Variables: *** | |
| 736 ;;; mode: C++ *** | |
| 737 ;;; End: *** | |
| 738 */ |