Mercurial > octave-antonio
annotate src/ov-range.cc @ 10609:58bcda68ac11
improve warning/error message
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Thu, 06 May 2010 08:02:07 -0400 |
parents | 1834132fb50b |
children | e103fb2182ce |
rev | line source |
---|---|
2376 | 1 /* |
2 | |
7017 | 3 Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004, 2005, 2006, |
8920 | 4 2007, 2008 John W. Eaton |
2376 | 5 |
6 This file is part of Octave. | |
7 | |
8 Octave is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
11 option) any later version. | |
2376 | 12 |
13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
7016 | 19 along with Octave; see the file COPYING. If not, see |
20 <http://www.gnu.org/licenses/>. | |
2376 | 21 |
22 */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
25 #include <config.h> | |
26 #endif | |
27 | |
3503 | 28 #include <iostream> |
2901 | 29 |
2376 | 30 #include "lo-ieee.h" |
31 #include "lo-utils.h" | |
32 | |
10605
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
33 #include "defun.h" |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
34 #include "variables.h" |
2376 | 35 #include "gripes.h" |
36 #include "ops.h" | |
3933 | 37 #include "oct-obj.h" |
2376 | 38 #include "ov-range.h" |
39 #include "ov-re-mat.h" | |
2410 | 40 #include "ov-scalar.h" |
2376 | 41 #include "pr-output.h" |
42 | |
4687 | 43 #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
|
44 #include "ls-ascii-helper.h" |
4687 | 45 #include "ls-hdf5.h" |
46 #include "ls-utils.h" | |
47 | |
3219 | 48 DEFINE_OCTAVE_ALLOCATOR (octave_range); |
2376 | 49 |
4612 | 50 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_range, "range", "double"); |
2376 | 51 |
5759 | 52 static octave_base_value * |
53 default_numeric_conversion_function (const octave_base_value& a) | |
2376 | 54 { |
55 CAST_CONV_ARG (const octave_range&); | |
56 | |
57 return new octave_matrix (v.matrix_value ()); | |
58 } | |
59 | |
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
60 octave_base_value::type_conv_info |
2376 | 61 octave_range::numeric_conversion_function (void) const |
62 { | |
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
63 return octave_base_value::type_conv_info (default_numeric_conversion_function, |
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
64 octave_matrix::static_type_id ()); |
2376 | 65 } |
66 | |
5759 | 67 octave_base_value * |
2410 | 68 octave_range::try_narrowing_conversion (void) |
69 { | |
5759 | 70 octave_base_value *retval = 0; |
2410 | 71 |
72 switch (range.nelem ()) | |
73 { | |
74 case 1: | |
75 retval = new octave_scalar (range.base ()); | |
76 break; | |
77 | |
78 case 0: | |
4417 | 79 retval = new octave_matrix (Matrix (1, 0)); |
2410 | 80 break; |
81 | |
8971 | 82 case -2: |
83 retval = new octave_matrix (range.matrix_value ()); | |
84 break; | |
85 | |
2410 | 86 default: |
87 break; | |
88 } | |
89 | |
90 return retval; | |
91 } | |
92 | |
2436 | 93 octave_value |
4247 | 94 octave_range::subsref (const std::string& type, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
95 const std::list<octave_value_list>& idx) |
3933 | 96 { |
97 octave_value retval; | |
98 | |
99 switch (type[0]) | |
100 { | |
101 case '(': | |
102 retval = do_index_op (idx.front ()); | |
103 break; | |
104 | |
105 case '{': | |
106 case '.': | |
107 { | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
108 std::string nm = type_name (); |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
109 error ("%s cannot be indexed with %c", nm.c_str (), type[0]); |
3933 | 110 } |
111 break; | |
112 | |
113 default: | |
114 panic_impossible (); | |
115 } | |
116 | |
117 return retval.next_subsref (type, idx); | |
118 } | |
119 | |
120 octave_value | |
5885 | 121 octave_range::do_index_op (const octave_value_list& idx, bool resize_ok) |
2436 | 122 { |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
123 if (idx.length () == 1 && ! resize_ok) |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
124 { |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
125 octave_value retval; |
2436 | 126 |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
127 // The range can handle a single subscript. |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
128 idx_vector i = idx(0).index_vector (); |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
129 if (! error_state) |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
130 { |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
131 if (i.is_scalar () && i(0) < range.nelem ()) |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
132 retval = range.elem (i(0)); |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
133 else |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
134 retval = range.index (i); |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
135 } |
2436 | 136 |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
137 return retval; |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
138 } |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
139 else |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
140 { |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
141 octave_value tmp (new octave_matrix (range.matrix_value ())); |
2436 | 142 |
9986
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
143 return tmp.do_index_op (idx, resize_ok); |
672e1b49e01e
optimize indexing of ranges by single subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9892
diff
changeset
|
144 } |
2436 | 145 } |
146 | |
10605
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
147 idx_vector |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
148 octave_range::index_vector (void) const |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
149 { |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
150 if (idx_cache) |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
151 return *idx_cache; |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
152 else |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
153 { |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
154 if (range.all_elements_are_ints ()) |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
155 return set_idx_cache (idx_vector (range)); |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
156 else |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
157 { |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
158 warning_with_id ("Octave:allow-noninteger-ranges-as-indices", |
10609
58bcda68ac11
improve warning/error message
John W. Eaton <jwe@octave.org>
parents:
10605
diff
changeset
|
159 "non-integer range used as index"); |
10605
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
160 |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
161 return octave_value (matrix_value ()).round ().index_vector (); |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
162 } |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
163 } |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
164 } |
1834132fb50b
allow non-integer ranges as indices conditionally
John W. Eaton <jwe@octave.org>
parents:
10315
diff
changeset
|
165 |
2376 | 166 double |
167 octave_range::double_value (bool) const | |
168 { | |
4102 | 169 double retval = lo_ieee_nan_value (); |
2376 | 170 |
5275 | 171 octave_idx_type nel = range.nelem (); |
2376 | 172 |
4455 | 173 if (nel > 0) |
174 { | |
5781 | 175 gripe_implicit_conversion ("Octave:array-as-scalar", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
176 "range", "real scalar"); |
4455 | 177 |
178 retval = range.base (); | |
179 } | |
2376 | 180 else |
181 gripe_invalid_conversion ("range", "real scalar"); | |
182 | |
183 return retval; | |
184 } | |
185 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
186 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
187 octave_range::float_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
188 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
189 float retval = lo_ieee_float_nan_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
190 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
191 octave_idx_type nel = range.nelem (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
192 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
193 if (nel > 0) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
194 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
195 gripe_implicit_conversion ("Octave:array-as-scalar", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
196 "range", "real scalar"); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
197 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
198 retval = range.base (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
199 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
200 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
201 gripe_invalid_conversion ("range", "real scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
202 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
203 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
204 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
205 |
9146
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
206 charNDArray |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
207 octave_range::char_array_value (bool) const |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
208 { |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
209 const Matrix matrix = range.matrix_value (); |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
210 charNDArray retval (dims ()); |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
211 |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
212 octave_idx_type nel = numel (); |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
213 |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
214 for (octave_idx_type i = 0; i < nel; i++) |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
215 retval.elem (i) = static_cast<char>(matrix.elem (i)); |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
216 |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
217 return retval; |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
218 } |
a48c500e48e1
support range->string conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
8971
diff
changeset
|
219 |
2376 | 220 octave_value |
4017 | 221 octave_range::all (int dim) const |
2376 | 222 { |
5775 | 223 // FIXME -- this is a potential waste of memory. |
2436 | 224 |
225 Matrix m = range.matrix_value (); | |
226 | |
4017 | 227 return m.all (dim); |
2376 | 228 } |
229 | |
230 octave_value | |
4017 | 231 octave_range::any (int dim) const |
2376 | 232 { |
5775 | 233 // FIXME -- this is a potential waste of memory. |
4017 | 234 |
235 Matrix m = range.matrix_value (); | |
236 | |
237 return m.any (dim); | |
2376 | 238 } |
239 | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
240 octave_value |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
241 octave_range::diag (octave_idx_type k) const |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
242 { |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
243 return (k == 0 |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
244 ? octave_value (DiagMatrix (DiagArray2<double> (range.matrix_value ()))) |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
245 : octave_value (range.diag (k))); |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
246 } |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
247 |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
248 |
2376 | 249 bool |
250 octave_range::is_true (void) const | |
251 { | |
252 bool retval = false; | |
2436 | 253 |
4478 | 254 if (range.nelem () != 0) |
2436 | 255 { |
5775 | 256 // FIXME -- this is a potential waste of memory. |
2436 | 257 |
258 Matrix m ((range.matrix_value () . all ()) . all ()); | |
259 | |
260 retval = (m.rows () == 1 && m.columns () == 1 && m (0, 0) != 0.0); | |
261 } | |
262 | |
2376 | 263 return retval; |
264 } | |
265 | |
266 Complex | |
267 octave_range::complex_value (bool) const | |
268 { | |
4102 | 269 double tmp = lo_ieee_nan_value (); |
270 | |
271 Complex retval (tmp, tmp); | |
2376 | 272 |
5275 | 273 octave_idx_type nel = range.nelem (); |
2376 | 274 |
4455 | 275 if (nel > 0) |
276 { | |
5781 | 277 gripe_implicit_conversion ("Octave:array-as-scalar", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
278 "range", "complex scalar"); |
4455 | 279 |
280 retval = range.base (); | |
281 } | |
2376 | 282 else |
283 gripe_invalid_conversion ("range", "complex scalar"); | |
284 | |
285 return retval; | |
286 } | |
287 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
288 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
289 octave_range::float_complex_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
290 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
291 float tmp = lo_ieee_float_nan_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
292 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
293 FloatComplex retval (tmp, tmp); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
294 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
295 octave_idx_type nel = range.nelem (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
296 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
297 if (nel > 0) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
298 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
299 gripe_implicit_conversion ("Octave:array-as-scalar", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
300 "range", "complex scalar"); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
301 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
302 retval = range.base (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
303 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
304 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
305 gripe_invalid_conversion ("range", "complex scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
306 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
307 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
308 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
309 |
5731 | 310 octave_value |
311 octave_range::resize (const dim_vector& dv, bool fill) const | |
312 { | |
313 NDArray retval = array_value (); | |
314 if (fill) | |
315 retval.resize (dv, NDArray::resize_fill_value()); | |
316 else | |
317 retval.resize (dv); | |
318 return retval; | |
319 } | |
320 | |
2376 | 321 octave_value |
5279 | 322 octave_range::convert_to_str_internal (bool pad, bool force, char type) const |
2449 | 323 { |
324 octave_value tmp (range.matrix_value ()); | |
5279 | 325 return tmp.convert_to_str (pad, force, type); |
2449 | 326 } |
327 | |
2376 | 328 void |
3523 | 329 octave_range::print (std::ostream& os, bool pr_as_read_syntax) const |
2901 | 330 { |
331 print_raw (os, pr_as_read_syntax); | |
332 newline (os); | |
333 } | |
334 | |
335 void | |
3523 | 336 octave_range::print_raw (std::ostream& os, bool pr_as_read_syntax) const |
2901 | 337 { |
338 octave_print_internal (os, range, pr_as_read_syntax, | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
339 current_print_indent_level ()); |
2901 | 340 } |
341 | |
342 bool | |
3523 | 343 octave_range::print_name_tag (std::ostream& os, const std::string& name) const |
2376 | 344 { |
2901 | 345 bool retval = false; |
346 | |
5275 | 347 octave_idx_type n = range.nelem (); |
2901 | 348 |
349 indent (os); | |
350 | |
351 if (n == 0 || n == 1) | |
352 os << name << " = "; | |
353 else | |
354 { | |
355 os << name << " ="; | |
356 newline (os); | |
357 newline (os); | |
358 retval = true; | |
359 } | |
360 | |
361 return retval; | |
2376 | 362 } |
363 | |
4687 | 364 // Skip white space and comments on stream IS. |
365 | |
366 static void | |
367 skip_comments (std::istream& is) | |
368 { | |
369 char c = '\0'; | |
370 while (is.get (c)) | |
371 { | |
372 if (c == ' ' || c == '\t' || c == '\n') | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
373 ; // Skip whitespace on way to beginning of next line. |
4687 | 374 else |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
375 break; |
4687 | 376 } |
377 | |
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
|
378 skip_until_newline (is, false); |
4687 | 379 } |
380 | |
381 bool | |
6974 | 382 octave_range::save_ascii (std::ostream& os) |
4687 | 383 { |
384 Range r = range_value (); | |
385 double base = r.base (); | |
386 double limit = r.limit (); | |
387 double inc = r.inc (); | |
388 | |
389 os << "# base, limit, increment\n"; | |
390 octave_write_double (os, base); | |
391 os << " "; | |
392 octave_write_double (os, limit); | |
393 os << " "; | |
394 octave_write_double (os, inc); | |
395 os << "\n"; | |
396 | |
397 return true; | |
398 } | |
399 | |
400 bool | |
401 octave_range::load_ascii (std::istream& is) | |
402 { | |
403 // # base, limit, range comment added by save (). | |
404 skip_comments (is); | |
405 | |
406 is >> range; | |
407 | |
408 if (!is) | |
409 { | |
410 error ("load: failed to load range constant"); | |
411 return false; | |
412 } | |
413 | |
414 return true; | |
415 } | |
416 | |
417 bool | |
418 octave_range::save_binary (std::ostream& os, bool& /* save_as_floats */) | |
419 { | |
5760 | 420 char tmp = LS_DOUBLE; |
421 os.write (reinterpret_cast<char *> (&tmp), 1); | |
4687 | 422 Range r = range_value (); |
423 double bas = r.base (); | |
424 double lim = r.limit (); | |
425 double inc = r.inc (); | |
5760 | 426 os.write (reinterpret_cast<char *> (&bas), 8); |
427 os.write (reinterpret_cast<char *> (&lim), 8); | |
428 os.write (reinterpret_cast<char *> (&inc), 8); | |
4687 | 429 |
430 return true; | |
431 } | |
432 | |
433 bool | |
434 octave_range::load_binary (std::istream& is, bool swap, | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
435 oct_mach_info::float_format /* fmt */) |
4687 | 436 { |
437 char tmp; | |
5760 | 438 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
4687 | 439 return false; |
440 double bas, lim, inc; | |
5760 | 441 if (! is.read (reinterpret_cast<char *> (&bas), 8)) |
4687 | 442 return false; |
443 if (swap) | |
4944 | 444 swap_bytes<8> (&bas); |
5760 | 445 if (! is.read (reinterpret_cast<char *> (&lim), 8)) |
4687 | 446 return false; |
447 if (swap) | |
4944 | 448 swap_bytes<8> (&lim); |
5760 | 449 if (! is.read (reinterpret_cast<char *> (&inc), 8)) |
4687 | 450 return false; |
451 if (swap) | |
4944 | 452 swap_bytes<8> (&inc); |
4687 | 453 Range r (bas, lim, inc); |
454 range = r; | |
455 return true; | |
456 } | |
457 | |
458 #if defined (HAVE_HDF5) | |
4944 | 459 |
4687 | 460 // The following subroutines creates an HDF5 representation of the way |
461 // we will store Octave range types (triplets of floating-point numbers). | |
462 // NUM_TYPE is the HDF5 numeric type to use for storage (e.g. | |
463 // H5T_NATIVE_DOUBLE to save as 'double'). Note that any necessary | |
464 // conversions are handled automatically by HDF5. | |
465 | |
466 static hid_t | |
467 hdf5_make_range_type (hid_t num_type) | |
468 { | |
469 hid_t type_id = H5Tcreate (H5T_COMPOUND, sizeof (double) * 3); | |
470 | |
471 H5Tinsert (type_id, "base", 0 * sizeof (double), num_type); | |
472 H5Tinsert (type_id, "limit", 1 * sizeof (double), num_type); | |
473 H5Tinsert (type_id, "increment", 2 * sizeof (double), num_type); | |
474 | |
475 return type_id; | |
476 } | |
477 | |
478 bool | |
479 octave_range::save_hdf5 (hid_t loc_id, const char *name, | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
480 bool /* save_as_floats */) |
4687 | 481 { |
4792 | 482 hsize_t dimens[3]; |
4687 | 483 hid_t space_hid = -1, type_hid = -1, data_hid = -1; |
484 bool retval = true; | |
485 | |
4815 | 486 space_hid = H5Screate_simple (0, dimens, 0); |
4687 | 487 if (space_hid < 0) return false; |
488 | |
489 type_hid = hdf5_make_range_type (H5T_NATIVE_DOUBLE); | |
490 if (type_hid < 0) | |
491 { | |
492 H5Sclose (space_hid); | |
493 return false; | |
494 } | |
9892
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
495 #if HAVE_HDF5_18 |
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
496 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
497 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); |
9892
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
498 #else |
4687 | 499 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, H5P_DEFAULT); |
9892
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
500 #endif |
4687 | 501 if (data_hid < 0) |
502 { | |
503 H5Sclose (space_hid); | |
504 H5Tclose (type_hid); | |
505 return false; | |
506 } | |
507 | |
508 Range r = range_value (); | |
509 double range_vals[3]; | |
510 range_vals[0] = r.base (); | |
511 range_vals[1] = r.limit (); | |
512 range_vals[2] = r.inc (); | |
513 | |
514 retval = H5Dwrite (data_hid, type_hid, H5S_ALL, H5S_ALL, H5P_DEFAULT, | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
515 range_vals) >= 0; |
4687 | 516 |
517 H5Dclose (data_hid); | |
518 H5Tclose (type_hid); | |
519 H5Sclose (space_hid); | |
4837 | 520 |
4687 | 521 return retval; |
522 } | |
523 | |
524 bool | |
9881
b3089dba88bf
Remove HDF5 cruft for older versions of HDF5
Kacper Kowalik
parents:
9146
diff
changeset
|
525 octave_range::load_hdf5 (hid_t loc_id, const char *name) |
4687 | 526 { |
527 bool retval = false; | |
4837 | 528 |
9892
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
529 #if HAVE_HDF5_18 |
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
530 hid_t data_hid = H5Dopen (loc_id, name, H5P_DEFAULT); |
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
531 #else |
4687 | 532 hid_t data_hid = H5Dopen (loc_id, name); |
9892
ac69e6f4b33d
Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions
Kacper Kowalik <xarthisius.kk@gmail.com>
parents:
9881
diff
changeset
|
533 #endif |
4687 | 534 hid_t type_hid = H5Dget_type (data_hid); |
535 | |
536 hid_t range_type = hdf5_make_range_type (H5T_NATIVE_DOUBLE); | |
537 | |
538 if (! hdf5_types_compatible (type_hid, range_type)) | |
539 { | |
4837 | 540 H5Tclose (range_type); |
4687 | 541 H5Dclose (data_hid); |
542 return false; | |
543 } | |
544 | |
545 hid_t space_hid = H5Dget_space (data_hid); | |
546 hsize_t rank = H5Sget_simple_extent_ndims (space_hid); | |
547 | |
548 if (rank != 0) | |
549 { | |
4837 | 550 H5Tclose (range_type); |
4687 | 551 H5Sclose (space_hid); |
552 H5Dclose (data_hid); | |
553 return false; | |
554 } | |
555 | |
556 double rangevals[3]; | |
557 if (H5Dread (data_hid, range_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
558 rangevals) >= 0) |
4687 | 559 { |
560 retval = true; | |
561 Range r (rangevals[0], rangevals[1], rangevals[2]); | |
562 range = r; | |
563 } | |
564 | |
4837 | 565 H5Tclose (range_type); |
4687 | 566 H5Sclose (space_hid); |
567 H5Dclose (data_hid); | |
4837 | 568 |
4687 | 569 return retval; |
570 } | |
4944 | 571 |
4687 | 572 #endif |
573 | |
5900 | 574 mxArray * |
575 octave_range::as_mxArray (void) const | |
576 { | |
577 mxArray *retval = new mxArray (mxDOUBLE_CLASS, dims (), mxREAL); | |
578 | |
579 double *pr = static_cast<double *> (retval->get_data ()); | |
580 | |
6686 | 581 mwSize nel = numel (); |
5900 | 582 |
583 Matrix m = matrix_value (); | |
584 | |
585 const double *p = m.data (); | |
586 | |
6686 | 587 for (mwSize i = 0; i < nel; i++) |
5900 | 588 pr[i] = p[i]; |
589 | |
590 return retval; | |
591 } |