Mercurial > jwe > octave
annotate libinterp/octave-value/ov-range.cc @ 30841:97504d2edcc7
maint: Merge stable to default.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Thu, 17 Mar 2022 02:52:53 -0400 |
parents | 83f9f8bda883 2989202f92f8 |
children | eba0a86471b9 |
rev | line source |
---|---|
27928
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
1 //////////////////////////////////////////////////////////////////////// |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
2 // |
30569
796f54d4ddbf
update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents:
30442
diff
changeset
|
3 // Copyright (C) 1996-2022 The Octave Project Developers |
27928
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
4 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
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:
27924
diff
changeset
|
6 // distribution or <https://octave.org/copyright/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
7 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
8 // This file is part of Octave. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
9 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
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:
27924
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:
27924
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:
27924
diff
changeset
|
13 // (at your option) any later version. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
14 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
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:
27924
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:
27924
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:
27924
diff
changeset
|
18 // GNU General Public License for more details. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
19 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
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:
27924
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:
27924
diff
changeset
|
22 // <https://www.gnu.org/licenses/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
23 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27924
diff
changeset
|
24 //////////////////////////////////////////////////////////////////////// |
2376 | 25 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
27 # include "config.h" |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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" |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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" |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
69 template <> |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
71 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
73 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
74 # if 0 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
75 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
76 template <> |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
77 octave_hdf5_id ov_range<float>::hdf5_save_type = H5T_NATIVE_FLOAT; |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
78 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
79 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
81 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
82 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
84 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
85 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
87 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
88 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
90 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
91 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
93 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
94 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
96 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
97 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
99 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
100 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
102 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
103 # endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
104 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
105 #else |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
106 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
107 template <> |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
109 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
111 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
112 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
113 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
114 template <> |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
116 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
117 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
119 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
120 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
122 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
123 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
124 octave_hdf5_id ov_range<octave_int32>::hdf5_save_type = 0; |
2376 | 125 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
126 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
128 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
129 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
131 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
132 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
134 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
135 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
137 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
138 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
140 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
141 # endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
142 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
143 #endif |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
144 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
145 DEFINE_TEMPLATE_OV_TYPEID_FUNCTIONS_AND_DATA (ov_range<double>, |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
146 "range", "double"); |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
147 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
149 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
150 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
151 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
153 "float_range", "single"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
154 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
156 "int8_range", "int8"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
157 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
159 "int16_range", "int16"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
160 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
162 "int32_range", "int32"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
163 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
165 "int64_range", "int64"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
166 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
168 "uint8_range", "uint8"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
169 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
171 "uint16_range", "uint16"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
172 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
174 "uint32_range", "uint32"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
175 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
177 "uint64_range", "uint64"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
178 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
179 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
180 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
181 template <typename T> |
5759 | 182 static octave_base_value * |
183 default_numeric_conversion_function (const octave_base_value& a) | |
2376 | 184 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
185 typedef typename octave_value_range_traits<T>::matrix_type ov_mx_type; |
2376 | 186 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
188 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
189 return new ov_mx_type (v.raw_array_value ()); |
2376 | 190 } |
191 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
194 ov_range<T>::numeric_conversion_function (void) const |
2376 | 195 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
197 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
199 (default_numeric_conversion_function<T>, ov_mx_type::static_type_id ()); |
2376 | 200 } |
201 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
202 template <typename T> |
5759 | 203 octave_base_value * |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
208 switch (numel ()) |
2410 | 209 { |
210 case 1: | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
211 retval = new typename octave_value_range_traits<T>::scalar_type (m_range.elem (0)); |
2410 | 212 break; |
213 | |
214 case 0: | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
215 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
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:
28643
diff
changeset
|
218 retval = new ov_mx_type (m); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
219 } |
2410 | 220 break; |
221 | |
8971 | 222 case -2: |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
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:
28643
diff
changeset
|
225 // is the invalid numel value preserved? |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
236 template <typename T> |
2436 | 237 octave_value |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
264 template <typename T> |
3933 | 265 octave_value |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
266 ov_range<T>::do_index_op (const octave_value_list& idx, |
30395
a61e1a0f6024
maint: style check C++ files in libinterp/ ahead of 7.1 release.
Rik <rik@octave.org>
parents:
30011
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 { |
29574
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29399
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 |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
279 if (i.is_scalar () && i(0) < numel ()) |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
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 |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
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 } |
29168
8f67ad8b3103
maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents:
28651
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 |
29168
8f67ad8b3103
maint: Updating naming conventions for exceptions and use const where possible.
Rik <rik@octave.org>
parents:
28651
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
296 octave_value tmp (new typename octave_value_range_traits<T>::matrix_type (raw_array_value ())); |
2436 | 297 |
28636
70cdf8de553d
move non-member octave_value operator functions to octave namespace
John W. Eaton <jwe@octave.org>
parents:
28633
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
302 template <typename T> |
29574
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29399
diff
changeset
|
303 octave::idx_vector |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
306 octave_value tmp (raw_array_value ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
310 template <typename T> |
2376 | 311 double |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
312 ov_range<T>::double_value (bool) const |
2376 | 313 { |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
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 |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
322 return m_range.base (); |
2376 | 323 } |
324 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
340 template <typename T> |
9146
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
341 charNDArray |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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++) |
25691
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
355 template <typename T> |
2376 | 356 Complex |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
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 |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
367 return Complex (m_range.base (), 0); |
2376 | 368 } |
369 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
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 |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
29942
da7210e30f3e
move some utility functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29574
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
415 template <typename T> |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
416 octave::range<double> |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
418 { |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
420 } |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
421 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
423 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
424 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
425 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
426 template <typename T> |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
427 octave::range<float> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
429 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
431 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
432 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
433 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
434 octave::range<octave_int8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
436 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
438 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
439 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
440 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
441 octave::range<octave_int16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
443 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
445 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
446 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
447 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
448 octave::range<octave_int32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
450 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
452 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
453 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
454 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
455 octave::range<octave_int64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
457 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
459 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
460 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
461 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
462 octave::range<octave_uint8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
464 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
466 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
467 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
468 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
469 octave::range<octave_uint16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
471 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
473 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
474 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
475 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
476 octave::range<octave_uint32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
478 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
480 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
481 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
482 template <typename T> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
483 octave::range<octave_uint64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
485 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
487 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
488 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
489 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
490 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
491 template <typename T> |
2376 | 492 octave_value |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
493 ov_range<T>::convert_to_str_internal (bool pad, bool force, char type) const |
2449 | 494 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
495 octave_value tmp (raw_array_value ()); |
5279 | 496 return tmp.convert_to_str (pad, force, type); |
2449 | 497 } |
498 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
500 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
571 template <typename T> |
2376 | 572 void |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
579 template <typename T> |
2901 | 580 void |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
581 ov_range<T>::print_raw (std::ostream& os, bool pr_as_read_syntax) const |
2901 | 582 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
diff
changeset
|
584 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
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:
28643
diff
changeset
|
587 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
592 template <typename T> |
2901 | 593 bool |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 | |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
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 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
617 template <typename T> |
17870 | 618 void |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
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 { |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
631 if (m_range.increment () != T (1)) |
28641
a3db48e66ef8
use Range::increment instead of Range::inc
John W. Eaton <jwe@octave.org>
parents:
28639
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 |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
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 | |
30011
75dff8f2de2e
move some load-save utilities to octave namespace
John W. Eaton <jwe@octave.org>
parents:
29942
diff
changeset
|
653 octave::skip_until_newline (is, false); |
4687 | 654 } |
655 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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:
28643
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; |
28639
e057dbd3c108
use m_ prefix for octave_range member variables
John W. Eaton <jwe@octave.org>
parents:
28636
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
676 const bool with_reverse) |
4687 | 677 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
678 T base = r.base (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
679 T limit = r.limit (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
680 T inc = r.increment (); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
684 if (inc != T (0)) |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
688 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
689 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
690 os << ", reverse\n"; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
691 else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 << ' '; |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
696 if (inc != T (0)) |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 << ' '; |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
701 octave::write_value<T> (os, inc); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
702 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
703 os << ' ' << rev; |
4687 | 704 os << "\n"; |
705 | |
706 return true; | |
707 } | |
708 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
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 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
712 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
714 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
715 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
717 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
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:
30569
diff
changeset
|
719 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
720 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
721 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
722 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
723 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
725 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
727 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
728 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
729 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
730 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
732 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
734 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
735 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
736 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
737 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
739 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
741 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
742 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
743 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
744 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
746 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
748 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
749 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
750 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
751 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
752 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
753 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
755 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
757 skip_comments (is); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
758 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
760 bool rev = false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
762 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
763 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
764 is >> rev; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
765 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
766 if (! is) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
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:
30395
diff
changeset
|
768 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
769 if (inc != T (0)) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
770 r = octave::range<T> (base, inc, limit, rev); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
771 else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
772 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
773 octave_idx_type numel = static_cast<octave_idx_type> (limit); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
774 r = octave::range<T>::make_constant (base, numel, rev); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
775 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
776 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
777 return true; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
778 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
779 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
780 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
781 bool |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
782 ov_range<T>::load_ascii (std::istream& is) |
4687 | 783 { |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
784 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:
30395
diff
changeset
|
785 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
786 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
787 // specialize for loading with "reverse" flag |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
788 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
789 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
790 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
791 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
792 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
793 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
794 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
795 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:
30395
diff
changeset
|
796 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
797 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:
30395
diff
changeset
|
798 } |
4687 | 799 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
800 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
801 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
802 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:
30395
diff
changeset
|
803 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
804 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:
30395
diff
changeset
|
805 } |
4687 | 806 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
807 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
808 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
809 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:
30395
diff
changeset
|
810 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
811 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:
30395
diff
changeset
|
812 } |
4687 | 813 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
814 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
815 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
816 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:
30395
diff
changeset
|
817 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
818 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:
30395
diff
changeset
|
819 } |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
820 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
821 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
822 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
823 /* |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
824 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
825 %! a = b = 1:4; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
826 %! sv_file = [tempname(), ".sav"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
827 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
828 %! save (sv_file, "a", "-text"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
829 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
830 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
831 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
832 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
833 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
834 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
835 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
836 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
837 %! a = b = uint8(5):-1:0; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
838 %! sv_file = [tempname(), ".sav"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
839 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
840 %! save (sv_file, "a", "-text"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
841 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
842 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
843 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
844 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
845 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
846 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
847 */ |
4687 | 848 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
849 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
850 bool |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
851 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:
30395
diff
changeset
|
852 const octave::range<T>& r, const bool with_reverse) |
4687 | 853 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
854 // FIXME: Not always double! |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
855 |
5760 | 856 char tmp = LS_DOUBLE; |
857 os.write (reinterpret_cast<char *> (&tmp), 1); | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
858 T bas = r.base (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
859 T lim = r.limit (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
860 T inc = r.increment (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
861 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
|
862 lim = r.numel (); |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
863 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
864 os.write (reinterpret_cast<char *> (&bas), sizeof (T)); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
865 os.write (reinterpret_cast<char *> (&lim), sizeof (T)); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
866 os.write (reinterpret_cast<char *> (&inc), sizeof (T)); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
867 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
868 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
869 bool rev = r.reverse (); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
870 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:
30395
diff
changeset
|
871 } |
4687 | 872 |
873 return true; | |
874 } | |
875 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
876 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
877 bool |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
878 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:
30395
diff
changeset
|
879 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
880 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:
30395
diff
changeset
|
881 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
882 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
883 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
884 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
885 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
886 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
887 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
888 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
889 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:
30395
diff
changeset
|
890 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
891 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:
30395
diff
changeset
|
892 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
893 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
894 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
895 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
896 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:
30395
diff
changeset
|
897 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
898 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:
30395
diff
changeset
|
899 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
900 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
901 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
902 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
903 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:
30395
diff
changeset
|
904 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
905 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:
30395
diff
changeset
|
906 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
907 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
908 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
909 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
910 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:
30395
diff
changeset
|
911 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
912 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:
30395
diff
changeset
|
913 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
914 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
915 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
916 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
917 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
918 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
919 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:
30395
diff
changeset
|
920 octave::mach_info::float_format /* fmt */, |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
921 octave::range<T>& r, const bool with_reverse) |
4687 | 922 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
923 // FIXME: Not always double! |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
924 |
4687 | 925 char tmp; |
5760 | 926 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
4687 | 927 return false; |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
928 T bas, lim, inc; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
929 if (! is.read (reinterpret_cast<char *> (&bas), sizeof (T))) |
4687 | 930 return false; |
931 if (swap) | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
932 swap_bytes<sizeof (T)> (&bas); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
933 if (! is.read (reinterpret_cast<char *> (&lim), sizeof (T))) |
4687 | 934 return false; |
935 if (swap) | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
936 swap_bytes<sizeof (T)> (&lim); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
937 if (! is.read (reinterpret_cast<char *> (&inc), sizeof (T))) |
4687 | 938 return false; |
939 if (swap) | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
940 swap_bytes<sizeof (T)> (&inc); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
941 bool rev = false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
942 if (with_reverse) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
943 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
944 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:
30395
diff
changeset
|
945 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
946 if (swap) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
947 swap_bytes<sizeof (bool)> (&rev); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
948 } |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
949 if (inc != T (0)) |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
950 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
|
951 else |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
952 { |
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
953 octave_idx_type numel = static_cast<octave_idx_type> (lim); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
954 r = octave::range<T>::make_constant (bas, numel, rev); |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
955 } |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
956 |
4687 | 957 return true; |
958 } | |
959 | |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
960 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
961 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
962 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:
30395
diff
changeset
|
963 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
964 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
965 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:
30395
diff
changeset
|
966 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
967 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
968 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
969 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
970 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
971 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
972 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
973 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
974 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:
30395
diff
changeset
|
975 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
976 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
977 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:
30395
diff
changeset
|
978 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
979 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
980 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
981 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
982 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:
30395
diff
changeset
|
983 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
984 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
985 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:
30395
diff
changeset
|
986 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
987 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
988 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
989 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
990 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:
30395
diff
changeset
|
991 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
992 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
993 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:
30395
diff
changeset
|
994 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
995 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
996 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
997 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
998 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:
30395
diff
changeset
|
999 octave::mach_info::float_format fmt) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1000 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1001 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:
30395
diff
changeset
|
1002 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1003 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1004 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1005 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1006 /* |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1007 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1008 %! a = b = 1:4; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1009 %! sv_file = [tempname(), ".dat"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1010 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1011 %! save (sv_file, "a", "-binary"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1012 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1013 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1014 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1015 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1016 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1017 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1018 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1019 %!test |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1020 %! a = b = uint8(5):-1:0; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1021 %! sv_file = [tempname(), ".dat"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1022 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1023 %! save (sv_file, "a", "-binary"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1024 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1025 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1026 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1027 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1028 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1029 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1030 */ |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1031 |
4687 | 1032 #if defined (HAVE_HDF5) |
4944 | 1033 |
4687 | 1034 // 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
|
1035 // 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
|
1036 // 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
|
1037 // H5T_NATIVE_DOUBLE to save as 'double'). Note that any necessary |
4687 | 1038 // conversions are handled automatically by HDF5. |
1039 | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1040 template <typename T> |
4687 | 1041 static hid_t |
1042 hdf5_make_range_type (hid_t num_type) | |
1043 { | |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1044 hid_t type_id = H5Tcreate (H5T_COMPOUND, sizeof (T) * 3); |
4687 | 1045 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1046 H5Tinsert (type_id, "base", 0 * sizeof (T), num_type); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1047 H5Tinsert (type_id, "limit", 1 * sizeof (T), num_type); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1048 H5Tinsert (type_id, "increment", 2 * sizeof (T), num_type); |
4687 | 1049 |
1050 return type_id; | |
1051 } | |
1052 | |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1053 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1054 static hid_t |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1055 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:
30395
diff
changeset
|
1056 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1057 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:
30395
diff
changeset
|
1058 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1059 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:
30395
diff
changeset
|
1060 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:
30395
diff
changeset
|
1061 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:
30395
diff
changeset
|
1062 // 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:
30395
diff
changeset
|
1063 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:
30395
diff
changeset
|
1064 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1065 return type_id; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1066 } |
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
|
1067 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1068 template <typename T> |
4687 | 1069 bool |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1070 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:
30395
diff
changeset
|
1071 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:
30395
diff
changeset
|
1072 const octave_hdf5_id h5_save_type, const bool with_reverse) |
4687 | 1073 { |
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
|
1074 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
|
1075 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1076 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
|
1077 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
|
1078 space_hid = type_hid = data_hid = -1; |
4687 | 1079 |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
1080 space_hid = H5Screate_simple (0, dimens, nullptr); |
4687 | 1081 if (space_hid < 0) return false; |
1082 | |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1083 type_hid = with_reverse |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1084 ? 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:
30395
diff
changeset
|
1085 : 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
|
1086 if (type_hid < 0) |
4687 | 1087 { |
1088 H5Sclose (space_hid); | |
1089 return false; | |
1090 } | |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1091 # if defined (HAVE_HDF5_18) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1092 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, |
30351
91c6288781ba
maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents:
30011
diff
changeset
|
1093 octave_H5P_DEFAULT, octave_H5P_DEFAULT, |
91c6288781ba
maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents:
30011
diff
changeset
|
1094 octave_H5P_DEFAULT); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1095 # 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
|
1096 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, octave_H5P_DEFAULT); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1097 # endif |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1098 if (data_hid < 0) |
4687 | 1099 { |
1100 H5Sclose (space_hid); | |
1101 H5Tclose (type_hid); | |
1102 return false; | |
1103 } | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1104 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1105 T range_vals[4]; |
4687 | 1106 range_vals[0] = r.base (); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1107 if (r.increment () != T (0)) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1108 range_vals[1] = r.limit (); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1109 else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1110 range_vals[1] = r.numel (); |
28641
a3db48e66ef8
use Range::increment instead of Range::inc
John W. Eaton <jwe@octave.org>
parents:
28639
diff
changeset
|
1111 range_vals[2] = r.increment (); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1112 range_vals[3] = r.reverse (); |
4687 | 1113 |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1114 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
|
1115 octave_H5P_DEFAULT, range_vals) |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1116 >= 0) |
11176
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1117 { |
20228
00cf2847355d
Deprecate Array::nelem() and Range::nelem() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20163
diff
changeset
|
1118 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
|
1119 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
|
1120 "OCTAVE_RANGE_NELEM", &nel) >= 0; |
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1121 } |
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1122 else |
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1123 retval = false; |
4687 | 1124 |
1125 H5Dclose (data_hid); | |
1126 H5Tclose (type_hid); | |
1127 H5Sclose (space_hid); | |
4837 | 1128 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1129 return retval; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1130 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1131 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1132 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1133 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1134 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1135 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1136 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:
30395
diff
changeset
|
1137 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1138 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1139 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1140 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:
30395
diff
changeset
|
1141 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
|
1142 #else |
21691
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1143 octave_unused_parameter (loc_id); |
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1144 octave_unused_parameter (name); |
30442
e3df47a19871
ov-range.cc: Silence compiler warning about unused parameter.
Markus Mützel <markus.muetzel@gmx.de>
parents:
30421
diff
changeset
|
1145 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
|
1146 |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1147 warn_save ("hdf5"); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1148 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1149 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
|
1150 #endif |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1151 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1152 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1153 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1154 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1155 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1156 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1157 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1158 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1159 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:
30395
diff
changeset
|
1160 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1161 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1162 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1163 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:
30395
diff
changeset
|
1164 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1165 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1166 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1167 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1168 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1169 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1170 warn_save ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1171 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1172 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1173 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1174 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1175 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1176 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1177 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1178 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:
30395
diff
changeset
|
1179 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1180 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1181 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1182 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:
30395
diff
changeset
|
1183 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1184 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1185 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1186 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1187 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1188 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1189 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
|
1190 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1191 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1192 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1193 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1194 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1195 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1196 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1197 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:
30395
diff
changeset
|
1198 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1199 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1200 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1201 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:
30395
diff
changeset
|
1202 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1203 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1204 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1205 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1206 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1207 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1208 warn_save ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1209 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1210 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1211 #endif |
4687 | 1212 } |
1213 | |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1214 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1215 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1216 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:
30395
diff
changeset
|
1217 bool save_as_floats) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1218 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1219 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1220 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:
30395
diff
changeset
|
1221 true); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1222 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1223 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1224 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1225 octave_unused_parameter (save_as_floats); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1226 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1227 warn_save ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1228 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1229 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1230 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1231 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1232 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1233 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1234 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1235 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1236 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1237 template <typename T> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1238 bool |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1239 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:
30395
diff
changeset
|
1240 const octave_hdf5_id h5_save_type, const bool with_reverse) |
4687 | 1241 { |
1242 bool retval = false; | |
4837 | 1243 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1244 # 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
|
1245 hid_t data_hid = H5Dopen (loc_id, name, octave_H5P_DEFAULT); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1246 # else |
4687 | 1247 hid_t data_hid = H5Dopen (loc_id, name); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1248 # endif |
4687 | 1249 hid_t type_hid = H5Dget_type (data_hid); |
1250 | |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1251 hid_t range_type = with_reverse |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1252 ? 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:
30395
diff
changeset
|
1253 : hdf5_make_range_type<T> (h5_save_type); |
4687 | 1254 |
1255 if (! hdf5_types_compatible (type_hid, range_type)) | |
1256 { | |
4837 | 1257 H5Tclose (range_type); |
4687 | 1258 H5Dclose (data_hid); |
1259 return false; | |
1260 } | |
1261 | |
1262 hid_t space_hid = H5Dget_space (data_hid); | |
1263 hsize_t rank = H5Sget_simple_extent_ndims (space_hid); | |
1264 | |
1265 if (rank != 0) | |
1266 { | |
4837 | 1267 H5Tclose (range_type); |
4687 | 1268 H5Sclose (space_hid); |
1269 H5Dclose (data_hid); | |
1270 return false; | |
1271 } | |
1272 | |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1273 T rangevals[4]; |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1274 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
|
1275 octave_H5P_DEFAULT, rangevals) |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
1276 >= 0) |
4687 | 1277 { |
1278 retval = true; | |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
1279 |
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
1280 // Don't use OCTAVE_RANGE_NELEM attribute, just reconstruct the range. |
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
1281 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1282 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:
30395
diff
changeset
|
1283 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1284 if (rangevals[2] != T (0)) |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1285 r = octave::range<T> (rangevals[0], rangevals[2], rangevals[1], rev); |
10735
d899b2ee6a37
fix saving/loading of constant ranges (bug #30289)
Jaroslav Hajek <highegg@gmail.com>
parents:
10711
diff
changeset
|
1286 else |
11176
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1287 { |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
1288 octave_idx_type numel = static_cast<octave_idx_type> (rangevals[1]); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1289 r = octave::range<T>::make_constant (rangevals[0], numel, rev); |
11176
2271261f088a
Address precision issue in ranges saved to HDF5 files
David Bateman <dbateman@free.fr>
parents:
11129
diff
changeset
|
1290 } |
4687 | 1291 } |
1292 | |
4837 | 1293 H5Tclose (range_type); |
4687 | 1294 H5Sclose (space_hid); |
1295 H5Dclose (data_hid); | |
4837 | 1296 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1297 return retval; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1298 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1299 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1300 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1301 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1302 template <typename T> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1303 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1304 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:
30395
diff
changeset
|
1305 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1306 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1307 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:
30395
diff
changeset
|
1308 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1309 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1310 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1311 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1312 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1313 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1314 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1315 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1316 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1317 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1318 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1319 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1320 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1321 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1322 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1323 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1324 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:
30395
diff
changeset
|
1325 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1326 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1327 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:
30395
diff
changeset
|
1328 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1329 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1330 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1331 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1332 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1333 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1334 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1335 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1336 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1337 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1338 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1339 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1340 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:
30395
diff
changeset
|
1341 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1342 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1343 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
|
1344 #else |
21691
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1345 octave_unused_parameter (loc_id); |
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1346 octave_unused_parameter (name); |
263d18409fdf
Eliminate unused variable warnings for conditionally compiled code.
John W. Eaton <jwe@octave.org>
parents:
21647
diff
changeset
|
1347 |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
1348 warn_load ("hdf5"); |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1349 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1350 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
|
1351 #endif |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1352 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1353 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1354 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1355 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1356 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:
30395
diff
changeset
|
1357 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1358 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1359 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:
30395
diff
changeset
|
1360 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1361 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1362 octave_unused_parameter (name); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1363 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1364 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1365 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1366 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1367 #endif |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1368 } |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1369 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1370 template <> |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1371 bool |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1372 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:
30395
diff
changeset
|
1373 { |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1374 #if defined (HAVE_HDF5) |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1375 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:
30395
diff
changeset
|
1376 #else |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1377 octave_unused_parameter (loc_id); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1378 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
|
1379 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1380 warn_load ("hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1381 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1382 return false; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1383 #endif |
4687 | 1384 } |
4944 | 1385 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1386 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1387 |
30421
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1388 /* |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1389 %!testif HAVE_HDF5 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1390 %! a = b = 1:4; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1391 %! sv_file = [tempname(), ".h5"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1392 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1393 %! save (sv_file, "a", "-hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1394 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1395 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1396 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1397 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1398 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1399 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1400 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1401 %!testif HAVE_HDF5 |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1402 %! a = b = uint8(5):-1:0; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1403 %! sv_file = [tempname(), ".h5"]; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1404 %! unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1405 %! save (sv_file, "a", "-hdf5"); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1406 %! clear a; |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1407 %! load (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1408 %! assert (a, b); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1409 %! unwind_protect_cleanup |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1410 %! unlink (sv_file); |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1411 %! end_unwind_protect |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1412 */ |
4736bc8e9804
Allow descending ranges of all integer types (bug #61132).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30395
diff
changeset
|
1413 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1414 template <typename T> |
5900 | 1415 mxArray * |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1416 ov_range<T>::as_mxArray (bool interleaved) const |
5900 | 1417 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1418 mxClassID mx_class = mx_type_traits<T>::mx_class; |
5900 | 1419 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1420 mxArray *retval = new mxArray (interleaved, mx_class, dims (), mxREAL); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1421 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1422 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:
28643
diff
changeset
|
1423 mx_type *pd = static_cast<mx_type *> (retval->get_data ()); |
5900 | 1424 |
6686 | 1425 mwSize nel = numel (); |
5900 | 1426 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1427 Array<T> matrix = raw_array_value (); |
5900 | 1428 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1429 const T *pdata = matrix.data (); |
5900 | 1430 |
6686 | 1431 for (mwSize i = 0; i < nel; i++) |
28131
4c21f99b4ad5
handle interleaved complex data and new typed data access functions for mex
John W. Eaton <jwe@octave.org>
parents:
27928
diff
changeset
|
1432 pd[i] = pdata[i]; |
5900 | 1433 |
1434 return retval; | |
1435 } | |
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
|
1436 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1437 template <typename T> |
18650
491b0adfec95
compatibility fixes for printf integer format specifiers
John W. Eaton <jwe@octave.org>
parents:
18416
diff
changeset
|
1438 octave_value |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1439 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
|
1440 { |
28643
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28641
diff
changeset
|
1441 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
|
1442 } |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1443 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1444 // Specializations. |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1445 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1446 template <> |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1447 octave::range<double> |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1448 ov_range<double>::range_value (void) const |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1449 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1450 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1451 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1452 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1453 // For now, disable all but ov_range<double>. |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1454 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1455 #if 0 |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1456 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1457 template <> |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1458 octave::range<float> |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1459 ov_range<float>::float_range_value (void) const |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1460 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1461 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1462 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1463 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1464 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1465 octave::range<octave_int8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1466 ov_range<octave_int8>::int8_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1467 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1468 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1469 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1470 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1471 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1472 octave::range<octave_int16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1473 ov_range<octave_int16>::int16_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1474 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1475 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1476 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1477 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1478 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1479 octave::range<octave_int32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1480 ov_range<octave_int32>::int32_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1481 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1482 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1483 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1484 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1485 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1486 octave::range<octave_int64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1487 ov_range<octave_int64>::int64_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1488 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1489 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1490 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1491 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1492 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1493 octave::range<octave_uint8> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1494 ov_range<octave_uint8>::uint8_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1495 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1496 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1497 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1498 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1499 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1500 octave::range<octave_uint16> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1501 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
|
1502 { |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1503 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1504 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1505 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1506 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1507 octave::range<octave_uint32> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1508 ov_range<octave_uint32>::uint32_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1509 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1510 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1511 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1512 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1513 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1514 octave::range<octave_uint64> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1515 ov_range<octave_uint64>::uint64_range_value (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1516 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1517 return m_range; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1518 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1519 |
30840
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1520 #endif |
2989202f92f8
only allow range<FLOAT> to be instantiated
John W. Eaton <jwe@octave.org>
parents:
30569
diff
changeset
|
1521 |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1522 template <> |
29574
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29399
diff
changeset
|
1523 octave::idx_vector |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1524 ov_range<double>::index_vector (bool require_integers) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1525 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1526 if (m_idx_cache) |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1527 return *m_idx_cache; |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1528 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1529 if (require_integers || m_range.all_elements_are_ints ()) |
29574
29a1f8fd8ee6
move idx_vector classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29399
diff
changeset
|
1530 return set_idx_cache (octave::idx_vector (m_range)); |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1531 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1532 warning_with_id ("Octave:noninteger-range-as-index", |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1533 "non-integer range used as index"); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1534 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1535 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
|
1536 } |
28651
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1537 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1538 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1539 octave_idx_type |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1540 ov_range<double>::nnz (void) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1541 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1542 return m_range.nnz (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1543 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1544 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1545 // The following specialization is also historical baggage. For double |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1546 // 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:
28643
diff
changeset
|
1547 // 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:
28643
diff
changeset
|
1548 // objects. |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1549 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1550 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1551 octave_value |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1552 ov_range<double>::diag (octave_idx_type k) const |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1553 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1554 // FIXME: this is a potential waste of memory. |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1555 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1556 return |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1557 (k == 0 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1558 ? octave_value (DiagMatrix (DiagArray2<double> (matrix_value ()))) |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1559 : octave_value (m_range.diag (k))); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1560 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1561 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1562 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1563 octave_value |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1564 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:
28643
diff
changeset
|
1565 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1566 Matrix mat = matrix_value (); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1567 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1568 return mat.diag (nr, nc); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1569 } |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1570 |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1571 template <> |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1572 void |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1573 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:
28643
diff
changeset
|
1574 { |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1575 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:
28643
diff
changeset
|
1576 current_print_indent_level ()); |
e26201931ea3
new template class for octave_range objects
John W. Eaton <jwe@octave.org>
parents:
28643
diff
changeset
|
1577 } |