Mercurial > octave-nkf

comparison src/ov-base-int.cc @ 4917:f69e95587ba3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2004-07-27 14:03:03 by jwe]
author jwe
date Tue, 27 Jul 2004 14:03:03 +0000
parents bfe64e459ce3
children 43f4ebd2704c
comparison
equal deleted inserted replaced
4916:c45f14873b5e 4917:f69e95587ba3
70 return retval; 70 return retval;
71 } 71 }
72 72
73 template <class T> 73 template <class T>
74 bool 74 bool
75 octave_base_int_matrix<T>::save_ascii (std::ostream& os, bool& infnan_warned, 75 octave_base_int_matrix<T>::save_ascii (std::ostream& os, bool&, bool)
76 bool /* strip_nan_and_inf */) 76 {
77 {
78 infnan_warned = false;
79
80 dim_vector d = dims (); 77 dim_vector d = dims ();
81 78
82 os << "# ndims: " << d.length () << "\n"; 79 os << "# ndims: " << d.length () << "\n";
83 80
84 for (int i = 0; i < d.length (); i++) 81 for (int i = 0; i < d.length (); i++)
130 return success; 127 return success;
131 } 128 }
132 129
133 template <class T> 130 template <class T>
134 bool 131 bool
135 octave_base_int_matrix<T>::save_binary (std::ostream& os, bool& save_as_floats) 132 octave_base_int_matrix<T>::save_binary (std::ostream& os, bool&)
136 { 133 {
137 #if 0
138
139 dim_vector d = dims (); 134 dim_vector d = dims ();
140 if (d.length() < 1) 135 if (d.length() < 1)
141 return false; 136 return false;
142 137
143 // Use negative value for ndims to differentiate with old format!! 138 // Use negative value for ndims to differentiate with old format!!
147 { 142 {
148 tmp = d(i); 143 tmp = d(i);
149 os.write (X_CAST (char *, &tmp), 4); 144 os.write (X_CAST (char *, &tmp), 4);
150 } 145 }
151 146
152 NDArray m = array_value (); 147 os.write (X_CAST(char *, matrix.data()), byte_size());
153 save_type st = LS_DOUBLE;
154 if (save_as_floats)
155 {
156 if (m.too_large_for_float ())
157 {
158 warning ("save: some values too large to save as floats --");
159 warning ("save: saving as doubles instead");
160 }
161 else
162 st = LS_FLOAT;
163 }
164 else if (d.numel () > 8192) // XXX FIXME XXX -- make this configurable.
165 {
166 double max_val, min_val;
167 if (m.all_integers (max_val, min_val))
168 st = get_save_type (max_val, min_val);
169 }
170
171 const double *mtmp = m.data ();
172 write_doubles (os, mtmp, st, d.numel ());
173
174 #endif
175 148
176 return true; 149 return true;
177 } 150 }
178 151
179 template <class T> 152 template <class T>
180 bool 153 bool
181 octave_base_int_matrix<T>::load_binary (std::istream& is, bool swap, 154 octave_base_int_matrix<T>::load_binary (std::istream& is, bool swap,
182 oct_mach_info::float_format fmt) 155 oct_mach_info::float_format )
183 { 156 {
184 #if 0
185
186 char tmp;
187 FOUR_BYTE_INT mdims; 157 FOUR_BYTE_INT mdims;
188 if (! is.read (X_CAST (char *, &mdims), 4)) 158 if (! is.read (X_CAST (char *, &mdims), 4))
189 return false; 159 return false;
190 if (swap) 160 if (swap)
191 swap_4_bytes (X_CAST (char *, &mdims)); 161 swap_4_bytes (X_CAST (char *, &mdims));
192 if (mdims < 0) 162 if (mdims >= 0)
193 { 163 return false;
194 mdims = - mdims; 164
195 FOUR_BYTE_INT di; 165 mdims = - mdims;
196 dim_vector dv; 166 FOUR_BYTE_INT di;
197 dv.resize (mdims); 167 dim_vector dv;
198 168 dv.resize (mdims);
199 for (int i = 0; i < mdims; i++) 169
200 { 170 for (int i = 0; i < mdims; i++)
201 if (! is.read (X_CAST (char *, &di), 4)) 171 {
202 return false; 172 if (! is.read (X_CAST (char *, &di), 4))
203 if (swap)
204 swap_4_bytes (X_CAST (char *, &di));
205 dv(i) = di;
206 }
207
208 if (! is.read (X_CAST (char *, &tmp), 1))
209 return false;
210
211 NDArray m(dv);
212 double *re = m.fortran_vec ();
213 read_doubles (is, re, X_CAST (save_type, tmp), dv.numel (), swap, fmt);
214 if (error_state || ! is)
215 return false;
216 matrix = m;
217 }
218 else
219 {
220 FOUR_BYTE_INT nr, nc;
221 nr = mdims;
222 if (! is.read (X_CAST (char *, &nc), 4))
223 return false; 173 return false;
224 if (swap) 174 if (swap)
225 swap_4_bytes (X_CAST (char *, &nc)); 175 swap_4_bytes (X_CAST (char *, &di));
226 if (! is.read (X_CAST (char *, &tmp), 1)) 176 dv(i) = di;
227 return false; 177 }
228 Matrix m (nr, nc); 178
229 double *re = m.fortran_vec (); 179 T m (dv);
230 int len = nr * nc; 180
231 read_doubles (is, re, X_CAST (save_type, tmp), len, swap, fmt); 181 if (! is.read (X_CAST (char *, m.data ()), m.byte_size ()))
232 if (error_state || ! is) 182 return false;
233 return false; 183
234 matrix = m; 184 if (swap)
235 } 185 {
236 186 int nel = dv.numel ();
237 #endif 187 int bytes = nel / m.byte_size();
238 188 for (int i = 0; i < nel; i++)
189 switch (bytes)
190 {
191 case 8:
192 swap_8_bytes (X_CAST (char *, &m(i)));
193 break;
194 case 4:
195 swap_4_bytes (X_CAST (char *, &m(i)));
196 break;
197 case 2:
198 swap_2_bytes (X_CAST (char *, &m(i)));
199 break;
200 case 1:
201 default:
202 break;
203 }
204 }
205
206 matrix = m;
239 return true; 207 return true;
240 } 208 }
241 209
242 #if defined (HAVE_HDF5) 210 #if defined (HAVE_HDF5)
243 211
244 template <class T> 212 template <class T>
245 bool 213 bool
246 octave_base_int_matrix<T>::save_hdf5 (hid_t loc_id, const char *name, 214 octave_base_int_matrix<T>::save_hdf5 (hid_t loc_id, const char *name, bool)
247 bool save_as_floats) 215 {
248 { 216 hid_t save_type_hid = HDF5_SAVE_TYPE;
249 bool retval = true; 217 bool retval = true;
250
251 #if 0
252
253 dim_vector dv = dims (); 218 dim_vector dv = dims ();
254 int empty = save_hdf5_empty (loc_id, name, dv); 219 int empty = save_hdf5_empty (loc_id, name, dv);
255 if (empty) 220 if (empty)
256 return (empty > 0); 221 return (empty > 0);
257 222
258 int rank = dv.length (); 223 int rank = dv.length ();
259 hid_t space_hid = -1, data_hid = -1; 224 hid_t space_hid = -1, data_hid = -1;
260 NDArray m = array_value ();
261
262 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); 225 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);
263 226
264 // Octave uses column-major, while HDF5 uses row-major ordering 227 // Octave uses column-major, while HDF5 uses row-major ordering
265 for (int i = 0; i < rank; i++) 228 for (int i = 0; i < rank; i++)
266 hdims[i] = dv (rank-i-1); 229 hdims[i] = dv (rank-i-1);
267 230
268 space_hid = H5Screate_simple (rank, hdims, 0); 231 space_hid = H5Screate_simple (rank, hdims, 0);
269 232
270 if (space_hid < 0) return false; 233 if (space_hid < 0) return false;
271 234
272 hid_t save_type_hid = H5T_NATIVE_DOUBLE;
273
274 if (save_as_floats)
275 {
276 if (m.too_large_for_float ())
277 {
278 warning ("save: some values too large to save as floats --");
279 warning ("save: saving as doubles instead");
280 }
281 else
282 save_type_hid = H5T_NATIVE_FLOAT;
283 }
284 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS
285 // hdf5 currently doesn't support float/integer conversions
286 else
287 {
288 double max_val, min_val;
289
290 if (m.all_integers (max_val, min_val))
291 save_type_hid
292 = save_type_to_hdf5 (get_save_type (max_val, min_val));
293 }
294 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */
295
296 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid, 235 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
297 H5P_DEFAULT); 236 H5P_DEFAULT);
298 if (data_hid < 0) 237 if (data_hid < 0)
299 { 238 {
300 H5Sclose (space_hid); 239 H5Sclose (space_hid);
301 return false; 240 return false;
302 } 241 }
303 242
304 double *mtmp = m.fortran_vec (); 243 retval = H5Dwrite (data_hid, save_type_hid, H5S_ALL, H5S_ALL,
305 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, 244 H5P_DEFAULT, matrix.data()) >= 0;
306 H5P_DEFAULT, mtmp) >= 0;
307 245
308 H5Dclose (data_hid); 246 H5Dclose (data_hid);
309 H5Sclose (space_hid); 247 H5Sclose (space_hid);
310 248
311 #endif
312
313 return retval; 249 return retval;
314 } 250 }
315 251
316 template <class T> 252 template <class T>
317 bool 253 bool
318 octave_base_int_matrix<T>::load_hdf5 (hid_t loc_id, const char *name, 254 octave_base_int_matrix<T>::load_hdf5 (hid_t loc_id, const char *name,
319 bool /* have_h5giterate_bug */) 255 bool /* have_h5giterate_bug */)
320 { 256 {
257 hid_t save_type_hid = HDF5_SAVE_TYPE;
321 bool retval = false; 258 bool retval = false;
322
323 #if 0
324
325 dim_vector dv; 259 dim_vector dv;
326 int empty = load_hdf5_empty (loc_id, name, dv); 260 int empty = load_hdf5_empty (loc_id, name, dv);
327 if (empty > 0) 261 if (empty > 0)
328 matrix.resize(dv); 262 matrix.resize(dv);
329 if (empty) 263 if (empty)
358 dv.resize (rank); 292 dv.resize (rank);
359 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--) 293 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--)
360 dv(j) = hdims[i]; 294 dv(j) = hdims[i];
361 } 295 }
362 296
363 NDArray m (dv); 297 T m (dv);
364 double *re = m.fortran_vec (); 298 if (H5Dread (data_hid, save_type_hid, H5S_ALL, H5S_ALL,
365 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, 299 H5P_DEFAULT, m.fortran_vec()) >= 0)
366 H5P_DEFAULT, re) >= 0)
367 { 300 {
368 retval = true; 301 retval = true;
369 matrix = m; 302 matrix = m;
370 } 303 }
371 304
372 H5Sclose (space_id); 305 H5Sclose (space_id);
373 H5Dclose (data_hid); 306 H5Dclose (data_hid);
374
375 #endif
376 307
377 return retval; 308 return retval;
378 } 309 }
379 310
380 #endif 311 #endif
388 current_print_indent_level ()); 319 current_print_indent_level ());
389 } 320 }
390 321
391 template <class T> 322 template <class T>
392 bool 323 bool
393 octave_base_int_scalar<T>::save_ascii (std::ostream& os, bool& infnan_warned, 324 octave_base_int_scalar<T>::save_ascii (std::ostream& os, bool& , bool)
394 bool strip_nan_and_inf) 325 {
395 { 326 os << scalar << "\n";
396 #if 0
397
398 double d = double_value ();
399
400 if (strip_nan_and_inf)
401 {
402 if (xisnan (d))
403 {
404 error ("only value to plot is NaN");
405 return false;
406 }
407 else
408 {
409 d = xisinf (d) ? (d > 0 ? OCT_RBV : -OCT_RBV) : d;
410 octave_write_double (os, d);
411 os << "\n";
412 }
413 }
414 else
415 {
416 if (! infnan_warned && (xisnan (d) || xisinf (d)))
417 {
418 warning ("save: Inf or NaN values may not be reloadable");
419 infnan_warned = true;
420 }
421
422 octave_write_double (os, d);
423 os << "\n";
424 }
425
426 #endif
427
428 return true; 327 return true;
429 } 328 }
430 329
431 template <class T> 330 template <class T>
432 bool 331 bool
433 octave_base_int_scalar<T>::load_ascii (std::istream& is) 332 octave_base_int_scalar<T>::load_ascii (std::istream& is)
434 { 333 {
435 #if 0 334 is >> scalar;
436
437 scalar = octave_read_double (is);
438 if (!is) 335 if (!is)
439 { 336 {
440 error ("load: failed to load scalar constant"); 337 error ("load: failed to load scalar constant");
441 return false; 338 return false;
442 } 339 }
443
444 #endif
445
446 return true; 340 return true;
447 } 341 }
448 342
449 template <class T> 343 template <class T>
450 bool 344 bool
451 octave_base_int_scalar<T>::save_binary (std::ostream& os, 345 octave_base_int_scalar<T>::save_binary (std::ostream& os, bool&)
452 bool& /* save_as_floats */) 346 {
453 { 347 os.write (X_CAST(char *, &scalar), byte_size());
454 #if 0
455
456 char tmp = (char) LS_DOUBLE;
457 os.write (X_CAST (char *, &tmp), 1);
458 double dtmp = double_value ();
459 os.write (X_CAST (char *, &dtmp), 8);
460
461 #endif
462
463 return true; 348 return true;
464 } 349 }
465 350
466 template <class T> 351 template <class T>
467 bool 352 bool
468 octave_base_int_scalar<T>::load_binary (std::istream& is, bool swap, 353 octave_base_int_scalar<T>::load_binary (std::istream& is, bool swap,
469 oct_mach_info::float_format fmt) 354 oct_mach_info::float_format)
470 { 355 {
471 #if 0 356 T tmp;
472 357 if (! is.read (X_CAST (char *, &tmp), byte_size()))
473 char tmp;
474 if (! is.read (X_CAST (char *, &tmp), 1))
475 return false; 358 return false;
476 359
477 double dtmp; 360 if (swap)
478 read_doubles (is, &dtmp, X_CAST (save_type, tmp), 1, swap, fmt); 361 switch (byte_size())
479 if (error_state || ! is) 362 {
480 return false; 363 case 8:
481 364 swap_8_bytes (X_CAST (char *, &tmp));
482 scalar = dtmp; 365 break;
483 366 case 4:
484 #endif 367 swap_4_bytes (X_CAST (char *, &tmp));
485 368 break;
369 case 2:
370 swap_2_bytes (X_CAST (char *, &tmp));
371 break;
372 case 1:
373 default:
374 break;
375 }
376 scalar = tmp;
486 return true; 377 return true;
487 } 378 }
488 379
489 #if defined (HAVE_HDF5) 380 #if defined (HAVE_HDF5)
490 template <class T> 381 template <class T>
491 bool 382 bool
492 octave_base_int_scalar<T>::save_hdf5 (hid_t loc_id, const char *name, 383 octave_base_int_scalar<T>::save_hdf5 (hid_t loc_id, const char *name, bool)
493 bool /* save_as_floats */) 384 {
494 { 385 hid_t save_type_hid = HDF5_SAVE_TYPE;
495 bool retval = true; 386 bool retval = true;
496
497 #if 0
498
499 hsize_t dimens[3]; 387 hsize_t dimens[3];
500 hid_t space_hid = -1, data_hid = -1; 388 hid_t space_hid = -1, data_hid = -1;
501 389
502 space_hid = H5Screate_simple (0, dimens, 0); 390 space_hid = H5Screate_simple (0, dimens, 0);
503 if (space_hid < 0) return false; 391 if (space_hid < 0) return false;
504 392
505 data_hid = H5Dcreate (loc_id, name, H5T_NATIVE_DOUBLE, space_hid, 393 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
506 H5P_DEFAULT); 394 H5P_DEFAULT);
507 if (data_hid < 0) 395 if (data_hid < 0)
508 { 396 {
509 H5Sclose (space_hid); 397 H5Sclose (space_hid);
510 return false; 398 return false;
511 } 399 }
512 400
513 double tmp = double_value (); 401 retval = H5Dwrite (data_hid, save_type_hid, H5S_ALL, H5S_ALL,
514 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, 402 H5P_DEFAULT, &scalar) >= 0;
515 H5P_DEFAULT, &tmp) >= 0;
516 403
517 H5Dclose (data_hid); 404 H5Dclose (data_hid);
518 H5Sclose (space_hid); 405 H5Sclose (space_hid);
519 406
520 #endif
521
522 return retval; 407 return retval;
523 } 408 }
524 409
525 template <class T> 410 template <class T>
526 bool 411 bool
527 octave_base_int_scalar<T>::load_hdf5 (hid_t loc_id, const char *name, 412 octave_base_int_scalar<T>::load_hdf5 (hid_t loc_id, const char *name,
528 bool /* have_h5giterate_bug */) 413 bool /* have_h5giterate_bug */)
529 { 414 {
530 #if 0 415 hid_t save_type_hid = HDF5_SAVE_TYPE;
531
532 hid_t data_hid = H5Dopen (loc_id, name); 416 hid_t data_hid = H5Dopen (loc_id, name);
533 hid_t space_id = H5Dget_space (data_hid); 417 hid_t space_id = H5Dget_space (data_hid);
534 418
535 hsize_t rank = H5Sget_simple_extent_ndims (space_id); 419 hsize_t rank = H5Sget_simple_extent_ndims (space_id);
536 420
538 { 422 {
539 H5Dclose (data_hid); 423 H5Dclose (data_hid);
540 return false; 424 return false;
541 } 425 }
542 426
543 double dtmp; 427 T tmp;
544 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, 428 if (H5Dread (data_hid, save_type_hid, H5S_ALL, H5S_ALL,
545 H5P_DEFAULT, &dtmp) < 0) 429 H5P_DEFAULT, &tmp) < 0)
546 { 430 {
547 H5Dclose (data_hid); 431 H5Dclose (data_hid);
548 return false; 432 return false;
549 } 433 }
550 434
551 scalar = dtmp; 435 scalar = tmp;
552 436
553 H5Dclose (data_hid); 437 H5Dclose (data_hid);
554 #endif
555 438
556 return true; 439 return true;
557 } 440 }
558 #endif 441 #endif
559 442