Mercurial > octave
annotate src/Cell.cc @ 8732:a669df7beb73
[mq]: x
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Thu, 12 Feb 2009 14:37:43 -0500 |
parents | 280fae940bb0 |
children | eb63fbe60fab |
rev | line source |
---|---|
3353 | 1 /* |
2 | |
7017 | 3 Copyright (C) 1999, 2002, 2003, 2004, 2005, 2006, 2007 John W. Eaton |
3353 | 4 |
5 This file is part of Octave. | |
6 | |
7 Octave is free software; you can redistribute it and/or modify it | |
8 under the terms of the GNU General Public License as published by the | |
7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
10 option) any later version. | |
3353 | 11 |
12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
7016 | 18 along with Octave; see the file COPYING. If not, see |
19 <http://www.gnu.org/licenses/>. | |
3353 | 20 |
21 */ | |
22 | |
23 #ifdef HAVE_CONFIG_H | |
24 #include <config.h> | |
25 #endif | |
26 | |
4513 | 27 #include "idx-vector.h" |
28 | |
3353 | 29 #include "Cell.h" |
4919 | 30 #include "error.h" |
5602 | 31 #include "gripes.h" |
8579
7e0f36dfefbe
implement octave_value_list using Array
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
32 #include "oct-obj.h" |
7e0f36dfefbe
implement octave_value_list using Array
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
33 |
7e0f36dfefbe
implement octave_value_list using Array
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
34 Cell::Cell (const octave_value_list& ovl) |
7e0f36dfefbe
implement octave_value_list using Array
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
35 : ArrayN<octave_value> (ovl.cell_value ()) |
7e0f36dfefbe
implement octave_value_list using Array
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
36 { |
7e0f36dfefbe
implement octave_value_list using Array
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
37 } |
3353 | 38 |
5805 | 39 Cell::Cell (const string_vector& sv, bool trim) |
4513 | 40 : ArrayN<octave_value> () |
4216 | 41 { |
5275 | 42 octave_idx_type n = sv.length (); |
4216 | 43 |
44 if (n > 0) | |
45 { | |
4625 | 46 resize (dim_vector (n, 1)); |
4216 | 47 |
5275 | 48 for (octave_idx_type i = 0; i < n; i++) |
5805 | 49 { |
50 std::string s = sv[i]; | |
51 | |
52 if (trim) | |
53 { | |
5814 | 54 size_t pos = s.find_last_not_of (' '); |
5805 | 55 |
8021 | 56 s = (pos == std::string::npos) ? "" : s.substr (0, pos+1); |
5805 | 57 } |
58 | |
59 elem(i,0) = s; | |
60 } | |
4216 | 61 } |
62 } | |
3354 | 63 |
8732 | 64 Cell::Cell (const Array<std::string>& sa) |
65 : ArrayN<octave_value> (sa.dims ()) | |
66 { | |
67 octave_idx_type n = sa.numel (); | |
68 | |
69 octave_value *dst = fortran_vec (); | |
70 const std::string *src = sa.data (); | |
71 | |
72 for (octave_idx_type i = 0; i < n; i++) | |
73 dst[i] = src[i]; | |
74 } | |
75 | |
6116 | 76 // Set size to DV, filling with []. Then fill with as many elements of |
77 // SV as possible. | |
7209 | 78 |
6116 | 79 Cell::Cell (const dim_vector& dv, const string_vector& sv, bool trim) |
7209 | 80 : ArrayN<octave_value> (dv, resize_fill_value ()) |
6116 | 81 { |
82 octave_idx_type n = sv.length (); | |
83 | |
84 if (n > 0) | |
85 { | |
86 octave_idx_type m = numel (); | |
87 | |
88 octave_idx_type len = n > m ? m : n; | |
89 | |
90 for (octave_idx_type i = 0; i < len; i++) | |
91 { | |
92 std::string s = sv[i]; | |
93 | |
94 if (trim) | |
95 { | |
96 size_t pos = s.find_last_not_of (' '); | |
97 | |
8021 | 98 s = (pos == std::string::npos) ? "" : s.substr (0, pos+1); |
6116 | 99 } |
100 | |
101 elem(i) = s; | |
102 } | |
103 } | |
104 } | |
105 | |
106 bool | |
107 Cell::is_cellstr (void) const | |
108 { | |
109 bool retval = true; | |
110 | |
111 for (int i = 0; i < numel (); i++) | |
112 { | |
113 if (! elem(i).is_string ()) | |
114 { | |
115 retval = false; | |
116 break; | |
117 } | |
118 } | |
119 | |
120 return retval; | |
121 } | |
122 | |
4513 | 123 Cell |
4587 | 124 Cell::index (const octave_value_list& idx_arg, bool resize_ok) const |
4513 | 125 { |
126 Cell retval; | |
127 | |
5275 | 128 octave_idx_type n = idx_arg.length (); |
4513 | 129 |
130 switch (n) | |
131 { | |
5539 | 132 case 0: |
133 retval = *this; | |
134 break; | |
135 | |
4513 | 136 case 1: |
137 { | |
4587 | 138 idx_vector i = idx_arg(0).index_vector (); |
4513 | 139 |
4919 | 140 if (! error_state) |
8679
280fae940bb0
optimize scalar indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8579
diff
changeset
|
141 retval = ArrayN<octave_value>::index (i, resize_ok); |
4513 | 142 } |
143 break; | |
144 | |
145 case 2: | |
146 { | |
4587 | 147 idx_vector i = idx_arg(0).index_vector (); |
4513 | 148 |
4919 | 149 if (! error_state) |
150 { | |
151 idx_vector j = idx_arg(1).index_vector (); | |
152 | |
153 if (! error_state) | |
8679
280fae940bb0
optimize scalar indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8579
diff
changeset
|
154 retval = ArrayN<octave_value>::index (i, j, resize_ok); |
4919 | 155 } |
4513 | 156 } |
157 break; | |
158 | |
159 default: | |
160 { | |
161 Array<idx_vector> iv (n); | |
162 | |
5275 | 163 for (octave_idx_type i = 0; i < n; i++) |
4919 | 164 { |
165 iv(i) = idx_arg(i).index_vector (); | |
4513 | 166 |
4919 | 167 if (error_state) |
168 break; | |
169 } | |
170 | |
171 if (!error_state) | |
8679
280fae940bb0
optimize scalar indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8579
diff
changeset
|
172 retval = ArrayN<octave_value>::index (iv, resize_ok); |
4513 | 173 } |
174 break; | |
175 } | |
176 | |
177 return retval; | |
178 } | |
179 | |
180 Cell& | |
4587 | 181 Cell::assign (const octave_value_list& idx_arg, const Cell& rhs, |
4513 | 182 const octave_value& fill_val) |
183 | |
184 { | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
185 octave_idx_type len = idx_arg.length (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
186 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
187 Array<idx_vector> ra_idx (len); |
4513 | 188 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
189 for (octave_idx_type i = 0; i < len; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
190 ra_idx(i) = idx_arg(i).index_vector (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
191 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
192 Array<octave_value>::assign (ra_idx, rhs, fill_val); |
4513 | 193 |
194 return *this; | |
195 } | |
196 | |
8175
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
197 Cell& |
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
198 Cell::delete_elements (const octave_value_list& idx_arg) |
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
199 |
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
200 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
201 octave_idx_type len = idx_arg.length (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
202 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
203 Array<idx_vector> ra_idx (len); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
204 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
205 for (octave_idx_type i = 0; i < len; i++) |
8175
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
206 ra_idx.xelem (i) = idx_arg(i).index_vector (); |
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
207 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
208 Array<octave_value>::delete_elements (ra_idx); |
8175
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
209 |
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
210 return *this; |
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
211 } |
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
212 |
5602 | 213 octave_idx_type |
214 Cell::nnz (void) const | |
215 { | |
216 gripe_wrong_type_arg ("nnz", "cell array"); | |
217 return -1; | |
218 } | |
219 | |
4915 | 220 Cell |
5570 | 221 Cell::column (octave_idx_type i) const |
222 { | |
223 Cell retval; | |
224 | |
225 if (ndims () < 3) | |
226 { | |
227 if (i < 0 || i >= cols ()) | |
228 error ("invalid column selection"); | |
229 else | |
230 { | |
231 octave_idx_type nr = rows (); | |
232 | |
233 retval.resize (dim_vector (nr, 1)); | |
234 | |
235 for (octave_idx_type j = 0; j < nr; j++) | |
236 retval.xelem (j) = elem (j, i); | |
237 } | |
238 } | |
239 else | |
240 error ("Cell::column: requires 2-d cell array"); | |
241 | |
242 return retval; | |
243 } | |
244 | |
245 Cell | |
5275 | 246 Cell::concat (const Cell& rb, const Array<octave_idx_type>& ra_idx) |
4806 | 247 { |
5073 | 248 return insert (rb, ra_idx); |
4915 | 249 } |
250 | |
251 Cell& | |
5275 | 252 Cell::insert (const Cell& a, octave_idx_type r, octave_idx_type c) |
4915 | 253 { |
254 Array<octave_value>::insert (a, r, c); | |
255 return *this; | |
256 } | |
257 | |
258 Cell& | |
5275 | 259 Cell::insert (const Cell& a, const Array<octave_idx_type>& ra_idx) |
4915 | 260 { |
261 Array<octave_value>::insert (a, ra_idx); | |
262 return *this; | |
4806 | 263 } |
264 | |
7530
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
265 Cell |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
266 Cell::map (ctype_mapper fcn) const |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
267 { |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
268 Cell retval (dims ()); |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
269 octave_value *r = retval.fortran_vec (); |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
270 |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
271 const octave_value *p = data (); |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
272 |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
273 for (octave_idx_type i = 0; i < numel (); i++) |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
274 r[i] = ((p++)->*fcn) (); |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
275 |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
276 return retval; |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
277 } |
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
278 |
7618
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
279 Cell |
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
280 Cell::diag (octave_idx_type k) const |
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
281 { |
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
282 return ArrayN<octave_value>::diag (k); |
7618
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
283 } |
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
284 |
3353 | 285 /* |
286 ;;; Local Variables: *** | |
287 ;;; mode: C++ *** | |
288 ;;; End: *** | |
289 */ |