Mercurial > hg > octave-nkf
annotate src/Cell.cc @ 8290:7cbe01c21986
improve dense array indexing
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Mon, 20 Oct 2008 16:54:28 +0200 |
| parents | 6c08e3921d3e |
| children | 7e0f36dfefbe |
| 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" |
| 3353 | 32 |
| 5805 | 33 Cell::Cell (const string_vector& sv, bool trim) |
| 4513 | 34 : ArrayN<octave_value> () |
| 4216 | 35 { |
| 5275 | 36 octave_idx_type n = sv.length (); |
| 4216 | 37 |
| 38 if (n > 0) | |
| 39 { | |
| 4625 | 40 resize (dim_vector (n, 1)); |
| 4216 | 41 |
| 5275 | 42 for (octave_idx_type i = 0; i < n; i++) |
| 5805 | 43 { |
| 44 std::string s = sv[i]; | |
| 45 | |
| 46 if (trim) | |
| 47 { | |
| 5814 | 48 size_t pos = s.find_last_not_of (' '); |
| 5805 | 49 |
| 8021 | 50 s = (pos == std::string::npos) ? "" : s.substr (0, pos+1); |
| 5805 | 51 } |
| 52 | |
| 53 elem(i,0) = s; | |
| 54 } | |
| 4216 | 55 } |
| 56 } | |
| 3354 | 57 |
| 6116 | 58 // Set size to DV, filling with []. Then fill with as many elements of |
| 59 // SV as possible. | |
| 7209 | 60 |
| 6116 | 61 Cell::Cell (const dim_vector& dv, const string_vector& sv, bool trim) |
| 7209 | 62 : ArrayN<octave_value> (dv, resize_fill_value ()) |
| 6116 | 63 { |
| 64 octave_idx_type n = sv.length (); | |
| 65 | |
| 66 if (n > 0) | |
| 67 { | |
| 68 octave_idx_type m = numel (); | |
| 69 | |
| 70 octave_idx_type len = n > m ? m : n; | |
| 71 | |
| 72 for (octave_idx_type i = 0; i < len; i++) | |
| 73 { | |
| 74 std::string s = sv[i]; | |
| 75 | |
| 76 if (trim) | |
| 77 { | |
| 78 size_t pos = s.find_last_not_of (' '); | |
| 79 | |
| 8021 | 80 s = (pos == std::string::npos) ? "" : s.substr (0, pos+1); |
| 6116 | 81 } |
| 82 | |
| 83 elem(i) = s; | |
| 84 } | |
| 85 } | |
| 86 } | |
| 87 | |
| 88 bool | |
| 89 Cell::is_cellstr (void) const | |
| 90 { | |
| 91 bool retval = true; | |
| 92 | |
| 93 for (int i = 0; i < numel (); i++) | |
| 94 { | |
| 95 if (! elem(i).is_string ()) | |
| 96 { | |
| 97 retval = false; | |
| 98 break; | |
| 99 } | |
| 100 } | |
| 101 | |
| 102 return retval; | |
| 103 } | |
| 104 | |
| 4513 | 105 Cell |
| 4587 | 106 Cell::index (const octave_value_list& idx_arg, bool resize_ok) const |
| 4513 | 107 { |
| 108 Cell retval; | |
| 109 | |
| 5275 | 110 octave_idx_type n = idx_arg.length (); |
| 4513 | 111 |
| 112 switch (n) | |
| 113 { | |
| 5539 | 114 case 0: |
| 115 retval = *this; | |
| 116 break; | |
| 117 | |
| 4513 | 118 case 1: |
| 119 { | |
| 4587 | 120 idx_vector i = idx_arg(0).index_vector (); |
| 4513 | 121 |
| 4919 | 122 if (! error_state) |
| 123 retval = index (i, resize_ok); | |
| 4513 | 124 } |
| 125 break; | |
| 126 | |
| 127 case 2: | |
| 128 { | |
| 4587 | 129 idx_vector i = idx_arg(0).index_vector (); |
| 4513 | 130 |
| 4919 | 131 if (! error_state) |
| 132 { | |
| 133 idx_vector j = idx_arg(1).index_vector (); | |
| 134 | |
| 135 if (! error_state) | |
| 136 retval = index (i, j, resize_ok); | |
| 137 } | |
| 4513 | 138 } |
| 139 break; | |
| 140 | |
| 141 default: | |
| 142 { | |
| 143 Array<idx_vector> iv (n); | |
| 144 | |
| 5275 | 145 for (octave_idx_type i = 0; i < n; i++) |
| 4919 | 146 { |
| 147 iv(i) = idx_arg(i).index_vector (); | |
| 4513 | 148 |
| 4919 | 149 if (error_state) |
| 150 break; | |
| 151 } | |
| 152 | |
| 153 if (!error_state) | |
| 154 retval = index (iv, resize_ok); | |
| 4513 | 155 } |
| 156 break; | |
| 157 } | |
| 158 | |
| 159 return retval; | |
| 160 } | |
| 161 | |
| 162 Cell& | |
| 4587 | 163 Cell::assign (const octave_value_list& idx_arg, const Cell& rhs, |
| 4513 | 164 const octave_value& fill_val) |
| 165 | |
| 166 { | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
167 octave_idx_type len = idx_arg.length (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
168 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
169 Array<idx_vector> ra_idx (len); |
| 4513 | 170 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
171 for (octave_idx_type i = 0; i < len; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
172 ra_idx(i) = idx_arg(i).index_vector (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
173 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
174 Array<octave_value>::assign (ra_idx, rhs, fill_val); |
| 4513 | 175 |
| 176 return *this; | |
| 177 } | |
| 178 | |
|
8175
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
179 Cell& |
|
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
180 Cell::delete_elements (const octave_value_list& idx_arg) |
|
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
181 |
|
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
182 { |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
183 octave_idx_type len = idx_arg.length (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
184 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
185 Array<idx_vector> ra_idx (len); |
|
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 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
|
188 ra_idx.xelem (i) = idx_arg(i).index_vector (); |
|
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
189 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8179
diff
changeset
|
190 Array<octave_value>::delete_elements (ra_idx); |
|
8175
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
191 |
|
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
192 return *this; |
|
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
193 } |
|
977d5204cf67
fix null assignment for structs
Jaroslav Hajek <highegg@gmail.com>
parents:
8021
diff
changeset
|
194 |
| 5602 | 195 octave_idx_type |
| 196 Cell::nnz (void) const | |
| 197 { | |
| 198 gripe_wrong_type_arg ("nnz", "cell array"); | |
| 199 return -1; | |
| 200 } | |
| 201 | |
| 4915 | 202 Cell |
| 5570 | 203 Cell::column (octave_idx_type i) const |
| 204 { | |
| 205 Cell retval; | |
| 206 | |
| 207 if (ndims () < 3) | |
| 208 { | |
| 209 if (i < 0 || i >= cols ()) | |
| 210 error ("invalid column selection"); | |
| 211 else | |
| 212 { | |
| 213 octave_idx_type nr = rows (); | |
| 214 | |
| 215 retval.resize (dim_vector (nr, 1)); | |
| 216 | |
| 217 for (octave_idx_type j = 0; j < nr; j++) | |
| 218 retval.xelem (j) = elem (j, i); | |
| 219 } | |
| 220 } | |
| 221 else | |
| 222 error ("Cell::column: requires 2-d cell array"); | |
| 223 | |
| 224 return retval; | |
| 225 } | |
| 226 | |
| 227 Cell | |
| 5275 | 228 Cell::concat (const Cell& rb, const Array<octave_idx_type>& ra_idx) |
| 4806 | 229 { |
| 5073 | 230 return insert (rb, ra_idx); |
| 4915 | 231 } |
| 232 | |
| 233 Cell& | |
| 5275 | 234 Cell::insert (const Cell& a, octave_idx_type r, octave_idx_type c) |
| 4915 | 235 { |
| 236 Array<octave_value>::insert (a, r, c); | |
| 237 return *this; | |
| 238 } | |
| 239 | |
| 240 Cell& | |
| 5275 | 241 Cell::insert (const Cell& a, const Array<octave_idx_type>& ra_idx) |
| 4915 | 242 { |
| 243 Array<octave_value>::insert (a, ra_idx); | |
| 244 return *this; | |
| 4806 | 245 } |
| 246 | |
|
7530
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
247 Cell |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
248 Cell::map (ctype_mapper fcn) const |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
249 { |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
250 Cell retval (dims ()); |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
251 octave_value *r = retval.fortran_vec (); |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
252 |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
253 const octave_value *p = data (); |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
254 |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
255 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
|
256 r[i] = ((p++)->*fcn) (); |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
257 |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
258 return retval; |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
259 } |
|
bb0f2353cff5
new cell array ctype mappers
John W. Eaton <jwe@octave.org>
parents:
7209
diff
changeset
|
260 |
|
7618
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
261 Cell |
|
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
262 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
|
263 { |
|
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
264 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
|
265 } |
|
3209a584e1ac
Further type preservation tests and fix of diag for cell arrays
David Bateman <dbateman@free.fr>
parents:
7530
diff
changeset
|
266 |
| 3353 | 267 /* |
| 268 ;;; Local Variables: *** | |
| 269 ;;; mode: C++ *** | |
| 270 ;;; End: *** | |
| 271 */ |