Mercurial > hg > octave-nkf

comparison src/ov-base-int.cc @ 4903:bfe64e459ce3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2004-06-14 19:20:26 by jwe]
author jwe
date Mon, 14 Jun 2004 19:20:26 +0000
parents
children f69e95587ba3
comparison
equal deleted inserted replaced
4902:bd043a433918 4903:bfe64e459ce3
1 /*
2
3 Copyright (C) 2004 John W. Eaton
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
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
21 */
22
23 #if defined (__GNUG__) && defined (USE_PRAGMA_INTERFACE_IMPLEMENTATION)
24 #pragma implementation
25 #endif
26
27 #ifdef HAVE_CONFIG_H
28 #include <config.h>
29 #endif
30
31 #include <climits>
32
33 #include <iostream>
34 #include <vector>
35
36 #include "lo-ieee.h"
37 #include "lo-utils.h"
38 #include "mx-base.h"
39 #include "quit.h"
40
41 #include "defun.h"
42 #include "gripes.h"
43 #include "oct-obj.h"
44 #include "oct-lvalue.h"
45 #include "ops.h"
46 #include "ov-base.h"
47 #include "ov-base-mat.h"
48 #include "ov-base-mat.cc"
49 #include "ov-base-scalar.h"
50 #include "ov-base-scalar.cc"
51 #include "ov-base-int.h"
52 #include "ov-int-traits.h"
53 #include "pr-output.h"
54 #include "variables.h"
55
56 #include "byte-swap.h"
57 #include "ls-oct-ascii.h"
58 #include "ls-utils.h"
59 #include "ls-hdf5.h"
60
61 template <class T>
62 octave_value *
63 octave_base_int_matrix<T>::try_narrowing_conversion (void)
64 {
65 octave_value *retval = 0;
66
67 if (matrix.nelem () == 1)
68 retval = new typename octave_value_int_traits<T>::scalar_type (matrix (0));
69
70 return retval;
71 }
72
73 template <class T>
74 bool
75 octave_base_int_matrix<T>::save_ascii (std::ostream& os, bool& infnan_warned,
76 bool /* strip_nan_and_inf */)
77 {
78 infnan_warned = false;
79
80 dim_vector d = dims ();
81
82 os << "# ndims: " << d.length () << "\n";
83
84 for (int i = 0; i < d.length (); i++)
85 os << " " << d (i);
86
87 os << "\n" << matrix;
88
89 return true;
90 }
91
92 template <class T>
93 bool
94 octave_base_int_matrix<T>::load_ascii (std::istream& is)
95 {
96 int mdims = 0;
97 bool success = true;
98
99 if (extract_keyword (is, "ndims", mdims, true))
100 {
101 if (mdims >= 0)
102 {
103 dim_vector dv;
104 dv.resize (mdims);
105
106 for (int i = 0; i < mdims; i++)
107 is >> dv(i);
108
109 T tmp(dv);
110
111 is >> tmp;
112
113 if (!is)
114 {
115 error ("load: failed to load matrix constant");
116 success = false;
117 }
118
119 matrix = tmp;
120 }
121 else
122 {
123 error ("load: failed to extract number of rows and columns");
124 success = false;
125 }
126 }
127 else
128 error ("load: failed to extract number of dimensions");
129
130 return success;
131 }
132
133 template <class T>
134 bool
135 octave_base_int_matrix<T>::save_binary (std::ostream& os, bool& save_as_floats)
136 {
137 #if 0
138
139 dim_vector d = dims ();
140 if (d.length() < 1)
141 return false;
142
143 // Use negative value for ndims to differentiate with old format!!
144 FOUR_BYTE_INT tmp = - d.length();
145 os.write (X_CAST (char *, &tmp), 4);
146 for (int i=0; i < d.length (); i++)
147 {
148 tmp = d(i);
149 os.write (X_CAST (char *, &tmp), 4);
150 }
151
152 NDArray m = array_value ();
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
176 return true;
177 }
178
179 template <class T>
180 bool
181 octave_base_int_matrix<T>::load_binary (std::istream& is, bool swap,
182 oct_mach_info::float_format fmt)
183 {
184 #if 0
185
186 char tmp;
187 FOUR_BYTE_INT mdims;
188 if (! is.read (X_CAST (char *, &mdims), 4))
189 return false;
190 if (swap)
191 swap_4_bytes (X_CAST (char *, &mdims));
192 if (mdims < 0)
193 {
194 mdims = - mdims;
195 FOUR_BYTE_INT di;
196 dim_vector dv;
197 dv.resize (mdims);
198
199 for (int i = 0; i < mdims; i++)
200 {
201 if (! is.read (X_CAST (char *, &di), 4))
202 return false;
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;
224 if (swap)
225 swap_4_bytes (X_CAST (char *, &nc));
226 if (! is.read (X_CAST (char *, &tmp), 1))
227 return false;
228 Matrix m (nr, nc);
229 double *re = m.fortran_vec ();
230 int len = nr * nc;
231 read_doubles (is, re, X_CAST (save_type, tmp), len, swap, fmt);
232 if (error_state || ! is)
233 return false;
234 matrix = m;
235 }
236
237 #endif
238
239 return true;
240 }
241
242 #if defined (HAVE_HDF5)
243
244 template <class T>
245 bool
246 octave_base_int_matrix<T>::save_hdf5 (hid_t loc_id, const char *name,
247 bool save_as_floats)
248 {
249 bool retval = true;
250
251 #if 0
252
253 dim_vector dv = dims ();
254 int empty = save_hdf5_empty (loc_id, name, dv);
255 if (empty)
256 return (empty > 0);
257
258 int rank = dv.length ();
259 hid_t space_hid = -1, data_hid = -1;
260 NDArray m = array_value ();
261
262 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);
263
264 // Octave uses column-major, while HDF5 uses row-major ordering
265 for (int i = 0; i < rank; i++)
266 hdims[i] = dv (rank-i-1);
267
268 space_hid = H5Screate_simple (rank, hdims, 0);
269
270 if (space_hid < 0) return false;
271
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,
297 H5P_DEFAULT);
298 if (data_hid < 0)
299 {
300 H5Sclose (space_hid);
301 return false;
302 }
303
304 double *mtmp = m.fortran_vec ();
305 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
306 H5P_DEFAULT, mtmp) >= 0;
307
308 H5Dclose (data_hid);
309 H5Sclose (space_hid);
310
311 #endif
312
313 return retval;
314 }
315
316 template <class T>
317 bool
318 octave_base_int_matrix<T>::load_hdf5 (hid_t loc_id, const char *name,
319 bool /* have_h5giterate_bug */)
320 {
321 bool retval = false;
322
323 #if 0
324
325 dim_vector dv;
326 int empty = load_hdf5_empty (loc_id, name, dv);
327 if (empty > 0)
328 matrix.resize(dv);
329 if (empty)
330 return (empty > 0);
331
332 hid_t data_hid = H5Dopen (loc_id, name);
333 hid_t space_id = H5Dget_space (data_hid);
334
335 hsize_t rank = H5Sget_simple_extent_ndims (space_id);
336
337 if (rank < 1)
338 {
339 H5Sclose (space_id);
340 H5Dclose (data_hid);
341 return false;
342 }
343
344 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);
345 OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank);
346
347 H5Sget_simple_extent_dims (space_id, hdims, maxdims);
348
349 // Octave uses column-major, while HDF5 uses row-major ordering
350 if (rank == 1)
351 {
352 dv.resize (2);
353 dv(0) = 1;
354 dv(1) = hdims[0];
355 }
356 else
357 {
358 dv.resize (rank);
359 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--)
360 dv(j) = hdims[i];
361 }
362
363 NDArray m (dv);
364 double *re = m.fortran_vec ();
365 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
366 H5P_DEFAULT, re) >= 0)
367 {
368 retval = true;
369 matrix = m;
370 }
371
372 H5Sclose (space_id);
373 H5Dclose (data_hid);
374
375 #endif
376
377 return retval;
378 }
379
380 #endif
381
382 template <class T>
383 void
384 octave_base_int_matrix<T>::print_raw (std::ostream& os,
385 bool pr_as_read_syntax) const
386 {
387 octave_print_internal (os, matrix, pr_as_read_syntax,
388 current_print_indent_level ());
389 }
390
391 template <class T>
392 bool
393 octave_base_int_scalar<T>::save_ascii (std::ostream& os, bool& infnan_warned,
394 bool strip_nan_and_inf)
395 {
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;
429 }
430
431 template <class T>
432 bool
433 octave_base_int_scalar<T>::load_ascii (std::istream& is)
434 {
435 #if 0
436
437 scalar = octave_read_double (is);
438 if (!is)
439 {
440 error ("load: failed to load scalar constant");
441 return false;
442 }
443
444 #endif
445
446 return true;
447 }
448
449 template <class T>
450 bool
451 octave_base_int_scalar<T>::save_binary (std::ostream& os,
452 bool& /* save_as_floats */)
453 {
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;
464 }
465
466 template <class T>
467 bool
468 octave_base_int_scalar<T>::load_binary (std::istream& is, bool swap,
469 oct_mach_info::float_format fmt)
470 {
471 #if 0
472
473 char tmp;
474 if (! is.read (X_CAST (char *, &tmp), 1))
475 return false;
476
477 double dtmp;
478 read_doubles (is, &dtmp, X_CAST (save_type, tmp), 1, swap, fmt);
479 if (error_state || ! is)
480 return false;
481
482 scalar = dtmp;
483
484 #endif
485
486 return true;
487 }
488
489 #if defined (HAVE_HDF5)
490 template <class T>
491 bool
492 octave_base_int_scalar<T>::save_hdf5 (hid_t loc_id, const char *name,
493 bool /* save_as_floats */)
494 {
495 bool retval = true;
496
497 #if 0
498
499 hsize_t dimens[3];
500 hid_t space_hid = -1, data_hid = -1;
501
502 space_hid = H5Screate_simple (0, dimens, 0);
503 if (space_hid < 0) return false;
504
505 data_hid = H5Dcreate (loc_id, name, H5T_NATIVE_DOUBLE, space_hid,
506 H5P_DEFAULT);
507 if (data_hid < 0)
508 {
509 H5Sclose (space_hid);
510 return false;
511 }
512
513 double tmp = double_value ();
514 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
515 H5P_DEFAULT, &tmp) >= 0;
516
517 H5Dclose (data_hid);
518 H5Sclose (space_hid);
519
520 #endif
521
522 return retval;
523 }
524
525 template <class T>
526 bool
527 octave_base_int_scalar<T>::load_hdf5 (hid_t loc_id, const char *name,
528 bool /* have_h5giterate_bug */)
529 {
530 #if 0
531
532 hid_t data_hid = H5Dopen (loc_id, name);
533 hid_t space_id = H5Dget_space (data_hid);
534
535 hsize_t rank = H5Sget_simple_extent_ndims (space_id);
536
537 if (rank != 0)
538 {
539 H5Dclose (data_hid);
540 return false;
541 }
542
543 double dtmp;
544 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
545 H5P_DEFAULT, &dtmp) < 0)
546 {
547 H5Dclose (data_hid);
548 return false;
549 }
550
551 scalar = dtmp;
552
553 H5Dclose (data_hid);
554 #endif
555
556 return true;
557 }
558 #endif
559
560 /*
561 ;;; Local Variables: ***
562 ;;; mode: C++ ***
563 ;;; End: ***
564 */