|
1
|
1 /* |
|
|
2 |
|
7017
|
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, |
|
|
4 2003, 2004, 2005, 2006, 2007 John W. Eaton |
|
1
|
5 |
|
|
6 This file is part of Octave. |
|
|
7 |
|
|
8 Octave is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
7016
|
10 Free Software Foundation; either version 3 of the License, or (at your |
|
|
11 option) any later version. |
|
1
|
12 |
|
|
13 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
16 for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
7016
|
19 along with Octave; see the file COPYING. If not, see |
|
|
20 <http://www.gnu.org/licenses/>. |
|
1
|
21 |
|
|
22 */ |
|
|
23 |
|
240
|
24 #ifdef HAVE_CONFIG_H |
|
1192
|
25 #include <config.h> |
|
1
|
26 #endif |
|
|
27 |
|
1343
|
28 #include <cstdlib> |
|
|
29 |
|
3503
|
30 #include <iostream> |
|
164
|
31 |
|
1352
|
32 #include "Range.h" |
|
4650
|
33 #include "boolNDArray.h" |
|
1560
|
34 #include "dColVector.h" |
|
4650
|
35 #include "dNDArray.h" |
|
1352
|
36 |
|
1
|
37 #include "idx-vector.h" |
|
1560
|
38 #include "lo-error.h" |
|
2500
|
39 #include "lo-mappers.h" |
|
1
|
40 |
|
1560
|
41 #define IDX_VEC_REP idx_vector::idx_vector_rep |
|
|
42 |
|
|
43 IDX_VEC_REP::idx_vector_rep (const IDX_VEC_REP& a) |
|
4653
|
44 : data (0), len (a.len), num_zeros (a.num_zeros), num_ones (a.num_ones), |
|
|
45 max_val (a.max_val), min_val (a.min_val), |
|
|
46 frozen_at_z_len (a.frozen_at_z_len), frozen_len (a.frozen_len), |
|
|
47 colon (a.colon), one_zero (a.one_zero), initialized (a.initialized), |
|
|
48 frozen (a.frozen), colon_equiv_checked (a.colon_equiv_checked), |
|
|
49 colon_equiv (a.colon_equiv), orig_dims (a.orig_dims) |
|
1
|
50 { |
|
|
51 if (len > 0) |
|
|
52 { |
|
5275
|
53 data = new octave_idx_type [len]; |
|
|
54 for (octave_idx_type i = 0; i < len; i++) |
|
1
|
55 data[i] = a.data[i]; |
|
|
56 } |
|
|
57 } |
|
|
58 |
|
5275
|
59 octave_idx_type |
|
4938
|
60 IDX_VEC_REP::tree_to_mat_idx (double x, bool& conversion_error) |
|
1
|
61 { |
|
5275
|
62 octave_idx_type retval = -1; |
|
4732
|
63 |
|
|
64 conversion_error = false; |
|
|
65 |
|
|
66 if (D_NINT (x) != x) |
|
|
67 { |
|
|
68 (*current_liboctave_error_handler) |
|
|
69 ("expecting integer index, found %f", x); |
|
|
70 |
|
|
71 conversion_error = true; |
|
|
72 } |
|
|
73 else |
|
5275
|
74 retval = static_cast<octave_idx_type> (x - 1); |
|
4732
|
75 |
|
|
76 return retval; |
|
3928
|
77 } |
|
|
78 |
|
2500
|
79 static inline bool |
|
|
80 idx_is_inf_or_nan (double x) |
|
|
81 { |
|
|
82 bool retval = false; |
|
|
83 |
|
|
84 if (xisnan (x)) |
|
|
85 { |
|
|
86 (*current_liboctave_error_handler) ("NaN invalid as index"); |
|
|
87 retval = true; |
|
|
88 } |
|
|
89 else if (xisinf (x)) |
|
|
90 { |
|
|
91 (*current_liboctave_error_handler) ("Inf invalid as index"); |
|
|
92 retval = true; |
|
|
93 } |
|
|
94 |
|
|
95 return retval; |
|
1
|
96 } |
|
|
97 |
|
1560
|
98 IDX_VEC_REP::idx_vector_rep (const ColumnVector& v) |
|
4653
|
99 : data (0), len (v.length ()), num_zeros (0), num_ones (0), max_val (0), |
|
|
100 min_val (0), count (1), frozen_at_z_len (0), frozen_len (0), |
|
|
101 colon (0), one_zero (0), initialized (0), frozen (0), |
|
|
102 colon_equiv_checked (0), colon_equiv (0), orig_dims (len, 1) |
|
1
|
103 { |
|
1560
|
104 if (len == 0) |
|
1
|
105 { |
|
191
|
106 initialized = 1; |
|
1
|
107 return; |
|
|
108 } |
|
1560
|
109 else |
|
1
|
110 { |
|
5275
|
111 data = new octave_idx_type [len]; |
|
2500
|
112 |
|
4732
|
113 bool conversion_error = false; |
|
|
114 |
|
5275
|
115 for (octave_idx_type i = 0; i < len; i++) |
|
2500
|
116 { |
|
|
117 double d = v.elem (i); |
|
|
118 |
|
|
119 if (idx_is_inf_or_nan (d)) |
|
|
120 return; |
|
|
121 else |
|
4732
|
122 data[i] = tree_to_mat_idx (d, conversion_error); |
|
|
123 |
|
|
124 if (conversion_error) |
|
|
125 return; |
|
2500
|
126 } |
|
1
|
127 } |
|
1560
|
128 |
|
|
129 init_state (); |
|
|
130 } |
|
|
131 |
|
4650
|
132 IDX_VEC_REP::idx_vector_rep (const NDArray& nda) |
|
4653
|
133 : data (0), len (nda.length ()), num_zeros (0), num_ones (0), |
|
|
134 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
|
|
135 frozen_len (0), colon (0), one_zero (0), initialized (0), |
|
|
136 frozen (0), colon_equiv_checked (0), colon_equiv (0), |
|
|
137 orig_dims (nda.dims ()) |
|
1560
|
138 { |
|
|
139 if (len == 0) |
|
1
|
140 { |
|
1560
|
141 initialized = 1; |
|
|
142 return; |
|
1
|
143 } |
|
|
144 else |
|
|
145 { |
|
5275
|
146 octave_idx_type k = 0; |
|
|
147 data = new octave_idx_type [len]; |
|
2500
|
148 |
|
4732
|
149 bool conversion_error = false; |
|
|
150 |
|
5275
|
151 for (octave_idx_type i = 0; i < len; i++) |
|
4650
|
152 { |
|
|
153 double d = nda.elem (i); |
|
2500
|
154 |
|
4650
|
155 if (idx_is_inf_or_nan (d)) |
|
|
156 return; |
|
|
157 else |
|
4732
|
158 data[k++] = tree_to_mat_idx (d, conversion_error); |
|
|
159 |
|
|
160 if (conversion_error) |
|
|
161 return; |
|
4650
|
162 } |
|
1
|
163 } |
|
|
164 |
|
1560
|
165 init_state (); |
|
1
|
166 } |
|
|
167 |
|
1560
|
168 IDX_VEC_REP::idx_vector_rep (const Range& r) |
|
4653
|
169 : data (0), len (r.nelem ()), num_zeros (0), num_ones (0), |
|
|
170 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
|
|
171 frozen_len (0), colon (0), one_zero (0), initialized (0), |
|
|
172 frozen (0), colon_equiv_checked (0), colon_equiv (0), |
|
|
173 orig_dims (1, len) |
|
1
|
174 { |
|
191
|
175 if (len < 0) |
|
|
176 { |
|
1560
|
177 (*current_liboctave_error_handler) ("invalid range used as index"); |
|
191
|
178 return; |
|
|
179 } |
|
|
180 else if (len == 0) |
|
|
181 { |
|
|
182 initialized = 1; |
|
|
183 return; |
|
|
184 } |
|
1
|
185 |
|
5275
|
186 data = new octave_idx_type [len]; |
|
1
|
187 |
|
6457
|
188 // If all elements are ints, we can generate the indexes as integers |
|
|
189 // and save tons of tests. |
|
4732
|
190 |
|
6457
|
191 if (r.all_elements_are_ints ()) |
|
|
192 { |
|
|
193 octave_idx_type b = static_cast<octave_idx_type> (r.base ()); |
|
|
194 octave_idx_type step = static_cast<octave_idx_type> (r.inc ()); |
|
2500
|
195 |
|
6457
|
196 data[0] = b - 1; |
|
|
197 for (octave_idx_type i = 1; i < len; i++) |
|
|
198 data[i] = data[i-1] + step; |
|
4732
|
199 |
|
6884
|
200 // Don't use init_state(), as it can be vastly accelerated since |
|
|
201 // we don't have to search all values for max/min, etc. |
|
|
202 if (step >= 0) |
|
|
203 { |
|
|
204 min_val = data [0]; |
|
|
205 max_val = data [len - 1]; |
|
|
206 } |
|
|
207 else |
|
|
208 { |
|
|
209 min_val = data [len - 1]; |
|
|
210 max_val = data [0]; |
|
|
211 } |
|
|
212 |
|
|
213 if ((b <= 0 && step > 0) || (b >= 0 && step < 0)) |
|
|
214 num_zeros = 1; |
|
|
215 if ((b <= 1 && step > 0) || (b >= 1 && step < 0)) |
|
|
216 num_zeros = 0; |
|
|
217 |
|
|
218 initialized = 1; |
|
1
|
219 } |
|
6457
|
220 else |
|
|
221 (*current_liboctave_error_handler) |
|
|
222 ("expecting integer index, found non integer Range"); |
|
1
|
223 } |
|
|
224 |
|
3928
|
225 IDX_VEC_REP::idx_vector_rep (double d) |
|
4653
|
226 : data (0), len (1), num_zeros (0), num_ones (0), |
|
|
227 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
|
|
228 frozen_len (0), colon (0), one_zero (0), initialized (0), |
|
|
229 frozen (0), colon_equiv_checked (0), colon_equiv (0), |
|
|
230 orig_dims (1, 1) |
|
3928
|
231 { |
|
|
232 if (idx_is_inf_or_nan (d)) |
|
|
233 return; |
|
|
234 else |
|
|
235 { |
|
5275
|
236 data = new octave_idx_type [len]; |
|
3928
|
237 |
|
4732
|
238 bool conversion_error = false; |
|
|
239 |
|
|
240 data[0] = tree_to_mat_idx (d, conversion_error); |
|
|
241 |
|
|
242 if (conversion_error) |
|
|
243 return; |
|
3928
|
244 } |
|
|
245 |
|
|
246 init_state (); |
|
|
247 } |
|
|
248 |
|
5275
|
249 IDX_VEC_REP::idx_vector_rep (octave_idx_type i) |
|
4653
|
250 : data (0), len (1), num_zeros (0), num_ones (0), |
|
|
251 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
|
|
252 frozen_len (0), colon (0), one_zero (0), initialized (0), |
|
|
253 frozen (0), colon_equiv_checked (0), colon_equiv (0), |
|
|
254 orig_dims (1, 1) |
|
3928
|
255 { |
|
5275
|
256 data = new octave_idx_type [len]; |
|
3928
|
257 |
|
|
258 data[0] = tree_to_mat_idx (i); |
|
|
259 |
|
|
260 init_state (); |
|
|
261 } |
|
|
262 |
|
1560
|
263 IDX_VEC_REP::idx_vector_rep (char c) |
|
4653
|
264 : data (0), len (0), num_zeros (0), num_ones (0), |
|
|
265 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
|
|
266 frozen_len (0), colon (1), one_zero (0), initialized (0), |
|
|
267 frozen (0), colon_equiv_checked (0), colon_equiv (0), |
|
|
268 orig_dims (0, 0) |
|
1560
|
269 { |
|
|
270 assert (c == ':'); |
|
|
271 |
|
|
272 init_state (); |
|
|
273 } |
|
|
274 |
|
2828
|
275 IDX_VEC_REP::idx_vector_rep (bool b) |
|
4653
|
276 : data (0), len (1), num_zeros (0), num_ones (0), |
|
|
277 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
|
|
278 frozen_len (0), colon (0), one_zero (1), initialized (0), |
|
|
279 frozen (0), colon_equiv_checked (0), colon_equiv (0), |
|
|
280 orig_dims (1, 1) |
|
2828
|
281 { |
|
5275
|
282 data = new octave_idx_type [len]; |
|
2828
|
283 |
|
|
284 data[0] = tree_to_mat_idx (b); |
|
|
285 |
|
|
286 init_state (); |
|
|
287 } |
|
|
288 |
|
4650
|
289 IDX_VEC_REP::idx_vector_rep (const boolNDArray& bnda) |
|
4653
|
290 : data (0), len (bnda.length ()), num_zeros (0), num_ones (0), |
|
|
291 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
|
|
292 frozen_len (0), colon (0), one_zero (1), initialized (0), |
|
|
293 frozen (0), colon_equiv_checked (0), colon_equiv (0), |
|
|
294 orig_dims (bnda.dims ()) |
|
2828
|
295 { |
|
|
296 if (len == 0) |
|
|
297 { |
|
|
298 initialized = 1; |
|
|
299 return; |
|
|
300 } |
|
|
301 else |
|
|
302 { |
|
5275
|
303 octave_idx_type k = 0; |
|
|
304 data = new octave_idx_type [len]; |
|
2828
|
305 |
|
5275
|
306 for (octave_idx_type i = 0; i < len; i++) |
|
4650
|
307 data[k++] = tree_to_mat_idx (bnda.elem (i)); |
|
2828
|
308 } |
|
|
309 |
|
|
310 init_state (); |
|
|
311 } |
|
|
312 |
|
1560
|
313 IDX_VEC_REP& |
|
|
314 IDX_VEC_REP::operator = (const IDX_VEC_REP& a) |
|
1
|
315 { |
|
|
316 if (this != &a) |
|
|
317 { |
|
|
318 delete [] data; |
|
|
319 len = a.len; |
|
5275
|
320 data = new octave_idx_type [len]; |
|
|
321 for (octave_idx_type i = 0; i < len; i++) |
|
1
|
322 data[i] = a.data[i]; |
|
|
323 |
|
|
324 num_zeros = a.num_zeros; |
|
|
325 num_ones = a.num_ones; |
|
|
326 max_val = a.max_val; |
|
|
327 min_val = a.min_val; |
|
4653
|
328 frozen_at_z_len = a.frozen_at_z_len; |
|
|
329 frozen_len = a.frozen_len; |
|
|
330 colon = a.colon; |
|
|
331 one_zero = a.one_zero; |
|
|
332 initialized = a.initialized; |
|
|
333 frozen = a.frozen; |
|
|
334 colon_equiv_checked = a.colon_equiv_checked; |
|
|
335 colon_equiv = a.colon_equiv; |
|
|
336 orig_dims = a.orig_dims; |
|
1
|
337 } |
|
4653
|
338 |
|
1
|
339 return *this; |
|
|
340 } |
|
|
341 |
|
|
342 void |
|
1560
|
343 IDX_VEC_REP::init_state (void) |
|
1
|
344 { |
|
|
345 num_zeros = 0; |
|
|
346 num_ones = 0; |
|
|
347 |
|
1560
|
348 if (colon) |
|
1
|
349 { |
|
2828
|
350 min_val = 0; |
|
|
351 max_val = 0; |
|
1
|
352 } |
|
|
353 else |
|
|
354 { |
|
|
355 min_val = max_val = data[0]; |
|
|
356 |
|
5275
|
357 octave_idx_type i = 0; |
|
1
|
358 do |
|
|
359 { |
|
1560
|
360 if (data[i] == -1) |
|
|
361 num_zeros++; |
|
|
362 else if (data[i] == 0) |
|
|
363 num_ones++; |
|
|
364 |
|
1
|
365 if (data[i] > max_val) |
|
|
366 max_val = data[i]; |
|
|
367 |
|
|
368 if (data[i] < min_val) |
|
|
369 min_val = data[i]; |
|
|
370 } |
|
|
371 while (++i < len); |
|
|
372 } |
|
1560
|
373 |
|
|
374 initialized = 1; |
|
|
375 } |
|
|
376 |
|
|
377 void |
|
5275
|
378 IDX_VEC_REP::maybe_convert_one_zero_to_idx (octave_idx_type z_len) |
|
1560
|
379 { |
|
3680
|
380 if (one_zero && (z_len == len || z_len == 0)) |
|
1560
|
381 { |
|
|
382 if (num_ones == 0) |
|
|
383 { |
|
|
384 len = 0; |
|
|
385 max_val = 0; |
|
|
386 min_val = 0; |
|
|
387 delete [] data; |
|
|
388 data = 0; |
|
|
389 } |
|
|
390 else |
|
|
391 { |
|
|
392 assert (num_ones + num_zeros == len); |
|
|
393 |
|
5275
|
394 octave_idx_type *new_data = new octave_idx_type [num_ones]; |
|
|
395 octave_idx_type k = 0; |
|
|
396 for (octave_idx_type i = 0; i < len; i++) |
|
1560
|
397 if (data[i] == 0) |
|
1650
|
398 new_data[k++] = i; |
|
1560
|
399 |
|
|
400 delete [] data; |
|
|
401 len = num_ones; |
|
|
402 data = new_data; |
|
|
403 |
|
|
404 min_val = max_val = data[0]; |
|
|
405 |
|
5275
|
406 octave_idx_type i = 0; |
|
1560
|
407 do |
|
|
408 { |
|
|
409 if (data[i] > max_val) |
|
|
410 max_val = data[i]; |
|
|
411 |
|
|
412 if (data[i] < min_val) |
|
|
413 min_val = data[i]; |
|
|
414 } |
|
|
415 while (++i < len); |
|
|
416 } |
|
|
417 } |
|
1
|
418 } |
|
|
419 |
|
5275
|
420 octave_idx_type |
|
|
421 IDX_VEC_REP::checkelem (octave_idx_type n) const |
|
227
|
422 { |
|
|
423 if (n < 0 || n >= len) |
|
|
424 { |
|
1560
|
425 (*current_liboctave_error_handler) ("idx-vector: index out of range"); |
|
227
|
426 return 0; |
|
|
427 } |
|
|
428 |
|
|
429 return elem (n); |
|
|
430 } |
|
|
431 |
|
1552
|
432 static inline int |
|
3262
|
433 intcmp (const void *ii, const void *jj) |
|
1552
|
434 { |
|
5275
|
435 return (*(static_cast<const octave_idx_type *> (ii)) - *(static_cast<const octave_idx_type *> (jj))); |
|
1552
|
436 } |
|
|
437 |
|
1560
|
438 static inline void |
|
5275
|
439 sort_data (octave_idx_type *d, octave_idx_type l) |
|
1560
|
440 { |
|
5275
|
441 qsort (d, l, sizeof (octave_idx_type), intcmp); |
|
1560
|
442 } |
|
|
443 |
|
5275
|
444 static inline octave_idx_type |
|
|
445 make_uniq (octave_idx_type *d, octave_idx_type l) |
|
1560
|
446 { |
|
3125
|
447 if (l < 2) |
|
|
448 return l; |
|
|
449 |
|
5275
|
450 octave_idx_type k = 0; |
|
|
451 for (octave_idx_type ii = 1; ii < l; ii++) |
|
1560
|
452 { |
|
1650
|
453 if (d[ii] != d[k]) |
|
1560
|
454 { |
|
|
455 k++; |
|
1650
|
456 d[k] = d[ii]; |
|
1560
|
457 } |
|
|
458 } |
|
|
459 return k+1; |
|
|
460 } |
|
|
461 |
|
5275
|
462 static inline octave_idx_type * |
|
|
463 copy_data (const octave_idx_type *d, octave_idx_type l) |
|
209
|
464 { |
|
5275
|
465 octave_idx_type *new_data = new octave_idx_type [l]; |
|
1560
|
466 |
|
5275
|
467 for (octave_idx_type ii = 0; ii < l; ii++) |
|
1650
|
468 new_data[ii] = d[ii]; |
|
1560
|
469 |
|
|
470 return new_data; |
|
|
471 } |
|
|
472 |
|
|
473 int |
|
5275
|
474 IDX_VEC_REP::is_colon_equiv (octave_idx_type n, int sort_uniq) |
|
1560
|
475 { |
|
|
476 if (! colon_equiv_checked) |
|
|
477 { |
|
|
478 if (colon) |
|
|
479 { |
|
|
480 colon_equiv = 1; |
|
|
481 } |
|
5275
|
482 else if (static_cast<octave_idx_type> (len) > 1) |
|
1560
|
483 { |
|
3472
|
484 if (one_zero) |
|
|
485 { |
|
|
486 colon_equiv = (len == n && ones_count () == n); |
|
|
487 } |
|
|
488 else if (sort_uniq) |
|
2356
|
489 { |
|
5275
|
490 octave_idx_type *tmp_data = copy_data (data, len); |
|
2966
|
491 |
|
2356
|
492 sort_data (tmp_data, len); |
|
|
493 |
|
5275
|
494 octave_idx_type tmp_len = make_uniq (tmp_data, len); |
|
2966
|
495 |
|
|
496 colon_equiv = (tmp_len == n |
|
|
497 && tmp_data[0] == 0 |
|
|
498 && tmp_data[tmp_len-1] == tmp_len - 1); |
|
1560
|
499 |
|
2966
|
500 delete [] tmp_data; |
|
|
501 } |
|
|
502 else |
|
|
503 { |
|
|
504 if (len == n) |
|
|
505 { |
|
|
506 colon_equiv = 1; |
|
1560
|
507 |
|
5275
|
508 for (octave_idx_type ii = 0; ii < n; ii++) |
|
2966
|
509 if (data[ii] != ii) |
|
|
510 { |
|
|
511 colon_equiv = 0; |
|
|
512 break; |
|
|
513 } |
|
|
514 } |
|
|
515 } |
|
1560
|
516 } |
|
|
517 else |
|
2966
|
518 colon_equiv = (len == n && (n == 0 || (n == 1 && data[0] == 0))); |
|
1560
|
519 |
|
|
520 colon_equiv_checked = 1; |
|
|
521 } |
|
|
522 |
|
|
523 return colon_equiv; |
|
209
|
524 } |
|
|
525 |
|
417
|
526 void |
|
3079
|
527 IDX_VEC_REP::sort (bool uniq) |
|
|
528 { |
|
3125
|
529 if (len > 1) |
|
|
530 { |
|
|
531 sort_data (data, len); |
|
3079
|
532 |
|
3125
|
533 if (uniq) |
|
|
534 len = make_uniq (data, len); |
|
|
535 } |
|
3079
|
536 } |
|
|
537 |
|
|
538 void |
|
5275
|
539 IDX_VEC_REP::shorten (octave_idx_type n) |
|
434
|
540 { |
|
|
541 if (n > 0 && n <= len) |
|
|
542 len = n; |
|
|
543 else |
|
1560
|
544 (*current_liboctave_error_handler) |
|
|
545 ("idx_vector::shorten: internal error!"); |
|
434
|
546 } |
|
|
547 |
|
3504
|
548 std::ostream& |
|
|
549 IDX_VEC_REP::print (std::ostream& os) const |
|
1560
|
550 { |
|
5275
|
551 for (octave_idx_type ii = 0; ii < len; ii++) |
|
1650
|
552 os << data[ii] << "\n"; |
|
1560
|
553 return os; |
|
|
554 } |
|
|
555 |
|
5275
|
556 octave_idx_type |
|
5781
|
557 IDX_VEC_REP::freeze (octave_idx_type z_len, const char *tag, bool resize_ok) |
|
1
|
558 { |
|
1560
|
559 if (frozen) |
|
3680
|
560 return frozen_len; |
|
1560
|
561 |
|
|
562 frozen_len = -1; |
|
|
563 |
|
|
564 if (colon) |
|
|
565 frozen_len = z_len; |
|
|
566 else |
|
|
567 { |
|
|
568 if (len == 0) |
|
|
569 frozen_len = 0; |
|
|
570 else |
|
|
571 { |
|
2828
|
572 maybe_convert_one_zero_to_idx (z_len); |
|
1560
|
573 |
|
1650
|
574 max_val = max (); |
|
|
575 min_val = min (); |
|
1560
|
576 |
|
|
577 if (min_val < 0) |
|
|
578 { |
|
|
579 if (tag) |
|
|
580 (*current_liboctave_error_handler) |
|
|
581 ("invalid %s index = %d", tag, min_val+1); |
|
|
582 else |
|
|
583 (*current_liboctave_error_handler) |
|
|
584 ("invalid index = %d", min_val+1); |
|
|
585 |
|
|
586 initialized = 0; |
|
|
587 } |
|
|
588 else if (! resize_ok && max_val >= z_len) |
|
|
589 { |
|
|
590 if (tag) |
|
|
591 (*current_liboctave_error_handler) |
|
|
592 ("invalid %s index = %d", tag, max_val+1); |
|
|
593 else |
|
|
594 (*current_liboctave_error_handler) |
|
|
595 ("invalid index = %d", max_val+1); |
|
|
596 |
|
|
597 initialized = 0; |
|
|
598 } |
|
|
599 else |
|
4461
|
600 { |
|
5781
|
601 if (max_val >= z_len) |
|
4461
|
602 { |
|
|
603 if (tag) |
|
5781
|
604 (*current_liboctave_warning_with_id_handler) |
|
|
605 ("Octave:resize-on-range-error", |
|
|
606 "resizing object with %s index = %d out of bounds", |
|
4461
|
607 tag, max_val+1); |
|
|
608 else |
|
5781
|
609 (*current_liboctave_warning_with_id_handler) |
|
|
610 ("Octave:resize-on-range-error", |
|
|
611 "resizing object with index = %d out of bounds", |
|
4461
|
612 max_val+1); |
|
|
613 } |
|
|
614 |
|
|
615 frozen_len = length (z_len); |
|
|
616 } |
|
1560
|
617 } |
|
|
618 } |
|
|
619 |
|
|
620 frozen = 1; |
|
3680
|
621 |
|
|
622 frozen_at_z_len = z_len ? z_len : len; |
|
1560
|
623 |
|
|
624 return frozen_len; |
|
1
|
625 } |
|
|
626 |
|
|
627 /* |
|
|
628 ;;; Local Variables: *** |
|
|
629 ;;; mode: C++ *** |
|
|
630 ;;; End: *** |
|
|
631 */ |
