Mercurial > octave
annotate libinterp/octave-value/ov-range.cc @ 30853:fc3bd70cd1be stable
eliminate range<T>::make_constant function
Overloading ranges as a way to create constant arrays adds complexity
to the range class for limited benefit. It is currently only used for
double-valued ranges and only provides constant row vectors. If this
optimization is determined to be useful, it would probably be best to
provide a data type that allows N-d constant arrays. The legacy range
class was revived in a previous changeset so that constant ranges
(increment == 0) can be loaded from existing data files and converted
to ordinary arrays automatically.
* Range.h (range<T>::make_constant): Delete. Remove all uses.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Tue, 22 Mar 2022 00:01:53 -0400 |
parents | 95725e6ad9c1 |
children | eba0a86471b9 |
rev | line source |
---|---|
27923
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
1 //////////////////////////////////////////////////////////////////////// |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
2 // |
30564
796f54d4ddbf
update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents:
30437
diff
changeset
|
3 // Copyright (C) 1996-2022 The Octave Project Developers |
27923
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
4 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
5 // See the file COPYRIGHT.md in the top-level directory of this |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
6 // distribution or <https://octave.org/copyright/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
7 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
8 // This file is part of Octave. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
9 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
10 // Octave is free software: you can redistribute it and/or modify it |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
11 // under the terms of the GNU General Public License as published by |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
12 // the Free Software Foundation, either version 3 of the License, or |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
13 // (at your option) any later version. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
14 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
15 // Octave is distributed in the hope that it will be useful, but |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
16 // WITHOUT ANY WARRANTY; without even the implied warranty of |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
18 // GNU General Public License for more details. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
19 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
20 // You should have received a copy of the GNU General Public License |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
21 // along with Octave; see the file COPYING. If not, see |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
22 // <https://www.gnu.org/licenses/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
23 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
24 //////////////////////////////////////////////////////////////////////// |
2376 | 25 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
26 #if defined (HAVE_CONFIG_H) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
27 # include "config.h" |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
28 #endif |
2376 | 29 |
25438
cb1606f78f6b
prefer <istream>, <ostream>, or <iosfwd> to <iostream> where possible
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
30 #include <istream> |
cb1606f78f6b
prefer <istream>, <ostream>, or <iosfwd> to <iostream> where possible
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
31 #include <ostream> |
cb1606f78f6b
prefer <istream>, <ostream>, or <iosfwd> to <iostream> where possible
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
32 #include <sstream> |
2901 | 33 |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
34 #include "dNDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
35 #include "fNDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
36 #include "int8NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
37 #include "int16NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
38 #include "int32NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
39 #include "int64NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
40 #include "uint8NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
41 #include "uint16NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
42 #include "uint32NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
43 #include "uint64NDArray.h" |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
44 |
2376 | 45 #include "lo-ieee.h" |
46 #include "lo-utils.h" | |
47 | |
10605
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
48 #include "defun.h" |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
49 #include "variables.h" |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
21022
diff
changeset
|
50 #include "errwarn.h" |
15149
62a35ae7d6a2
use forward decls for mxArray in ov.h and ov-base.h
John W. Eaton <jwe@octave.org>
parents:
15057
diff
changeset
|
51 #include "mxarray.h" |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
52 #include "mx-type-traits.h" |
2376 | 53 #include "ops.h" |
20940
48b2ad5ee801
maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents:
20893
diff
changeset
|
54 #include "ovl.h" |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
55 #include "oct-hdf5.h" |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
56 #include "ov-range-traits.h" |
2376 | 57 #include "ov-range.h" |
58 #include "ov-re-mat.h" | |
2410 | 59 #include "ov-scalar.h" |
2376 | 60 #include "pr-output.h" |
61 | |
4687 | 62 #include "byte-swap.h" |
8946
e7e928088e90
fix CRLF issues with text-mode reading in windows when loading ascii data
Benjamin Lindner <lindnerb@users.sourceforge.net>
parents:
8920
diff
changeset
|
63 #include "ls-ascii-helper.h" |
4687 | 64 #include "ls-hdf5.h" |
65 #include "ls-utils.h" | |
66 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
67 #if defined (HAVE_HDF5) |
10613
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
68 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
69 template <> |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
70 octave_hdf5_id ov_range<double>::hdf5_save_type = H5T_NATIVE_DOUBLE; |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
71 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
72 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
73 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
74 # if 0 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
75 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
76 template <> |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
77 octave_hdf5_id ov_range<float>::hdf5_save_type = H5T_NATIVE_FLOAT; |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
78 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
79 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
80 octave_hdf5_id ov_range<octave_int8>::hdf5_save_type = H5T_NATIVE_INT8; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
81 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
82 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
83 octave_hdf5_id ov_range<octave_int16>::hdf5_save_type = H5T_NATIVE_INT16; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
84 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
85 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
86 octave_hdf5_id ov_range<octave_int32>::hdf5_save_type = H5T_NATIVE_INT32; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
87 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
88 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
89 octave_hdf5_id ov_range<octave_int64>::hdf5_save_type = H5T_NATIVE_INT64; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
90 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
91 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
92 octave_hdf5_id ov_range<octave_uint8>::hdf5_save_type = H5T_NATIVE_UINT8; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
93 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
94 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
95 octave_hdf5_id ov_range<octave_uint16>::hdf5_save_type = H5T_NATIVE_UINT16; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
96 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
97 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
98 octave_hdf5_id ov_range<octave_uint32>::hdf5_save_type = H5T_NATIVE_UINT32; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
99 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
100 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
101 octave_hdf5_id ov_range<octave_uint64>::hdf5_save_type = H5T_NATIVE_UINT64; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
102 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
103 # endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
104 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
105 #else |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
106 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
107 template <> |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
108 octave_hdf5_id ov_range<double>::hdf5_save_type = 0; |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
109 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
110 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
111 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
112 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
113 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
114 template <> |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
115 octave_hdf5_id ov_range<float>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
116 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
117 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
118 octave_hdf5_id ov_range<octave_int8>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
119 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
120 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
121 octave_hdf5_id ov_range<octave_int16>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
122 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
123 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
124 octave_hdf5_id ov_range<octave_int32>::hdf5_save_type = 0; |
2376 | 125 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
126 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
127 octave_hdf5_id ov_range<octave_int64>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
128 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
129 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
130 octave_hdf5_id ov_range<octave_uint8>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
131 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
132 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
133 octave_hdf5_id ov_range<octave_uint16>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
134 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
135 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
136 octave_hdf5_id ov_range<octave_uint32>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
137 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
138 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
139 octave_hdf5_id ov_range<octave_uint64>::hdf5_save_type = 0; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
140 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
141 # endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
142 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
143 #endif |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
144 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
145 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<double>, |
30852
95725e6ad9c1
restore part of the old octave_range class as octave_legacy_range
John W. Eaton <jwe@octave.org>
parents:
30835
diff
changeset
|
146 "double_range", "double"); |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
147 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
148 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
149 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
150 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
151 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
152 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<float>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
153 "float_range", "single"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
154 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
155 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_int8>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
156 "int8_range", "int8"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
157 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
158 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_int16>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
159 "int16_range", "int16"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
160 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
161 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_int32>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
162 "int32_range", "int32"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
163 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
164 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_int64>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
165 "int64_range", "int64"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
166 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
167 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_uint8>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
168 "uint8_range", "uint8"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
169 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
170 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_uint16>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
171 "uint16_range", "uint16"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
172 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
173 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_uint32>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
174 "uint32_range", "uint32"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
175 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
176 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<octave_uint64>, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
177 "uint64_range", "uint64"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
178 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
179 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
180 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
181 template <typename T> |
5759 | 182 static octave_base_value * |
183 default_numeric_conversion_function (const octave_base_value& a) | |
2376 | 184 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
185 typedef typename octave_value_range_traits<T>::matrix_type ov_mx_type; |
2376 | 186 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
187 const ov_range<T>& v = dynamic_cast<const ov_range<T>&> (a); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
188 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
189 return new ov_mx_type (v.raw_array_value ()); |
2376 | 190 } |
191 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
192 template <typename T> |
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
193 octave_base_value::type_conv_info |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
194 ov_range<T>::numeric_conversion_function (void) const |
2376 | 195 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
196 typedef typename octave_value_range_traits<T>::matrix_type ov_mx_type; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
197 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
198 return octave_base_value::type_conv_info |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
199 (default_numeric_conversion_function<T>, ov_mx_type::static_type_id ()); |
2376 | 200 } |
201 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
202 template <typename T> |
5759 | 203 octave_base_value * |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
204 ov_range<T>::try_narrowing_conversion (void) |
2410 | 205 { |
23457
21baad6b35c4
maint: Use C++11 nullptr rather than 0 or NULL when possible.
Rik <rik@octave.org>
parents:
23450
diff
changeset
|
206 octave_base_value *retval = nullptr; |
2410 | 207 |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
208 switch (numel ()) |
2410 | 209 { |
210 case 1: | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
211 retval = new typename octave_value_range_traits<T>::scalar_type (m_range.elem (0)); |
2410 | 212 break; |
213 | |
214 case 0: | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
215 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
216 typedef typename octave_value_range_traits<T>::matrix_type ov_mx_type; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
217 typename ov_mx_type::object_type m (dim_vector (1, 0)); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
218 retval = new ov_mx_type (m); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
219 } |
2410 | 220 break; |
221 | |
8971 | 222 case -2: |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
223 // FIXME: is this case possible now? It would have to be due to |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
224 // conversion from Range to range<double>, but even in that case, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
225 // is the invalid numel value preserved? |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
226 retval = new typename octave_value_range_traits<T>::matrix_type (raw_array_value ()); |
8971 | 227 break; |
228 | |
2410 | 229 default: |
230 break; | |
231 } | |
232 | |
233 return retval; | |
234 } | |
235 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
236 template <typename T> |
2436 | 237 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
238 ov_range<T>::subsref (const std::string& type, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
239 const std::list<octave_value_list>& idx) |
3933 | 240 { |
241 octave_value retval; | |
242 | |
243 switch (type[0]) | |
244 { | |
245 case '(': | |
246 retval = do_index_op (idx.front ()); | |
247 break; | |
248 | |
249 case '{': | |
250 case '.': | |
251 { | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
252 std::string nm = type_name (); |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
253 error ("%s cannot be indexed with %c", nm.c_str (), type[0]); |
3933 | 254 } |
255 break; | |
256 | |
257 default: | |
258 panic_impossible (); | |
259 } | |
260 | |
261 return retval.next_subsref (type, idx); | |
262 } | |
263 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
264 template <typename T> |
3933 | 265 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
266 ov_range<T>::do_index_op (const octave_value_list& idx, |
30390
a61e1a0f6024
maint: style check C++ files in libinterp/ ahead of 7.1 release.
Rik <rik@octave.org>
parents:
30006
diff
changeset
|
267 bool resize_ok) |
2436 | 268 { |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
269 if (idx.length () == 1 && ! resize_ok) |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
270 { |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
271 octave_value retval; |
2436 | 272 |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
273 // The range can handle a single subscript. |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
274 |
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
275 try |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
276 { |
29569
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29394
diff
changeset
|
277 octave::idx_vector i = idx(0).index_vector (); |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
278 |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
279 if (i.is_scalar () && i(0) < numel ()) |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
280 retval = m_range.elem (i(0)); |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20542
diff
changeset
|
281 else |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
282 retval = m_range.index (i); |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
283 } |
29163
8f67ad8b3103
maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents:
28646
diff
changeset
|
284 catch (octave::index_exception& ie) |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
285 { |
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
286 // More info may be added later before displaying error. |
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
287 |
29163
8f67ad8b3103
maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents:
28646
diff
changeset
|
288 ie.set_pos_if_unset (1, 1); |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20228
diff
changeset
|
289 throw; |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
290 } |
2436 | 291 |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
292 return retval; |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
293 } |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
294 else |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
295 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
296 octave_value tmp (new typename octave_value_range_traits<T>::matrix_type (raw_array_value ())); |
2436 | 297 |
28631
70cdf8de553d
move non-member octave_value operator functions to octave namespace
John W. Eaton <jwe@octave.org>
parents:
28628
diff
changeset
|
298 return tmp.index_op (idx, resize_ok); |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
299 } |
2436 | 300 } |
301 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
302 template <typename T> |
29569
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29394
diff
changeset
|
303 octave::idx_vector |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
304 ov_range<T>::index_vector (bool require_integers) const |
10605
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
305 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
306 octave_value tmp (raw_array_value ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
307 return tmp.index_vector (require_integers); |
10605
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
308 } |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
309 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
310 template <typename T> |
2376 | 311 double |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
312 ov_range<T>::double_value (bool) const |
2376 | 313 { |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
314 octave_idx_type nel = numel (); |
2376 | 315 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
316 if (nel == 0) |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
317 err_invalid_conversion ("range", "real scalar"); |
4455 | 318 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
319 warn_implicit_conversion ("Octave:array-to-scalar", |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
320 "range", "real scalar"); |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
321 |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
322 return m_range.base (); |
2376 | 323 } |
324 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
325 template <typename T> |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
326 float |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
327 ov_range<T>::float_value (bool) const |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
328 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
329 octave_idx_type nel = numel (); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
330 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
331 if (nel == 0) |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
332 err_invalid_conversion ("range", "real scalar"); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
333 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
334 warn_implicit_conversion ("Octave:array-to-scalar", |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
335 "range", "real scalar"); |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
336 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
337 return m_range.base (); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
338 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
339 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
340 template <typename T> |
9146
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
341 charNDArray |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
342 ov_range<T>::char_array_value (bool) const |
9146
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
343 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
344 const Array<T> matrix = raw_array_value (); |
9146
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
345 charNDArray retval (dims ()); |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
346 |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
347 octave_idx_type nel = numel (); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
348 |
9146
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
349 for (octave_idx_type i = 0; i < nel; i++) |
25688
b2917b7858ba
maint: Use Octave convention for spacing of C++ cast statements.
Rik <rik@octave.org>
parents:
25438
diff
changeset
|
350 retval.elem (i) = static_cast<char> (matrix.elem (i)); |
9146
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
351 |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
352 return retval; |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
353 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
354 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
355 template <typename T> |
2376 | 356 Complex |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
357 ov_range<T>::complex_value (bool) const |
14557
e8e86ae3abbc
make diag (x, m, n) return a proper diagonal matrix object (bug #36099)
John W. Eaton <jwe@octave.org>
parents:
14469
diff
changeset
|
358 { |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
359 octave_idx_type nel = numel (); |
2376 | 360 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
361 if (nel == 0) |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
362 err_invalid_conversion ("range", "complex scalar"); |
4455 | 363 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
364 warn_implicit_conversion ("Octave:array-to-scalar", |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
365 "range", "complex scalar"); |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
366 |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
367 return Complex (m_range.base (), 0); |
2376 | 368 } |
369 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
370 template <typename T> |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
371 FloatComplex |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
372 ov_range<T>::float_complex_value (bool) const |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
373 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
374 float tmp = lo_ieee_float_nan_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
375 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
376 FloatComplex retval (tmp, tmp); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
377 |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
378 octave_idx_type nel = numel (); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
379 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
380 if (nel == 0) |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
381 err_invalid_conversion ("range", "complex scalar"); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
382 |
21118
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
383 warn_implicit_conversion ("Octave:array-to-scalar", |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
384 "range", "complex scalar"); |
3ac9f47fb04b
Invert pattern if/code/else/err_XXX to if !/err_XXX/code.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
385 |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
386 retval = m_range.base (); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
387 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
388 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
389 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
390 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
391 template <typename T> |
10613
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
392 boolNDArray |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
393 ov_range<T>::bool_array_value (bool warn) const |
10613
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
394 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
395 Array<T> matrix = raw_array_value (); |
10613
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
396 |
29937
da7210e30f3e
move some utility functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29569
diff
changeset
|
397 if (warn && ! matrix.test_all (octave::is_one_or_zero<T>)) |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
21022
diff
changeset
|
398 warn_logical_conversion (); |
10613
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
399 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
400 return boolNDArray (matrix); |
10613
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
401 } |
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
402 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
403 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
404 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
405 ov_range<T>::resize (const dim_vector& dv, bool fill) const |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
406 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
407 Array<T> retval = raw_array_value (); |
5731 | 408 if (fill) |
14616
13cc11418393
improve handling of default resize fill value for arrays
John W. Eaton <jwe@octave.org>
parents:
14557
diff
changeset
|
409 retval.resize (dv, 0); |
5731 | 410 else |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
411 retval.resize (dv); |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
412 return retval; |
5731 | 413 } |
414 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
415 template <typename T> |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
416 octave::range<double> |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
417 ov_range<T>::range_value (void) const |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
418 { |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
419 err_wrong_type_arg ("ov_range<T>::range_value()", type_name ()); |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
420 } |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
421 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
422 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
423 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
424 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
425 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
426 template <typename T> |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
427 octave::range<float> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
428 ov_range<T>::float_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
429 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
430 err_wrong_type_arg ("ov_range<T>::float_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
431 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
432 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
433 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
434 octave::range<octave_int8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
435 ov_range<T>::int8_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
436 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
437 err_wrong_type_arg ("ov_range<T>::int8_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
438 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
439 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
440 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
441 octave::range<octave_int16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
442 ov_range<T>::int16_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
443 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
444 err_wrong_type_arg ("ov_range<T>::int16_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
445 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
446 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
447 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
448 octave::range<octave_int32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
449 ov_range<T>::int32_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
450 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
451 err_wrong_type_arg ("ov_range<T>::int32_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
452 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
453 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
454 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
455 octave::range<octave_int64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
456 ov_range<T>::int64_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
457 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
458 err_wrong_type_arg ("ov_range<T>::int64_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
459 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
460 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
461 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
462 octave::range<octave_uint8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
463 ov_range<T>::uint8_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
464 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
465 err_wrong_type_arg ("ov_range<T>::uint8_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
466 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
467 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
468 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
469 octave::range<octave_uint16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
470 ov_range<T>::uint16_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
471 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
472 err_wrong_type_arg ("ov_range<T>::uint16_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
473 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
474 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
475 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
476 octave::range<octave_uint32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
477 ov_range<T>::uint32_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
478 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
479 err_wrong_type_arg ("ov_range<T>::uint32_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
480 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
481 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
482 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
483 octave::range<octave_uint64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
484 ov_range<T>::uint64_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
485 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
486 err_wrong_type_arg ("ov_range<T>::uint64_range_value ()", type_name ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
487 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
488 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
489 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
490 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
491 template <typename T> |
2376 | 492 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
493 ov_range<T>::convert_to_str_internal (bool pad, bool force, char type) const |
2449 | 494 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
495 octave_value tmp (raw_array_value ()); |
5279 | 496 return tmp.convert_to_str (pad, force, type); |
2449 | 497 } |
498 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
499 // FIXME: could most of these fucntions preserve range type now? |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
500 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
501 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
502 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
503 ov_range<T>::as_double (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
504 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
505 return NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
506 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
507 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
508 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
509 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
510 ov_range<T>::as_single (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
511 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
512 return FloatMatrix (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
513 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
514 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
515 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
516 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
517 ov_range<T>::as_int8 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
518 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
519 return int8NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
520 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
521 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
522 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
523 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
524 ov_range<T>::as_int16 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
525 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
526 return int16NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
527 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
528 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
529 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
530 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
531 ov_range<T>::as_int32 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
532 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
533 return int32NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
534 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
535 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
536 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
537 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
538 ov_range<T>::as_int64 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
539 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
540 return int64NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
541 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
542 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
543 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
544 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
545 ov_range<T>::as_uint8 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
546 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
547 return uint8NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
548 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
549 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
550 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
551 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
552 ov_range<T>::as_uint16 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
553 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
554 return uint16NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
555 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
556 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
557 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
558 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
559 ov_range<T>::as_uint32 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
560 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
561 return uint32NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
562 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
563 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
564 template <typename T> |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
565 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
566 ov_range<T>::as_uint64 (void) const |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
567 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
568 return uint64NDArray (raw_array_value ()); |
22296
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
569 } |
8b18f46f6427
revamp double, single, int type conversions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
570 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
571 template <typename T> |
2376 | 572 void |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
573 ov_range<T>::print (std::ostream& os, bool pr_as_read_syntax) |
2901 | 574 { |
575 print_raw (os, pr_as_read_syntax); | |
576 newline (os); | |
577 } | |
578 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
579 template <typename T> |
2901 | 580 void |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
581 ov_range<T>::print_raw (std::ostream& os, bool pr_as_read_syntax) const |
2901 | 582 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
583 // FIXME: this is a potential waste of memory. |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
584 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
585 typedef typename octave_value_range_traits<T>::matrix_type ov_mx_type; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
586 typename ov_mx_type::object_type tmp (raw_array_value ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
587 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
588 octave_print_internal (os, tmp, pr_as_read_syntax, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
589 current_print_indent_level ()); |
2901 | 590 } |
591 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
592 template <typename T> |
2901 | 593 bool |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
594 ov_range<T>::print_name_tag (std::ostream& os, const std::string& name) const |
2376 | 595 { |
2901 | 596 bool retval = false; |
597 | |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
598 octave_idx_type n = numel (); |
2901 | 599 |
600 indent (os); | |
601 | |
602 if (n == 0 || n == 1) | |
603 os << name << " = "; | |
604 else | |
605 { | |
606 os << name << " ="; | |
607 newline (os); | |
13112
969ed305dde5
Remove all blank lines with "format compact"
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
12863
diff
changeset
|
608 if (! Vcompact_format) |
969ed305dde5
Remove all blank lines with "format compact"
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
12863
diff
changeset
|
609 newline (os); |
969ed305dde5
Remove all blank lines with "format compact"
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
12863
diff
changeset
|
610 |
2901 | 611 retval = true; |
612 } | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
613 |
2901 | 614 return retval; |
2376 | 615 } |
616 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
617 template <typename T> |
17870 | 618 void |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
619 ov_range<T>::short_disp (std::ostream& os) const |
16468
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
620 { |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
621 octave_idx_type len = numel (); |
16468
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
622 |
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
623 if (len == 0) |
17870 | 624 os << "[]"; |
16468
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
625 else |
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
626 { |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
627 os << m_range.base () << ':'; |
16468
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
628 |
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
629 if (len > 1) |
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
630 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
631 if (m_range.increment () != T (1)) |
28636
a3db48e66ef8
use Range::increment instead of Range::inc
John W. Eaton <jwe@octave.org>
parents:
28634
diff
changeset
|
632 os << m_range.increment () << ':'; |
16468
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
633 |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
634 os << m_range.limit (); |
16468
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
635 } |
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
636 } |
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
637 } |
0f143f68078d
use signal/slot for updating workspace instead of using event listener
John W. Eaton <jwe@octave.org>
parents:
15195
diff
changeset
|
638 |
4687 | 639 // Skip white space and comments on stream IS. |
640 | |
641 static void | |
642 skip_comments (std::istream& is) | |
643 { | |
644 char c = '\0'; | |
645 while (is.get (c)) | |
646 { | |
647 if (c == ' ' || c == '\t' || c == '\n') | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
648 ; // Skip whitespace on way to beginning of next line. |
4687 | 649 else |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
650 break; |
4687 | 651 } |
652 | |
30006
75dff8f2de2e
move some load-save utilities to octave namespace
John W. Eaton <jwe@octave.org>
parents:
29937
diff
changeset
|
653 octave::skip_until_newline (is, false); |
4687 | 654 } |
655 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
656 template <typename T> |
24745
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
657 float_display_format |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
658 ov_range<T>::get_edit_display_format (void) const |
24745
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
659 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
660 return make_format (m_range); |
24745
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
661 } |
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
662 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
663 template <typename T> |
24745
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
664 std::string |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
665 ov_range<T>::edit_display (const float_display_format& fmt, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
666 octave_idx_type, octave_idx_type j) const |
24745
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
667 { |
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
668 std::ostringstream buf; |
28634
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28631
diff
changeset
|
669 octave_print_internal (buf, fmt, m_range.elem (j)); |
24745
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
670 return buf.str (); |
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
671 } |
d2467914ce33
enable (or improve) display for more types in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
672 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
673 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
674 bool |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
675 xsave_ascii (std::ostream& os, const octave::range<T>& r, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
676 const bool with_reverse) |
4687 | 677 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
678 T base = r.base (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
679 T limit = r.limit (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
680 T inc = r.increment (); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
681 bool rev = r.reverse (); |
20228
00cf2847355d
Deprecate Array::nelem() and Range::nelem() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20163
diff
changeset
|
682 octave_idx_type len = r.numel (); |
4687 | 683 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
684 if (inc != T (0)) |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
685 os << "# base, limit, increment"; |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
686 else |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
687 os << "# base, length, increment"; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
688 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
689 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
690 os << ", reverse\n"; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
691 else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
692 os << "\n"; |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
693 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
694 octave::write_value<T> (os, base); |
23807
336f89b6208b
Use character literals 'c' rather than string literals "c" when possible.
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
695 os << ' '; |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
696 if (inc != T (0)) |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
697 octave::write_value<T> (os, limit); |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
698 else |
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
699 os << len; |
23807
336f89b6208b
Use character literals 'c' rather than string literals "c" when possible.
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
700 os << ' '; |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
701 octave::write_value<T> (os, inc); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
702 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
703 os << ' ' << rev; |
4687 | 704 os << "\n"; |
705 | |
706 return true; | |
707 } | |
708 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
709 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
710 bool |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
711 ov_range<T>::save_ascii (std::ostream& os) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
712 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
713 return xsave_ascii (os, m_range, false); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
714 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
715 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
716 // specialize for saving with "reverse" flag |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
717 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
718 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
719 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
720 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
721 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
722 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
723 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
724 ov_range<octave_uint8>::save_ascii (std::ostream& os) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
725 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
726 return xsave_ascii (os, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
727 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
728 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
729 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
730 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
731 ov_range<octave_uint16>::save_ascii (std::ostream& os) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
732 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
733 return xsave_ascii (os, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
734 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
735 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
736 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
737 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
738 ov_range<octave_uint32>::save_ascii (std::ostream& os) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
739 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
740 return xsave_ascii (os, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
741 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
742 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
743 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
744 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
745 ov_range<octave_uint64>::save_ascii (std::ostream& os) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
746 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
747 return xsave_ascii (os, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
748 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
749 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
750 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
751 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
752 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
753 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
754 xload_ascii (std::istream& is, octave::range<T>& r, const bool with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
755 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
756 // # base, limit, range comment added by save (). |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
757 skip_comments (is); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
758 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
759 T base, limit, inc; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
760 bool rev = false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
761 is >> base >> limit >> inc; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
762 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
763 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
764 is >> rev; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
765 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
766 if (! is) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
767 error ("load: failed to load range constant"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
768 |
30853
fc3bd70cd1be
eliminate range<T>::make_constant function
John W. Eaton <jwe@octave.org>
parents:
30852
diff
changeset
|
769 r = octave::range<T> (base, inc, limit, rev); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
770 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
771 return true; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
772 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
773 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
774 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
775 bool |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
776 ov_range<T>::load_ascii (std::istream& is) |
4687 | 777 { |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
778 return xload_ascii (is, m_range, false); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
779 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
780 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
781 // specialize for loading with "reverse" flag |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
782 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
783 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
784 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
785 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
786 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
787 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
788 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
789 ov_range<octave_uint8>::load_ascii (std::istream& is) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
790 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
791 return xload_ascii (is, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
792 } |
4687 | 793 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
794 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
795 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
796 ov_range<octave_uint16>::load_ascii (std::istream& is) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
797 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
798 return xload_ascii (is, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
799 } |
4687 | 800 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
801 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
802 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
803 ov_range<octave_uint32>::load_ascii (std::istream& is) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
804 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
805 return xload_ascii (is, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
806 } |
4687 | 807 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
808 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
809 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
810 ov_range<octave_uint64>::load_ascii (std::istream& is) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
811 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
812 return xload_ascii (is, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
813 } |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
814 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
815 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
816 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
817 /* |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
818 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
819 %! a = b = 1:4; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
820 %! sv_file = [tempname(), ".sav"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
821 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
822 %! save (sv_file, "a", "-text"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
823 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
824 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
825 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
826 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
827 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
828 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
829 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
830 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
831 %! a = b = uint8(5):-1:0; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
832 %! sv_file = [tempname(), ".sav"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
833 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
834 %! save (sv_file, "a", "-text"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
835 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
836 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
837 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
838 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
839 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
840 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
841 */ |
4687 | 842 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
843 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
844 bool |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
845 xsave_binary (std::ostream& os, bool /* save_as_floats */, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
846 const octave::range<T>& r, const bool with_reverse) |
4687 | 847 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
848 // FIXME: Not always double! |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
849 |
5760 | 850 char tmp = LS_DOUBLE; |
851 os.write (reinterpret_cast<char *> (&tmp), 1); | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
852 T bas = r.base (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
853 T lim = r.limit (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
854 T inc = r.increment (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
855 if (inc == T (0)) |
20228
00cf2847355d
Deprecate Array::nelem() and Range::nelem() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20163
diff
changeset
|
856 lim = r.numel (); |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
857 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
858 os.write (reinterpret_cast<char *> (&bas), sizeof (T)); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
859 os.write (reinterpret_cast<char *> (&lim), sizeof (T)); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
860 os.write (reinterpret_cast<char *> (&inc), sizeof (T)); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
861 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
862 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
863 bool rev = r.reverse (); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
864 os.write (reinterpret_cast<char *> (&rev), sizeof (bool)); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
865 } |
4687 | 866 |
867 return true; | |
868 } | |
869 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
870 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
871 bool |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
872 ov_range<T>::save_binary (std::ostream& os, bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
873 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
874 return xsave_binary (os, save_as_floats, m_range, false); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
875 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
876 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
877 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
878 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
879 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
880 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
881 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
882 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
883 ov_range<octave_uint8>::save_binary (std::ostream& os, bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
884 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
885 return xsave_binary (os, save_as_floats, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
886 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
887 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
888 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
889 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
890 ov_range<octave_uint16>::save_binary (std::ostream& os, bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
891 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
892 return xsave_binary (os, save_as_floats, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
893 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
894 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
895 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
896 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
897 ov_range<octave_uint32>::save_binary (std::ostream& os, bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
898 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
899 return xsave_binary (os, save_as_floats, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
900 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
901 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
902 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
903 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
904 ov_range<octave_uint64>::save_binary (std::ostream& os, bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
905 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
906 return xsave_binary (os, save_as_floats, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
907 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
908 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
909 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
910 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
911 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
912 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
913 xload_binary (std::istream& is, bool swap, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
914 octave::mach_info::float_format /* fmt */, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
915 octave::range<T>& r, const bool with_reverse) |
4687 | 916 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
917 // FIXME: Not always double! |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
918 |
4687 | 919 char tmp; |
5760 | 920 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
4687 | 921 return false; |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
922 T bas, lim, inc; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
923 if (! is.read (reinterpret_cast<char *> (&bas), sizeof (T))) |
4687 | 924 return false; |
925 if (swap) | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
926 swap_bytes<sizeof (T)> (&bas); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
927 if (! is.read (reinterpret_cast<char *> (&lim), sizeof (T))) |
4687 | 928 return false; |
929 if (swap) | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
930 swap_bytes<sizeof (T)> (&lim); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
931 if (! is.read (reinterpret_cast<char *> (&inc), sizeof (T))) |
4687 | 932 return false; |
933 if (swap) | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
934 swap_bytes<sizeof (T)> (&inc); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
935 bool rev = false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
936 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
937 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
938 if (! is.read (reinterpret_cast<char *> (&rev), sizeof (bool))) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
939 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
940 if (swap) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
941 swap_bytes<sizeof (bool)> (&rev); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
942 } |
30853
fc3bd70cd1be
eliminate range<T>::make_constant function
John W. Eaton <jwe@octave.org>
parents:
30852
diff
changeset
|
943 |
fc3bd70cd1be
eliminate range<T>::make_constant function
John W. Eaton <jwe@octave.org>
parents:
30852
diff
changeset
|
944 r = octave::range<T> (bas, inc, lim, rev); |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
945 |
4687 | 946 return true; |
947 } | |
948 | |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
949 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
950 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
951 ov_range<T>::load_binary (std::istream& is, bool swap, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
952 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
953 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
954 return xload_binary (is, swap, fmt, m_range, false); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
955 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
956 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
957 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
958 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
959 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
960 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
961 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
962 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
963 ov_range<octave_uint8>::load_binary (std::istream& is, bool swap, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
964 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
965 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
966 return xload_binary (is, swap, fmt, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
967 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
968 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
969 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
970 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
971 ov_range<octave_uint16>::load_binary (std::istream& is, bool swap, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
972 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
973 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
974 return xload_binary (is, swap, fmt, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
975 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
976 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
977 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
978 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
979 ov_range<octave_uint32>::load_binary (std::istream& is, bool swap, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
980 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
981 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
982 return xload_binary (is, swap, fmt, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
983 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
984 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
985 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
986 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
987 ov_range<octave_uint64>::load_binary (std::istream& is, bool swap, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
988 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
989 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
990 return xload_binary (is, swap, fmt, m_range, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
991 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
992 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
993 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
994 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
995 /* |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
996 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
997 %! a = b = 1:4; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
998 %! sv_file = [tempname(), ".dat"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
999 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1000 %! save (sv_file, "a", "-binary"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1001 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1002 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1003 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1004 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1005 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1006 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1007 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1008 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1009 %! a = b = uint8(5):-1:0; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1010 %! sv_file = [tempname(), ".dat"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1011 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1012 %! save (sv_file, "a", "-binary"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1013 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1014 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1015 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1016 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1017 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1018 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1019 */ |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1020 |
4687 | 1021 #if defined (HAVE_HDF5) |
4944 | 1022 |
4687 | 1023 // The following subroutines creates an HDF5 representation of the way |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1024 // we will store Octave range types (triplets of floating-point numbers). |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1025 // NUM_TYPE is the HDF5 numeric type to use for storage (e.g. |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21739
diff
changeset
|
1026 // H5T_NATIVE_DOUBLE to save as 'double'). Note that any necessary |
4687 | 1027 // conversions are handled automatically by HDF5. |
1028 | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1029 template <typename T> |
4687 | 1030 static hid_t |
1031 hdf5_make_range_type (hid_t num_type) | |
1032 { | |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1033 hid_t type_id = H5Tcreate (H5T_COMPOUND, sizeof (T) * 3); |
4687 | 1034 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1035 H5Tinsert (type_id, "base", 0 * sizeof (T), num_type); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1036 H5Tinsert (type_id, "limit", 1 * sizeof (T), num_type); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1037 H5Tinsert (type_id, "increment", 2 * sizeof (T), num_type); |
4687 | 1038 |
1039 return type_id; | |
1040 } | |
1041 | |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1042 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1043 static hid_t |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1044 hdf5_make_range_rev_type (hid_t num_type) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1045 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1046 hid_t type_id = H5Tcreate (H5T_COMPOUND, sizeof (T) * 4); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1047 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1048 H5Tinsert (type_id, "base", 0 * sizeof (T), num_type); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1049 H5Tinsert (type_id, "limit", 1 * sizeof (T), num_type); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1050 H5Tinsert (type_id, "increment", 2 * sizeof (T), num_type); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1051 // FIXME: Storing "reverse" with the same width is inefficient. |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1052 H5Tinsert (type_id, "reverse", 3 * sizeof (T), num_type); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1053 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1054 return type_id; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1055 } |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1056 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1057 template <typename T> |
4687 | 1058 bool |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1059 xsave_hdf5 (octave_hdf5_id loc_id, const char *name, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1060 bool /* save_as_floats */, const octave::range<T>& r, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1061 const octave_hdf5_id h5_save_type, const bool with_reverse) |
4687 | 1062 { |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1063 bool retval = false; |
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1064 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1065 hsize_t dimens[3] = {0}; |
18100
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
17870
diff
changeset
|
1066 hid_t space_hid, type_hid, data_hid; |
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
17870
diff
changeset
|
1067 space_hid = type_hid = data_hid = -1; |
4687 | 1068 |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
1069 space_hid = H5Screate_simple (0, dimens, nullptr); |
4687 | 1070 if (space_hid < 0) return false; |
1071 | |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1072 type_hid = with_reverse |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1073 ? hdf5_make_range_rev_type<T> (h5_save_type) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1074 : hdf5_make_range_type<T> (h5_save_type); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1075 if (type_hid < 0) |
4687 | 1076 { |
1077 H5Sclose (space_hid); | |
1078 return false; | |
1079 } | |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1080 # if defined (HAVE_HDF5_18) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1081 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, |
21022
ebc439187d29
avoid old-style cast warnings from HDF5 macros used in C++ sources
John W. Eaton <jwe@octave.org>
parents:
20988
diff
changeset
|
1082 octave_H5P_DEFAULT, octave_H5P_DEFAULT, octave_H5P_DEFAULT); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1083 # else |
21022
ebc439187d29
avoid old-style cast warnings from HDF5 macros used in C++ sources
John W. Eaton <jwe@octave.org>
parents:
20988
diff
changeset
|
1084 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, octave_H5P_DEFAULT); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1085 # endif |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1086 if (data_hid < 0) |
4687 | 1087 { |
1088 H5Sclose (space_hid); | |
1089 H5Tclose (type_hid); | |
1090 return false; | |
1091 } | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1092 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1093 T range_vals[4]; |
4687 | 1094 range_vals[0] = r.base (); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1095 if (r.increment () != T (0)) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1096 range_vals[1] = r.limit (); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1097 else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1098 range_vals[1] = r.numel (); |
28636
a3db48e66ef8
use Range::increment instead of Range::inc
John W. Eaton <jwe@octave.org>
parents:
28634
diff
changeset
|
1099 range_vals[2] = r.increment (); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1100 range_vals[3] = r.reverse (); |
4687 | 1101 |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1102 if (H5Dwrite (data_hid, type_hid, octave_H5S_ALL, octave_H5S_ALL, |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1103 octave_H5P_DEFAULT, range_vals) |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1104 >= 0) |
11176
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1105 { |
20228
00cf2847355d
Deprecate Array::nelem() and Range::nelem() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20163
diff
changeset
|
1106 octave_idx_type nel = r.numel (); |
11176
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1107 retval = hdf5_add_scalar_attr (data_hid, H5T_NATIVE_IDX, |
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1108 "OCTAVE_RANGE_NELEM", &nel) >= 0; |
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1109 } |
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1110 else |
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1111 retval = false; |
4687 | 1112 |
1113 H5Dclose (data_hid); | |
1114 H5Tclose (type_hid); | |
1115 H5Sclose (space_hid); | |
4837 | 1116 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1117 return retval; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1118 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1119 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1120 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1121 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1122 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1123 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1124 ov_range<T>::save_hdf5 (octave_hdf5_id loc_id, const char *name, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1125 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1126 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1127 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1128 return xsave_hdf5 (loc_id, name, save_as_floats, m_range, hdf5_save_type, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1129 false); |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1130 #else |
21691
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1131 octave_unused_parameter (loc_id); |
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1132 octave_unused_parameter (name); |
30437
e3df47a19871
ov-range.cc: Silence compiler warning about unused parameter.
Markus Mützel <markus.muetzel@gmx.de>
parents:
30416
diff
changeset
|
1133 octave_unused_parameter (save_as_floats); |
21691
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1134 |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1135 warn_save ("hdf5"); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1136 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1137 return false; |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1138 #endif |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1139 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1140 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1141 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1142 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1143 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1144 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1145 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1146 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1147 ov_range<octave_uint8>::save_hdf5 (octave_hdf5_id loc_id, const char *name, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1148 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1149 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1150 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1151 return xsave_hdf5 (loc_id, name, save_as_floats, m_range, hdf5_save_type, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1152 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1153 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1154 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1155 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1156 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1157 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1158 warn_save ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1159 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1160 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1161 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1162 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1163 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1164 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1165 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1166 ov_range<octave_uint16>::save_hdf5 (octave_hdf5_id loc_id, const char *name, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1167 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1168 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1169 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1170 return xsave_hdf5 (loc_id, name, save_as_floats, m_range, hdf5_save_type, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1171 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1172 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1173 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1174 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1175 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1176 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1177 warn_save ("hdf5"); |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1178 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1179 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1180 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1181 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1182 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1183 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1184 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1185 ov_range<octave_uint32>::save_hdf5 (octave_hdf5_id loc_id, const char *name, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1186 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1187 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1188 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1189 return xsave_hdf5 (loc_id, name, save_as_floats, m_range, hdf5_save_type, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1190 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1191 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1192 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1193 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1194 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1195 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1196 warn_save ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1197 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1198 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1199 #endif |
4687 | 1200 } |
1201 | |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1202 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1203 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1204 ov_range<octave_uint64>::save_hdf5 (octave_hdf5_id loc_id, const char *name, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1205 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1206 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1207 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1208 return xsave_hdf5 (loc_id, name, save_as_floats, m_range, hdf5_save_type, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1209 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1210 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1211 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1212 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1213 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1214 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1215 warn_save ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1216 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1217 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1218 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1219 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1220 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1221 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1222 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1223 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1224 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1225 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1226 bool |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1227 xload_hdf5 (octave_hdf5_id loc_id, const char *name, octave::range<T>& r, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1228 const octave_hdf5_id h5_save_type, const bool with_reverse) |
4687 | 1229 { |
1230 bool retval = false; | |
4837 | 1231 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1232 # if defined (HAVE_HDF5_18) |
21022
ebc439187d29
avoid old-style cast warnings from HDF5 macros used in C++ sources
John W. Eaton <jwe@octave.org>
parents:
20988
diff
changeset
|
1233 hid_t data_hid = H5Dopen (loc_id, name, octave_H5P_DEFAULT); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1234 # else |
4687 | 1235 hid_t data_hid = H5Dopen (loc_id, name); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1236 # endif |
4687 | 1237 hid_t type_hid = H5Dget_type (data_hid); |
1238 | |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1239 hid_t range_type = with_reverse |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1240 ? hdf5_make_range_rev_type<T> (h5_save_type) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1241 : hdf5_make_range_type<T> (h5_save_type); |
4687 | 1242 |
1243 if (! hdf5_types_compatible (type_hid, range_type)) | |
1244 { | |
4837 | 1245 H5Tclose (range_type); |
4687 | 1246 H5Dclose (data_hid); |
1247 return false; | |
1248 } | |
1249 | |
1250 hid_t space_hid = H5Dget_space (data_hid); | |
1251 hsize_t rank = H5Sget_simple_extent_ndims (space_hid); | |
1252 | |
1253 if (rank != 0) | |
1254 { | |
4837 | 1255 H5Tclose (range_type); |
4687 | 1256 H5Sclose (space_hid); |
1257 H5Dclose (data_hid); | |
1258 return false; | |
1259 } | |
1260 | |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1261 T rangevals[4]; |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1262 if (H5Dread (data_hid, range_type, octave_H5S_ALL, octave_H5S_ALL, |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1263 octave_H5P_DEFAULT, rangevals) |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1264 >= 0) |
4687 | 1265 { |
1266 retval = true; | |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
1267 |
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
1268 // Don't use OCTAVE_RANGE_NELEM attribute, just reconstruct the range. |
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
1269 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1270 bool rev = with_reverse ? static_cast<bool> (rangevals[3]) : false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1271 |
30853
fc3bd70cd1be
eliminate range<T>::make_constant function
John W. Eaton <jwe@octave.org>
parents:
30852
diff
changeset
|
1272 r = octave::range<T> (rangevals[0], rangevals[2], rangevals[1], rev); |
4687 | 1273 } |
1274 | |
4837 | 1275 H5Tclose (range_type); |
4687 | 1276 H5Sclose (space_hid); |
1277 H5Dclose (data_hid); | |
4837 | 1278 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1279 return retval; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1280 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1281 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1282 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1283 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1284 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1285 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1286 ov_range<T>::load_hdf5 (octave_hdf5_id loc_id, const char *name) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1287 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1288 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1289 return xload_hdf5 (loc_id, name, m_range, hdf5_save_type, false); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1290 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1291 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1292 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1293 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1294 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1295 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1296 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1297 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1298 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1299 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1300 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1301 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1302 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1303 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1304 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1305 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1306 ov_range<octave_uint8>::load_hdf5 (octave_hdf5_id loc_id, const char *name) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1307 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1308 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1309 return xload_hdf5 (loc_id, name, m_range, hdf5_save_type, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1310 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1311 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1312 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1313 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1314 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1315 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1316 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1317 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1318 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1319 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1320 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1321 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1322 ov_range<octave_uint16>::load_hdf5 (octave_hdf5_id loc_id, const char *name) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1323 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1324 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1325 return xload_hdf5 (loc_id, name, m_range, hdf5_save_type, true); |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1326 #else |
21691
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1327 octave_unused_parameter (loc_id); |
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1328 octave_unused_parameter (name); |
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1329 |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1330 warn_load ("hdf5"); |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1331 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1332 return false; |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1333 #endif |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1334 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1335 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1336 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1337 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1338 ov_range<octave_uint32>::load_hdf5 (octave_hdf5_id loc_id, const char *name) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1339 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1340 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1341 return xload_hdf5 (loc_id, name, m_range, hdf5_save_type, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1342 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1343 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1344 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1345 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1346 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1347 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1348 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1349 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1350 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1351 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1352 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1353 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1354 ov_range<octave_uint64>::load_hdf5 (octave_hdf5_id loc_id, const char *name) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1355 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1356 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1357 return xload_hdf5 (loc_id, name, m_range, hdf5_save_type, true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1358 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1359 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1360 octave_unused_parameter (name); |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19861
diff
changeset
|
1361 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1362 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1363 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1364 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1365 #endif |
4687 | 1366 } |
4944 | 1367 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1368 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1369 |
30416
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1370 /* |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1371 %!testif HAVE_HDF5 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1372 %! a = b = 1:4; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1373 %! sv_file = [tempname(), ".h5"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1374 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1375 %! save (sv_file, "a", "-hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1376 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1377 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1378 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1379 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1380 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1381 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1382 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1383 %!testif HAVE_HDF5 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1384 %! a = b = uint8(5):-1:0; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1385 %! sv_file = [tempname(), ".h5"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1386 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1387 %! save (sv_file, "a", "-hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1388 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1389 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1390 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1391 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1392 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1393 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1394 */ |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30390
diff
changeset
|
1395 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1396 template <typename T> |
5900 | 1397 mxArray * |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1398 ov_range<T>::as_mxArray (bool interleaved) const |
5900 | 1399 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1400 mxClassID mx_class = mx_type_traits<T>::mx_class; |
5900 | 1401 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1402 mxArray *retval = new mxArray (interleaved, mx_class, dims (), mxREAL); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1403 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1404 typedef typename mx_type_traits<T>::mx_type mx_type; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1405 mx_type *pd = static_cast<mx_type *> (retval->get_data ()); |
5900 | 1406 |
6686 | 1407 mwSize nel = numel (); |
5900 | 1408 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1409 Array<T> matrix = raw_array_value (); |
5900 | 1410 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1411 const T *pdata = matrix.data (); |
5900 | 1412 |
6686 | 1413 for (mwSize i = 0; i < nel; i++) |
28126
4c21f99b4ad5
handle interleaved complex data and new typed data access functions for mex
John W. Eaton <jwe@octave.org>
parents:
27923
diff
changeset
|
1414 pd[i] = pdata[i]; |
5900 | 1415 |
1416 return retval; | |
1417 } | |
10613
e103fb2182ce
use internal variable instead of warning state to control whether to allow non-integer ranges as indices
John W. Eaton <jwe@octave.org>
parents:
10609
diff
changeset
|
1418 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1419 template <typename T> |
18650
491b0adfec95
compatibility fixes for printf integer format specifiers
John W. Eaton <jwe@octave.org>
parents:
18416
diff
changeset
|
1420 octave_value |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1421 ov_range<T>::fast_elem_extract (octave_idx_type n) const |
18650
491b0adfec95
compatibility fixes for printf integer format specifiers
John W. Eaton <jwe@octave.org>
parents:
18416
diff
changeset
|
1422 { |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
1423 return (n < numel () ? octave_value (m_range.elem (n)) : octave_value ()); |
18650
491b0adfec95
compatibility fixes for printf integer format specifiers
John W. Eaton <jwe@octave.org>
parents:
18416
diff
changeset
|
1424 } |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1425 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1426 // Specializations. |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1427 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1428 template <> |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1429 octave::range<double> |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1430 ov_range<double>::range_value (void) const |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1431 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1432 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1433 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1434 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1435 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1436 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1437 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1438 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1439 template <> |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1440 octave::range<float> |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1441 ov_range<float>::float_range_value (void) const |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1442 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1443 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1444 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1445 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1446 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1447 octave::range<octave_int8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1448 ov_range<octave_int8>::int8_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1449 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1450 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1451 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1452 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1453 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1454 octave::range<octave_int16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1455 ov_range<octave_int16>::int16_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1456 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1457 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1458 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1459 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1460 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1461 octave::range<octave_int32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1462 ov_range<octave_int32>::int32_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1463 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1464 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1465 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1466 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1467 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1468 octave::range<octave_int64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1469 ov_range<octave_int64>::int64_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1470 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1471 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1472 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1473 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1474 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1475 octave::range<octave_uint8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1476 ov_range<octave_uint8>::uint8_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1477 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1478 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1479 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1480 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1481 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1482 octave::range<octave_uint16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1483 ov_range<octave_uint16>::uint16_range_value (void) const |
18650
491b0adfec95
compatibility fixes for printf integer format specifiers
John W. Eaton <jwe@octave.org>
parents:
18416
diff
changeset
|
1484 { |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1485 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1486 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1487 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1488 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1489 octave::range<octave_uint32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1490 ov_range<octave_uint32>::uint32_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1491 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1492 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1493 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1494 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1495 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1496 octave::range<octave_uint64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1497 ov_range<octave_uint64>::uint64_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1498 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1499 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1500 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1501 |
30835
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1502 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30564
diff
changeset
|
1503 |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1504 template <> |
29569
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29394
diff
changeset
|
1505 octave::idx_vector |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1506 ov_range<double>::index_vector (bool require_integers) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1507 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1508 if (m_idx_cache) |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1509 return *m_idx_cache; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1510 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1511 if (require_integers || m_range.all_elements_are_ints ()) |
29569
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29394
diff
changeset
|
1512 return set_idx_cache (octave::idx_vector (m_range)); |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1513 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1514 warning_with_id ("Octave:noninteger-range-as-index", |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1515 "non-integer range used as index"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1516 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1517 return octave_value (matrix_value ()).round ().index_vector (); |
18650
491b0adfec95
compatibility fixes for printf integer format specifiers
John W. Eaton <jwe@octave.org>
parents:
18416
diff
changeset
|
1518 } |
28646
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1519 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1520 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1521 octave_idx_type |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1522 ov_range<double>::nnz (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1523 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1524 return m_range.nnz (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1525 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1526 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1527 // The following specialization is also historical baggage. For double |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1528 // ranges, we can produce special double-valued diagnoal matrix objects |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1529 // but Octave currently provides only double and Complex diagonal matrix |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1530 // objects. |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1531 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1532 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1533 octave_value |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1534 ov_range<double>::diag (octave_idx_type k) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1535 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1536 // FIXME: this is a potential waste of memory. |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1537 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1538 return |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1539 (k == 0 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1540 ? octave_value (DiagMatrix (DiagArray2<double> (matrix_value ()))) |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1541 : octave_value (m_range.diag (k))); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1542 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1543 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1544 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1545 octave_value |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1546 ov_range<double>::diag (octave_idx_type nr, octave_idx_type nc) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1547 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1548 Matrix mat = matrix_value (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1549 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1550 return mat.diag (nr, nc); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1551 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1552 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1553 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1554 void |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1555 ov_range<double>::print_raw (std::ostream& os, bool pr_as_read_syntax) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1556 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1557 octave_print_internal (os, m_range, pr_as_read_syntax, |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1558 current_print_indent_level ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28638
diff
changeset
|
1559 } |