Mercurial > hg > octave-lyh

comparison liboctave/idx-vector.cc @ 5275:23b37da9fd5b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2005-04-08 16:07:35 by jwe]
author jwe
date Fri, 08 Apr 2005 16:07:37 +0000
parents 10004c9625c3
children 4c8a2e4e0717
comparison
equal deleted inserted replaced
5274:eae7b40388e9 5275:23b37da9fd5b
47 frozen (a.frozen), colon_equiv_checked (a.colon_equiv_checked), 47 frozen (a.frozen), colon_equiv_checked (a.colon_equiv_checked),
48 colon_equiv (a.colon_equiv), orig_dims (a.orig_dims) 48 colon_equiv (a.colon_equiv), orig_dims (a.orig_dims)
49 { 49 {
50 if (len > 0) 50 if (len > 0)
51 { 51 {
52 data = new int [len]; 52 data = new octave_idx_type [len];
53 for (int i = 0; i < len; i++) 53 for (octave_idx_type i = 0; i < len; i++)
54 data[i] = a.data[i]; 54 data[i] = a.data[i];
55 } 55 }
56 } 56 }
57 57
58 int 58 octave_idx_type
59 IDX_VEC_REP::tree_to_mat_idx (double x, bool& conversion_error) 59 IDX_VEC_REP::tree_to_mat_idx (double x, bool& conversion_error)
60 { 60 {
61 int retval = -1; 61 octave_idx_type retval = -1;
62 62
63 conversion_error = false; 63 conversion_error = false;
64 64
65 if (D_NINT (x) != x) 65 if (D_NINT (x) != x)
66 { 66 {
68 ("expecting integer index, found %f", x); 68 ("expecting integer index, found %f", x);
69 69
70 conversion_error = true; 70 conversion_error = true;
71 } 71 }
72 else 72 else
73 retval = static_cast<int> (x - 1); 73 retval = static_cast<octave_idx_type> (x - 1);
74 74
75 return retval; 75 return retval;
76 } 76 }
77 77
78 static inline bool 78 static inline bool
105 initialized = 1; 105 initialized = 1;
106 return; 106 return;
107 } 107 }
108 else 108 else
109 { 109 {
110 data = new int [len]; 110 data = new octave_idx_type [len];
111 111
112 bool conversion_error = false; 112 bool conversion_error = false;
113 113
114 for (int i = 0; i < len; i++) 114 for (octave_idx_type i = 0; i < len; i++)
115 { 115 {
116 double d = v.elem (i); 116 double d = v.elem (i);
117 117
118 if (idx_is_inf_or_nan (d)) 118 if (idx_is_inf_or_nan (d))
119 return; 119 return;
140 initialized = 1; 140 initialized = 1;
141 return; 141 return;
142 } 142 }
143 else 143 else
144 { 144 {
145 int k = 0; 145 octave_idx_type k = 0;
146 data = new int [len]; 146 data = new octave_idx_type [len];
147 147
148 bool conversion_error = false; 148 bool conversion_error = false;
149 149
150 for (int i = 0; i < len; i++) 150 for (octave_idx_type i = 0; i < len; i++)
151 { 151 {
152 double d = nda.elem (i); 152 double d = nda.elem (i);
153 153
154 if (idx_is_inf_or_nan (d)) 154 if (idx_is_inf_or_nan (d))
155 return; 155 return;
183 } 183 }
184 184
185 double b = r.base (); 185 double b = r.base ();
186 double step = r.inc (); 186 double step = r.inc ();
187 187
188 data = new int [len]; 188 data = new octave_idx_type [len];
189 189
190 bool conversion_error = false; 190 bool conversion_error = false;
191 191
192 for (int i = 0; i < len; i++) 192 for (octave_idx_type i = 0; i < len; i++)
193 { 193 {
194 double val = b + i * step; 194 double val = b + i * step;
195 195
196 if (idx_is_inf_or_nan (val)) 196 if (idx_is_inf_or_nan (val))
197 return; 197 return;
214 { 214 {
215 if (idx_is_inf_or_nan (d)) 215 if (idx_is_inf_or_nan (d))
216 return; 216 return;
217 else 217 else
218 { 218 {
219 data = new int [len]; 219 data = new octave_idx_type [len];
220 220
221 bool conversion_error = false; 221 bool conversion_error = false;
222 222
223 data[0] = tree_to_mat_idx (d, conversion_error); 223 data[0] = tree_to_mat_idx (d, conversion_error);
224 224
227 } 227 }
228 228
229 init_state (); 229 init_state ();
230 } 230 }
231 231
232 IDX_VEC_REP::idx_vector_rep (int i) 232 IDX_VEC_REP::idx_vector_rep (octave_idx_type i)
233 : data (0), len (1), num_zeros (0), num_ones (0), 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), 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), 235 frozen_len (0), colon (0), one_zero (0), initialized (0),
236 frozen (0), colon_equiv_checked (0), colon_equiv (0), 236 frozen (0), colon_equiv_checked (0), colon_equiv (0),
237 orig_dims (1, 1) 237 orig_dims (1, 1)
238 { 238 {
239 data = new int [len]; 239 data = new octave_idx_type [len];
240 240
241 data[0] = tree_to_mat_idx (i); 241 data[0] = tree_to_mat_idx (i);
242 242
243 init_state (); 243 init_state ();
244 } 244 }
260 max_val (0), min_val (0), count (1), frozen_at_z_len (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), 261 frozen_len (0), colon (0), one_zero (1), initialized (0),
262 frozen (0), colon_equiv_checked (0), colon_equiv (0), 262 frozen (0), colon_equiv_checked (0), colon_equiv (0),
263 orig_dims (1, 1) 263 orig_dims (1, 1)
264 { 264 {
265 data = new int [len]; 265 data = new octave_idx_type [len];
266 266
267 data[0] = tree_to_mat_idx (b); 267 data[0] = tree_to_mat_idx (b);
268 268
269 init_state (); 269 init_state ();
270 } 270 }
281 initialized = 1; 281 initialized = 1;
282 return; 282 return;
283 } 283 }
284 else 284 else
285 { 285 {
286 int k = 0; 286 octave_idx_type k = 0;
287 data = new int [len]; 287 data = new octave_idx_type [len];
288 288
289 for (int i = 0; i < len; i++) 289 for (octave_idx_type i = 0; i < len; i++)
290 data[k++] = tree_to_mat_idx (bnda.elem (i)); 290 data[k++] = tree_to_mat_idx (bnda.elem (i));
291 } 291 }
292 292
293 init_state (); 293 init_state ();
294 } 294 }
298 { 298 {
299 if (this != &a) 299 if (this != &a)
300 { 300 {
301 delete [] data; 301 delete [] data;
302 len = a.len; 302 len = a.len;
303 data = new int [len]; 303 data = new octave_idx_type [len];
304 for (int i = 0; i < len; i++) 304 for (octave_idx_type i = 0; i < len; i++)
305 data[i] = a.data[i]; 305 data[i] = a.data[i];
306 306
307 num_zeros = a.num_zeros; 307 num_zeros = a.num_zeros;
308 num_ones = a.num_ones; 308 num_ones = a.num_ones;
309 max_val = a.max_val; 309 max_val = a.max_val;
335 } 335 }
336 else 336 else
337 { 337 {
338 min_val = max_val = data[0]; 338 min_val = max_val = data[0];
339 339
340 int i = 0; 340 octave_idx_type i = 0;
341 do 341 do
342 { 342 {
343 if (data[i] == -1) 343 if (data[i] == -1)
344 num_zeros++; 344 num_zeros++;
345 else if (data[i] == 0) 345 else if (data[i] == 0)
356 356
357 initialized = 1; 357 initialized = 1;
358 } 358 }
359 359
360 void 360 void
361 IDX_VEC_REP::maybe_convert_one_zero_to_idx (int z_len) 361 IDX_VEC_REP::maybe_convert_one_zero_to_idx (octave_idx_type z_len)
362 { 362 {
363 if (one_zero && (z_len == len || z_len == 0)) 363 if (one_zero && (z_len == len || z_len == 0))
364 { 364 {
365 if (num_ones == 0) 365 if (num_ones == 0)
366 { 366 {
372 } 372 }
373 else 373 else
374 { 374 {
375 assert (num_ones + num_zeros == len); 375 assert (num_ones + num_zeros == len);
376 376
377 int *new_data = new int [num_ones]; 377 octave_idx_type *new_data = new octave_idx_type [num_ones];
378 int k = 0; 378 octave_idx_type k = 0;
379 for (int i = 0; i < len; i++) 379 for (octave_idx_type i = 0; i < len; i++)
380 if (data[i] == 0) 380 if (data[i] == 0)
381 new_data[k++] = i; 381 new_data[k++] = i;
382 382
383 delete [] data; 383 delete [] data;
384 len = num_ones; 384 len = num_ones;
385 data = new_data; 385 data = new_data;
386 386
387 min_val = max_val = data[0]; 387 min_val = max_val = data[0];
388 388
389 int i = 0; 389 octave_idx_type i = 0;
390 do 390 do
391 { 391 {
392 if (data[i] > max_val) 392 if (data[i] > max_val)
393 max_val = data[i]; 393 max_val = data[i];
394 394
398 while (++i < len); 398 while (++i < len);
399 } 399 }
400 } 400 }
401 } 401 }
402 402
403 int 403 octave_idx_type
404 IDX_VEC_REP::checkelem (int n) const 404 IDX_VEC_REP::checkelem (octave_idx_type n) const
405 { 405 {
406 if (n < 0 || n >= len) 406 if (n < 0 || n >= len)
407 { 407 {
408 (*current_liboctave_error_handler) ("idx-vector: index out of range"); 408 (*current_liboctave_error_handler) ("idx-vector: index out of range");
409 return 0; 409 return 0;
413 } 413 }
414 414
415 static inline int 415 static inline int
416 intcmp (const void *ii, const void *jj) 416 intcmp (const void *ii, const void *jj)
417 { 417 {
418 return (*(static_cast<const int *> (ii)) - *(static_cast<const int *> (jj))); 418 return (*(static_cast<const octave_idx_type *> (ii)) - *(static_cast<const octave_idx_type *> (jj)));
419 } 419 }
420 420
421 static inline void 421 static inline void
422 sort_data (int *d, int l) 422 sort_data (octave_idx_type *d, octave_idx_type l)
423 { 423 {
424 qsort (d, l, sizeof (int), intcmp); 424 qsort (d, l, sizeof (octave_idx_type), intcmp);
425 } 425 }
426 426
427 static inline int 427 static inline octave_idx_type
428 make_uniq (int *d, int l) 428 make_uniq (octave_idx_type *d, octave_idx_type l)
429 { 429 {
430 if (l < 2) 430 if (l < 2)
431 return l; 431 return l;
432 432
433 int k = 0; 433 octave_idx_type k = 0;
434 for (int ii = 1; ii < l; ii++) 434 for (octave_idx_type ii = 1; ii < l; ii++)
435 { 435 {
436 if (d[ii] != d[k]) 436 if (d[ii] != d[k])
437 { 437 {
438 k++; 438 k++;
439 d[k] = d[ii]; 439 d[k] = d[ii];
440 } 440 }
441 } 441 }
442 return k+1; 442 return k+1;
443 } 443 }
444 444
445 static inline int * 445 static inline octave_idx_type *
446 copy_data (const int *d, int l) 446 copy_data (const octave_idx_type *d, octave_idx_type l)
447 { 447 {
448 int *new_data = new int [l]; 448 octave_idx_type *new_data = new octave_idx_type [l];
449 449
450 for (int ii = 0; ii < l; ii++) 450 for (octave_idx_type ii = 0; ii < l; ii++)
451 new_data[ii] = d[ii]; 451 new_data[ii] = d[ii];
452 452
453 return new_data; 453 return new_data;
454 } 454 }
455 455
456 int 456 int
457 IDX_VEC_REP::is_colon_equiv (int n, int sort_uniq) 457 IDX_VEC_REP::is_colon_equiv (octave_idx_type n, int sort_uniq)
458 { 458 {
459 if (! colon_equiv_checked) 459 if (! colon_equiv_checked)
460 { 460 {
461 if (colon) 461 if (colon)
462 { 462 {
463 colon_equiv = 1; 463 colon_equiv = 1;
464 } 464 }
465 else if (len > 1) 465 else if (static_cast<octave_idx_type> (len) > 1)
466 { 466 {
467 if (one_zero) 467 if (one_zero)
468 { 468 {
469 colon_equiv = (len == n && ones_count () == n); 469 colon_equiv = (len == n && ones_count () == n);
470 } 470 }
471 else if (sort_uniq) 471 else if (sort_uniq)
472 { 472 {
473 int *tmp_data = copy_data (data, len); 473 octave_idx_type *tmp_data = copy_data (data, len);
474 474
475 sort_data (tmp_data, len); 475 sort_data (tmp_data, len);
476 476
477 int tmp_len = make_uniq (tmp_data, len); 477 octave_idx_type tmp_len = make_uniq (tmp_data, len);
478 478
479 colon_equiv = (tmp_len == n 479 colon_equiv = (tmp_len == n
480 && tmp_data[0] == 0 480 && tmp_data[0] == 0
481 && tmp_data[tmp_len-1] == tmp_len - 1); 481 && tmp_data[tmp_len-1] == tmp_len - 1);
482 482
486 { 486 {
487 if (len == n) 487 if (len == n)
488 { 488 {
489 colon_equiv = 1; 489 colon_equiv = 1;
490 490
491 for (int ii = 0; ii < n; ii++) 491 for (octave_idx_type ii = 0; ii < n; ii++)
492 if (data[ii] != ii) 492 if (data[ii] != ii)
493 { 493 {
494 colon_equiv = 0; 494 colon_equiv = 0;
495 break; 495 break;
496 } 496 }
517 len = make_uniq (data, len); 517 len = make_uniq (data, len);
518 } 518 }
519 } 519 }
520 520
521 void 521 void
522 IDX_VEC_REP::shorten (int n) 522 IDX_VEC_REP::shorten (octave_idx_type n)
523 { 523 {
524 if (n > 0 && n <= len) 524 if (n > 0 && n <= len)
525 len = n; 525 len = n;
526 else 526 else
527 (*current_liboctave_error_handler) 527 (*current_liboctave_error_handler)
529 } 529 }
530 530
531 std::ostream& 531 std::ostream&
532 IDX_VEC_REP::print (std::ostream& os) const 532 IDX_VEC_REP::print (std::ostream& os) const
533 { 533 {
534 for (int ii = 0; ii < len; ii++) 534 for (octave_idx_type ii = 0; ii < len; ii++)
535 os << data[ii] << "\n"; 535 os << data[ii] << "\n";
536 return os; 536 return os;
537 } 537 }
538 538
539 int 539 octave_idx_type
540 IDX_VEC_REP::freeze (int z_len, const char *tag, bool resize_ok, 540 IDX_VEC_REP::freeze (octave_idx_type z_len, const char *tag, bool resize_ok,
541 bool warn_resize) 541 bool warn_resize)
542 { 542 {
543 if (frozen) 543 if (frozen)
544 return frozen_len; 544 return frozen_len;
545 545