Mercurial > octave-nkf

comparison src/ov-range.cc @ 11586:12df7854fa7c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
strip trailing whitespace from source files
author John W. Eaton <jwe@octave.org>
date Thu, 20 Jan 2011 17:24:59 -0500
parents fd0a3ac60b0e
children 8f9702abe3e3
comparison
equal deleted inserted replaced
11585:1473d0cf86d2 11586:12df7854fa7c
211 { 211 {
212 const Matrix matrix = range.matrix_value (); 212 const Matrix matrix = range.matrix_value ();
213 charNDArray retval (dims ()); 213 charNDArray retval (dims ());
214 214
215 octave_idx_type nel = numel (); 215 octave_idx_type nel = numel ();
216 216
217 for (octave_idx_type i = 0; i < nel; i++) 217 for (octave_idx_type i = 0; i < nel; i++)
218 retval.elem (i) = static_cast<char>(matrix.elem (i)); 218 retval.elem (i) = static_cast<char>(matrix.elem (i));
219 219
220 return retval; 220 return retval;
221 } 221 }
222 222
223 octave_value 223 octave_value
224 octave_range::all (int dim) const 224 octave_range::all (int dim) const
225 { 225 {
226 // FIXME -- this is a potential waste of memory. 226 // FIXME -- this is a potential waste of memory.
227 227
238 Matrix m = range.matrix_value (); 238 Matrix m = range.matrix_value ();
239 239
240 return m.any (dim); 240 return m.any (dim);
241 } 241 }
242 242
243 octave_value 243 octave_value
244 octave_range::diag (octave_idx_type k) const 244 octave_range::diag (octave_idx_type k) const
245 { 245 {
246 return (k == 0 246 return (k == 0
247 ? octave_value (DiagMatrix (DiagArray2<double> (range.matrix_value ()))) 247 ? octave_value (DiagMatrix (DiagArray2<double> (range.matrix_value ())))
248 : octave_value (range.diag (k))); 248 : octave_value (range.diag (k)));
249 } 249 }
250 250
251 251
252 bool 252 bool
253 octave_range::is_true (void) const 253 octave_range::is_true (void) const
321 gripe_logical_conversion (); 321 gripe_logical_conversion ();
322 322
323 return boolNDArray (m); 323 return boolNDArray (m);
324 } 324 }
325 325
326 octave_value 326 octave_value
327 octave_range::resize (const dim_vector& dv, bool fill) const 327 octave_range::resize (const dim_vector& dv, bool fill) const
328 { 328 {
329 NDArray retval = array_value (); 329 NDArray retval = array_value ();
330 if (fill) 330 if (fill)
331 retval.resize (dv, NDArray::resize_fill_value ()); 331 retval.resize (dv, NDArray::resize_fill_value ());
332 else 332 else
333 retval.resize (dv); 333 retval.resize (dv);
334 return retval; 334 return retval;
335 } 335 }
336 336
337 octave_value 337 octave_value
338 octave_range::convert_to_str_internal (bool pad, bool force, char type) const 338 octave_range::convert_to_str_internal (bool pad, bool force, char type) const
339 { 339 {
371 os << name << " ="; 371 os << name << " =";
372 newline (os); 372 newline (os);
373 newline (os); 373 newline (os);
374 retval = true; 374 retval = true;
375 } 375 }
376 376
377 return retval; 377 return retval;
378 } 378 }
379 379
380 // Skip white space and comments on stream IS. 380 // Skip white space and comments on stream IS.
381 381
392 } 392 }
393 393
394 skip_until_newline (is, false); 394 skip_until_newline (is, false);
395 } 395 }
396 396
397 bool 397 bool
398 octave_range::save_ascii (std::ostream& os) 398 octave_range::save_ascii (std::ostream& os)
399 { 399 {
400 Range r = range_value (); 400 Range r = range_value ();
401 double base = r.base (); 401 double base = r.base ();
402 double limit = r.limit (); 402 double limit = r.limit ();
419 os << "\n"; 419 os << "\n";
420 420
421 return true; 421 return true;
422 } 422 }
423 423
424 bool 424 bool
425 octave_range::load_ascii (std::istream& is) 425 octave_range::load_ascii (std::istream& is)
426 { 426 {
427 // # base, limit, range comment added by save (). 427 // # base, limit, range comment added by save ().
428 skip_comments (is); 428 skip_comments (is);
429 429
442 range = Range (base, inc, static_cast<octave_idx_type> (limit)); 442 range = Range (base, inc, static_cast<octave_idx_type> (limit));
443 443
444 return true; 444 return true;
445 } 445 }
446 446
447 bool 447 bool
448 octave_range::save_binary (std::ostream& os, bool& /* save_as_floats */) 448 octave_range::save_binary (std::ostream& os, bool& /* save_as_floats */)
449 { 449 {
450 char tmp = LS_DOUBLE; 450 char tmp = LS_DOUBLE;
451 os.write (reinterpret_cast<char *> (&tmp), 1); 451 os.write (reinterpret_cast<char *> (&tmp), 1);
452 Range r = range_value (); 452 Range r = range_value ();
461 os.write (reinterpret_cast<char *> (&inc), 8); 461 os.write (reinterpret_cast<char *> (&inc), 8);
462 462
463 return true; 463 return true;
464 } 464 }
465 465
466 bool 466 bool
467 octave_range::load_binary (std::istream& is, bool swap, 467 octave_range::load_binary (std::istream& is, bool swap,
468 oct_mach_info::float_format /* fmt */) 468 oct_mach_info::float_format /* fmt */)
469 { 469 {
470 char tmp; 470 char tmp;
471 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) 471 if (! is.read (reinterpret_cast<char *> (&tmp), 1))
492 } 492 }
493 493
494 #if defined (HAVE_HDF5) 494 #if defined (HAVE_HDF5)
495 495
496 // The following subroutines creates an HDF5 representation of the way 496 // The following subroutines creates an HDF5 representation of the way
497 // we will store Octave range types (triplets of floating-point numbers). 497 // we will store Octave range types (triplets of floating-point numbers).
498 // NUM_TYPE is the HDF5 numeric type to use for storage (e.g. 498 // NUM_TYPE is the HDF5 numeric type to use for storage (e.g.
499 // H5T_NATIVE_DOUBLE to save as 'double'). Note that any necessary 499 // H5T_NATIVE_DOUBLE to save as 'double'). Note that any necessary
500 // conversions are handled automatically by HDF5. 500 // conversions are handled automatically by HDF5.
501 501
502 static hid_t 502 static hid_t
503 hdf5_make_range_type (hid_t num_type) 503 hdf5_make_range_type (hid_t num_type)
504 { 504 {
521 521
522 space_hid = H5Screate_simple (0, dimens, 0); 522 space_hid = H5Screate_simple (0, dimens, 0);
523 if (space_hid < 0) return false; 523 if (space_hid < 0) return false;
524 524
525 type_hid = hdf5_make_range_type (H5T_NATIVE_DOUBLE); 525 type_hid = hdf5_make_range_type (H5T_NATIVE_DOUBLE);
526 if (type_hid < 0) 526 if (type_hid < 0)
527 { 527 {
528 H5Sclose (space_hid); 528 H5Sclose (space_hid);
529 return false; 529 return false;
530 } 530 }
531 #if HAVE_HDF5_18 531 #if HAVE_HDF5_18
532 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, 532 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid,
533 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); 533 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
534 #else 534 #else
535 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, H5P_DEFAULT); 535 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, H5P_DEFAULT);
536 #endif 536 #endif
537 if (data_hid < 0) 537 if (data_hid < 0)
538 { 538 {
539 H5Sclose (space_hid); 539 H5Sclose (space_hid);
540 H5Tclose (type_hid); 540 H5Tclose (type_hid);
541 return false; 541 return false;
542 } 542 }
543 543
544 Range r = range_value (); 544 Range r = range_value ();
545 double range_vals[3]; 545 double range_vals[3];
546 range_vals[0] = r.base (); 546 range_vals[0] = r.base ();
547 range_vals[1] = r.inc () != 0 ? r.limit () : r.nelem (); 547 range_vals[1] = r.inc () != 0 ? r.limit () : r.nelem ();
548 range_vals[2] = r.inc (); 548 range_vals[2] = r.inc ();
562 H5Sclose (space_hid); 562 H5Sclose (space_hid);
563 563
564 return retval; 564 return retval;
565 } 565 }
566 566
567 bool 567 bool
568 octave_range::load_hdf5 (hid_t loc_id, const char *name) 568 octave_range::load_hdf5 (hid_t loc_id, const char *name)
569 { 569 {
570 bool retval = false; 570 bool retval = false;
571 571
572 #if HAVE_HDF5_18 572 #if HAVE_HDF5_18
595 H5Dclose (data_hid); 595 H5Dclose (data_hid);
596 return false; 596 return false;
597 } 597 }
598 598
599 double rangevals[3]; 599 double rangevals[3];
600 if (H5Dread (data_hid, range_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, 600 if (H5Dread (data_hid, range_type, H5S_ALL, H5S_ALL, H5P_DEFAULT,
601 rangevals) >= 0) 601 rangevals) >= 0)
602 { 602 {
603 retval = true; 603 retval = true;
604 octave_idx_type nel; 604 octave_idx_type nel;
605 if (hdf5_get_scalar_attr (data_hid, H5T_NATIVE_IDX, 605 if (hdf5_get_scalar_attr (data_hid, H5T_NATIVE_IDX,
606 "OCTAVE_RANGE_NELEM", &nel)) 606 "OCTAVE_RANGE_NELEM", &nel))
607 range = Range (rangevals[0], rangevals[2], nel); 607 range = Range (rangevals[0], rangevals[2], nel);
608 else 608 else
609 { 609 {
610 if (rangevals[2] != 0) 610 if (rangevals[2] != 0)
611 range = Range (rangevals[0], rangevals[1], rangevals[2]); 611 range = Range (rangevals[0], rangevals[1], rangevals[2]);
612 else 612 else
613 range = Range (rangevals[0], rangevals[2], 613 range = Range (rangevals[0], rangevals[2],
614 static_cast<octave_idx_type> (rangevals[1])); 614 static_cast<octave_idx_type> (rangevals[1]));
615 } 615 }
616 } 616 }
617 617
618 H5Tclose (range_type); 618 H5Tclose (range_type);