Mercurial > octave

comparison src/ov-re-mat.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 ce07cb58ff61
comparison
equal deleted inserted replaced
11585:1473d0cf86d2 11586:12df7854fa7c
228 else if (warn && matrix.any_element_not_one_or_zero ()) 228 else if (warn && matrix.any_element_not_one_or_zero ())
229 gripe_logical_conversion (); 229 gripe_logical_conversion ();
230 230
231 return boolNDArray (matrix); 231 return boolNDArray (matrix);
232 } 232 }
233 233
234 charNDArray 234 charNDArray
235 octave_matrix::char_array_value (bool) const 235 octave_matrix::char_array_value (bool) const
236 { 236 {
237 charNDArray retval (dims ()); 237 charNDArray retval (dims ());
238 238
239 octave_idx_type nel = numel (); 239 octave_idx_type nel = numel ();
240 240
241 for (octave_idx_type i = 0; i < nel; i++) 241 for (octave_idx_type i = 0; i < nel; i++)
242 retval.elem (i) = static_cast<char>(matrix.elem (i)); 242 retval.elem (i) = static_cast<char>(matrix.elem (i));
243 243
244 return retval; 244 return retval;
245 } 245 }
246 246
247 SparseMatrix 247 SparseMatrix
248 octave_matrix::sparse_matrix_value (bool) const 248 octave_matrix::sparse_matrix_value (bool) const
249 { 249 {
250 return SparseMatrix (matrix.matrix_value ()); 250 return SparseMatrix (matrix.matrix_value ());
251 } 251 }
252 252
253 SparseComplexMatrix 253 SparseComplexMatrix
254 octave_matrix::sparse_complex_matrix_value (bool) const 254 octave_matrix::sparse_complex_matrix_value (bool) const
255 { 255 {
256 // FIXME Need a SparseComplexMatrix (Matrix) constructor to make 256 // FIXME Need a SparseComplexMatrix (Matrix) constructor to make
257 // this function more efficient. Then this should become 257 // this function more efficient. Then this should become
258 // return SparseComplexMatrix (matrix.matrix_value ()); 258 // return SparseComplexMatrix (matrix.matrix_value ());
261 261
262 octave_value 262 octave_value
263 octave_matrix::diag (octave_idx_type k) const 263 octave_matrix::diag (octave_idx_type k) const
264 { 264 {
265 octave_value retval; 265 octave_value retval;
266 if (k == 0 && matrix.ndims () == 2 266 if (k == 0 && matrix.ndims () == 2
267 && (matrix.rows () == 1 || matrix.columns () == 1)) 267 && (matrix.rows () == 1 || matrix.columns () == 1))
268 retval = DiagMatrix (DiagArray2<double> (matrix)); 268 retval = DiagMatrix (DiagArray2<double> (matrix));
269 else 269 else
270 retval = octave_base_matrix<NDArray>::diag (k); 270 retval = octave_base_matrix<NDArray>::diag (k);
271 271
272 return retval; 272 return retval;
273 } 273 }
274 274
275 // We override these two functions to allow reshaping both 275 // We override these two functions to allow reshaping both
276 // the matrix and the index cache. 276 // the matrix and the index cache.
277 octave_value 277 octave_value
278 octave_matrix::reshape (const dim_vector& new_dims) const 278 octave_matrix::reshape (const dim_vector& new_dims) const
279 { 279 {
280 if (idx_cache) 280 if (idx_cache)
281 { 281 {
282 return new octave_matrix (matrix.reshape (new_dims), 282 return new octave_matrix (matrix.reshape (new_dims),
285 } 285 }
286 else 286 else
287 return octave_base_matrix<NDArray>::reshape (new_dims); 287 return octave_base_matrix<NDArray>::reshape (new_dims);
288 } 288 }
289 289
290 octave_value 290 octave_value
291 octave_matrix::squeeze (void) const 291 octave_matrix::squeeze (void) const
292 { 292 {
293 if (idx_cache) 293 if (idx_cache)
294 { 294 {
295 return new octave_matrix (matrix.squeeze (), 295 return new octave_matrix (matrix.squeeze (),
298 } 298 }
299 else 299 else
300 return octave_base_matrix<NDArray>::squeeze (); 300 return octave_base_matrix<NDArray>::squeeze ();
301 } 301 }
302 302
303 octave_value 303 octave_value
304 octave_matrix::sort (octave_idx_type dim, sortmode mode) const 304 octave_matrix::sort (octave_idx_type dim, sortmode mode) const
305 { 305 {
306 if (idx_cache) 306 if (idx_cache)
307 { 307 {
308 // This is a valid index matrix, so sort via integers because it's 308 // This is a valid index matrix, so sort via integers because it's
311 } 311 }
312 else 312 else
313 return octave_base_matrix<NDArray>::sort (dim, mode); 313 return octave_base_matrix<NDArray>::sort (dim, mode);
314 } 314 }
315 315
316 octave_value 316 octave_value
317 octave_matrix::sort (Array<octave_idx_type> &sidx, octave_idx_type dim, 317 octave_matrix::sort (Array<octave_idx_type> &sidx, octave_idx_type dim,
318 sortmode mode) const 318 sortmode mode) const
319 { 319 {
320 if (idx_cache) 320 if (idx_cache)
321 { 321 {
325 } 325 }
326 else 326 else
327 return octave_base_matrix<NDArray>::sort (sidx, dim, mode); 327 return octave_base_matrix<NDArray>::sort (sidx, dim, mode);
328 } 328 }
329 329
330 sortmode 330 sortmode
331 octave_matrix::is_sorted (sortmode mode) const 331 octave_matrix::is_sorted (sortmode mode) const
332 { 332 {
333 if (idx_cache) 333 if (idx_cache)
334 { 334 {
335 // This is a valid index matrix, so check via integers because it's 335 // This is a valid index matrix, so check via integers because it's
337 return idx_cache->as_array ().is_sorted (mode); 337 return idx_cache->as_array ().is_sorted (mode);
338 } 338 }
339 else 339 else
340 return octave_base_matrix<NDArray>::is_sorted (mode); 340 return octave_base_matrix<NDArray>::is_sorted (mode);
341 } 341 }
342 Array<octave_idx_type> 342 Array<octave_idx_type>
343 octave_matrix::sort_rows_idx (sortmode mode) const 343 octave_matrix::sort_rows_idx (sortmode mode) const
344 { 344 {
345 if (idx_cache) 345 if (idx_cache)
346 { 346 {
347 // This is a valid index matrix, so sort via integers because it's 347 // This is a valid index matrix, so sort via integers because it's
350 } 350 }
351 else 351 else
352 return octave_base_matrix<NDArray>::sort_rows_idx (mode); 352 return octave_base_matrix<NDArray>::sort_rows_idx (mode);
353 } 353 }
354 354
355 sortmode 355 sortmode
356 octave_matrix::is_sorted_rows (sortmode mode) const 356 octave_matrix::is_sorted_rows (sortmode mode) const
357 { 357 {
358 if (idx_cache) 358 if (idx_cache)
359 { 359 {
360 // This is a valid index matrix, so check via integers because it's 360 // This is a valid index matrix, so check via integers because it's
412 retval = octave_value (chm, type); 412 retval = octave_value (chm, type);
413 413
414 return retval; 414 return retval;
415 } 415 }
416 416
417 bool 417 bool
418 octave_matrix::save_ascii (std::ostream& os) 418 octave_matrix::save_ascii (std::ostream& os)
419 { 419 {
420 dim_vector d = dims (); 420 dim_vector d = dims ();
421 421
422 if (d.length () > 2) 422 if (d.length () > 2)
430 430
431 os << "\n" << tmp; 431 os << "\n" << tmp;
432 } 432 }
433 else 433 else
434 { 434 {
435 // Keep this case, rather than use generic code above for backward 435 // Keep this case, rather than use generic code above for backward
436 // compatiability. Makes load_ascii much more complex!! 436 // compatiability. Makes load_ascii much more complex!!
437 os << "# rows: " << rows () << "\n" 437 os << "# rows: " << rows () << "\n"
438 << "# columns: " << columns () << "\n"; 438 << "# columns: " << columns () << "\n";
439 439
440 os << matrix_value (); 440 os << matrix_value ();
441 } 441 }
442 442
443 return true; 443 return true;
444 } 444 }
445 445
446 bool 446 bool
447 octave_matrix::load_ascii (std::istream& is) 447 octave_matrix::load_ascii (std::istream& is)
448 { 448 {
449 bool success = true; 449 bool success = true;
450 450
451 string_vector keywords(2); 451 string_vector keywords(2);
518 else if (nr == 0 || nc == 0) 518 else if (nr == 0 || nc == 0)
519 matrix = Matrix (nr, nc); 519 matrix = Matrix (nr, nc);
520 else 520 else
521 panic_impossible (); 521 panic_impossible ();
522 } 522 }
523 else 523 else
524 { 524 {
525 error ("load: failed to extract number of rows and columns"); 525 error ("load: failed to extract number of rows and columns");
526 success = false; 526 success = false;
527 } 527 }
528 } 528 }
536 } 536 }
537 537
538 return success; 538 return success;
539 } 539 }
540 540
541 bool 541 bool
542 octave_matrix::save_binary (std::ostream& os, bool& save_as_floats) 542 octave_matrix::save_binary (std::ostream& os, bool& save_as_floats)
543 { 543 {
544 544
545 dim_vector d = dims (); 545 dim_vector d = dims ();
546 if (d.length() < 1) 546 if (d.length() < 1)
578 write_doubles (os, mtmp, st, d.numel ()); 578 write_doubles (os, mtmp, st, d.numel ());
579 579
580 return true; 580 return true;
581 } 581 }
582 582
583 bool 583 bool
584 octave_matrix::load_binary (std::istream& is, bool swap, 584 octave_matrix::load_binary (std::istream& is, bool swap,
585 oct_mach_info::float_format fmt) 585 oct_mach_info::float_format fmt)
586 { 586 {
587 char tmp; 587 char tmp;
588 int32_t mdims; 588 int32_t mdims;
667 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); 667 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);
668 668
669 // Octave uses column-major, while HDF5 uses row-major ordering 669 // Octave uses column-major, while HDF5 uses row-major ordering
670 for (int i = 0; i < rank; i++) 670 for (int i = 0; i < rank; i++)
671 hdims[i] = dv (rank-i-1); 671 hdims[i] = dv (rank-i-1);
672 672
673 space_hid = H5Screate_simple (rank, hdims, 0); 673 space_hid = H5Screate_simple (rank, hdims, 0);
674 674
675 if (space_hid < 0) return false; 675 if (space_hid < 0) return false;
676 676
677 hid_t save_type_hid = H5T_NATIVE_DOUBLE; 677 hid_t save_type_hid = H5T_NATIVE_DOUBLE;
695 if (m.all_integers (max_val, min_val)) 695 if (m.all_integers (max_val, min_val))
696 save_type_hid 696 save_type_hid
697 = save_type_to_hdf5 (get_save_type (max_val, min_val)); 697 = save_type_to_hdf5 (get_save_type (max_val, min_val));
698 } 698 }
699 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */ 699 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */
700 700
701 #if HAVE_HDF5_18 701 #if HAVE_HDF5_18
702 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid, 702 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
703 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); 703 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
704 #else 704 #else
705 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid, 705 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
706 H5P_DEFAULT); 706 H5P_DEFAULT);
707 #endif 707 #endif
708 if (data_hid < 0) 708 if (data_hid < 0)
709 { 709 {
710 H5Sclose (space_hid); 710 H5Sclose (space_hid);
739 hid_t data_hid = H5Dopen (loc_id, name); 739 hid_t data_hid = H5Dopen (loc_id, name);
740 #endif 740 #endif
741 hid_t space_id = H5Dget_space (data_hid); 741 hid_t space_id = H5Dget_space (data_hid);
742 742
743 hsize_t rank = H5Sget_simple_extent_ndims (space_id); 743 hsize_t rank = H5Sget_simple_extent_ndims (space_id);
744 744
745 if (rank < 1) 745 if (rank < 1)
746 { 746 {
747 H5Sclose (space_id); 747 H5Sclose (space_id);
748 H5Dclose (data_hid); 748 H5Dclose (data_hid);
749 return false; 749 return false;
768 dv(j) = hdims[i]; 768 dv(j) = hdims[i];
769 } 769 }
770 770
771 NDArray m (dv); 771 NDArray m (dv);
772 double *re = m.fortran_vec (); 772 double *re = m.fortran_vec ();
773 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, 773 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
774 H5P_DEFAULT, re) >= 0) 774 H5P_DEFAULT, re) >= 0)
775 { 775 {
776 retval = true; 776 retval = true;
777 matrix = m; 777 matrix = m;
778 } 778 }
779 779