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