Mercurial > hg > octave-lyh
annotate src/ov-intx.h @ 7997:2b8952e133c9
implement checked conversions between integers
author | Jaroslav Hajek <highegg@gmail.com> |
---|---|
date | Wed, 30 Jul 2008 15:20:13 +0200 |
parents | f336dd8e96d0 |
children | f7f2d867c523 |
rev | line source |
---|---|
4904 | 1 /* |
2 | |
7017 | 3 Copyright (C) 2004, 2005, 2006, 2007 John W. Eaton |
4904 | 4 |
5 This file is part of Octave. | |
6 | |
7 Octave is free software; you can redistribute it and/or modify it | |
8 under the terms of the GNU General Public License as published by the | |
7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
10 option) any later version. | |
4904 | 11 |
12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
7016 | 18 along with Octave; see the file COPYING. If not, see |
19 <http://www.gnu.org/licenses/>. | |
4904 | 20 |
21 */ | |
22 | |
23 #include <cstdlib> | |
24 | |
25 #include <iostream> | |
26 #include <string> | |
27 | |
28 #include "mx-base.h" | |
29 #include "oct-alloc.h" | |
30 #include "str-vec.h" | |
31 | |
32 #include "error.h" | |
4944 | 33 #include "oct-stream.h" |
4904 | 34 #include "ov-base.h" |
35 #include "ov-base-int.h" | |
36 #include "ov-typeinfo.h" | |
4982 | 37 #include "gripes.h" |
4904 | 38 |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
39 #include "ov-re-mat.h" |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
40 #include "ov-scalar.h" |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
41 |
4904 | 42 class |
6693 | 43 OCTINTERP_API |
4904 | 44 OCTAVE_VALUE_INT_MATRIX_T |
45 : public octave_base_int_matrix<OCTAVE_INT_NDARRAY_T> | |
46 { | |
47 public: | |
48 | |
49 OCTAVE_VALUE_INT_MATRIX_T (void) | |
50 : octave_base_int_matrix<OCTAVE_INT_NDARRAY_T> () { } | |
51 | |
52 OCTAVE_VALUE_INT_MATRIX_T (const OCTAVE_INT_NDARRAY_T& nda) | |
53 : octave_base_int_matrix<OCTAVE_INT_NDARRAY_T> (nda) { } | |
54 | |
7064 | 55 OCTAVE_VALUE_INT_MATRIX_T (const ArrayN<OCTAVE_INT_T>& nda) |
56 : octave_base_int_matrix<OCTAVE_INT_NDARRAY_T> (OCTAVE_INT_NDARRAY_T (nda)) { } | |
57 | |
4904 | 58 ~OCTAVE_VALUE_INT_MATRIX_T (void) { } |
59 | |
5759 | 60 octave_base_value *clone (void) const |
4904 | 61 { return new OCTAVE_VALUE_INT_MATRIX_T (*this); } |
62 | |
5759 | 63 octave_base_value *empty_clone (void) const |
4904 | 64 { return new OCTAVE_VALUE_INT_MATRIX_T (); } |
65 | |
6069 | 66 bool OCTAVE_TYPE_PREDICATE_FUNCTION (void) const { return true; } |
5895 | 67 |
6223 | 68 bool is_integer_type (void) const { return true; } |
69 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
70 private: |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
71 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
72 template <class _int_matrix> |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
73 _int_matrix convert_gripe () const |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
74 { |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
75 typedef typename _int_matrix::element_type dest_el_type; |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
76 typedef OCTAVE_INT_NDARRAY_T::element_type src_el_type; |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
77 dest_el_type::clear_trunc_flag (); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
78 _int_matrix retval (matrix); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
79 if (dest_el_type::get_trunc_flag ()) |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
80 { |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
81 gripe_truncated_conversion (src_el_type::type_name (), |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
82 dest_el_type::type_name ()); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
83 dest_el_type::clear_trunc_flag (); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
84 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
85 } |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
86 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
87 return retval; |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
88 } |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
89 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
90 public: |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
91 |
5533 | 92 int8NDArray |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
93 int8_array_value (void) const { return convert_gripe<int8NDArray> (); } |
5533 | 94 |
95 int16NDArray | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
96 int16_array_value (void) const { return convert_gripe<int16NDArray> (); } |
5533 | 97 |
98 int32NDArray | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
99 int32_array_value (void) const { return convert_gripe<int32NDArray> (); } |
5533 | 100 |
101 int64NDArray | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
102 int64_array_value (void) const { return convert_gripe<int64NDArray> (); } |
5533 | 103 |
104 uint8NDArray | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
105 uint8_array_value (void) const { return convert_gripe<uint8NDArray> (); } |
5533 | 106 |
107 uint16NDArray | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
108 uint16_array_value (void) const { return convert_gripe<uint16NDArray> (); } |
5533 | 109 |
110 uint32NDArray | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
111 uint32_array_value (void) const { return convert_gripe<uint32NDArray> (); } |
5533 | 112 |
113 uint64NDArray | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
114 uint64_array_value (void) const { return convert_gripe<uint64NDArray> (); } |
4904 | 115 |
4982 | 116 double |
117 double_value (bool = false) const | |
118 { | |
119 double retval = lo_ieee_nan_value (); | |
120 | |
121 if (numel () > 0) | |
122 { | |
5781 | 123 gripe_implicit_conversion ("Octave:array-as-scalar", |
124 type_name (), "real scalar"); | |
4982 | 125 |
7198 | 126 retval = matrix(0).double_value (); |
4982 | 127 } |
128 else | |
129 gripe_invalid_conversion (type_name (), "real scalar"); | |
130 | |
131 return retval; | |
132 | |
133 } | |
134 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
135 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
136 float_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
137 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
138 float retval = lo_ieee_float_nan_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
139 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
140 if (numel () > 0) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
141 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
142 gripe_implicit_conversion ("Octave:array-as-scalar", |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
143 type_name (), "real scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
144 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
145 retval = matrix(0).float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
146 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
147 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
148 gripe_invalid_conversion (type_name (), "real scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
149 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
150 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
151 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
152 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
153 |
4983 | 154 double scalar_value (bool = false) const { return double_value (); } |
4982 | 155 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
156 float float_scalar_value (bool = false) const { return float_value (); } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
157 |
6214 | 158 Matrix |
159 matrix_value (bool = false) const | |
160 { | |
161 Matrix retval; | |
162 dim_vector dv = dims (); | |
163 if (dv.length () > 2) | |
164 error ("invalid conversion of %s to Matrix", type_name().c_str ()); | |
165 else | |
166 { | |
167 retval = Matrix (dv(0), dv(1)); | |
168 double *vec = retval.fortran_vec (); | |
169 octave_idx_type nel = matrix.numel (); | |
170 for (octave_idx_type i = 0; i < nel; i++) | |
7198 | 171 vec[i] = matrix(i).double_value (); |
6214 | 172 } |
173 return retval; | |
174 } | |
175 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
176 FloatMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
177 float_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
178 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
179 FloatMatrix retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
180 dim_vector dv = dims (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
181 if (dv.length () > 2) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
182 error ("invalid conversion of %s to FloatMatrix", type_name().c_str ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
183 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
184 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
185 retval = FloatMatrix (dv(0), dv(1)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
186 float *vec = retval.fortran_vec (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
187 octave_idx_type nel = matrix.numel (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
188 for (octave_idx_type i = 0; i < nel; i++) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
189 vec[i] = matrix(i).float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
190 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
191 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
192 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
193 |
6214 | 194 ComplexMatrix |
195 complex_matrix_value (bool = false) const | |
196 { | |
197 ComplexMatrix retval; | |
198 dim_vector dv = dims(); | |
199 if (dv.length () > 2) | |
200 error ("invalid conversion of %s to Matrix", type_name().c_str ()); | |
201 else | |
202 { | |
203 retval = ComplexMatrix (dv(0), dv(1)); | |
204 Complex *vec = retval.fortran_vec (); | |
205 octave_idx_type nel = matrix.numel (); | |
206 for (octave_idx_type i = 0; i < nel; i++) | |
7198 | 207 vec[i] = Complex (matrix(i).double_value ()); |
6214 | 208 } |
209 return retval; | |
210 } | |
211 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
212 FloatComplexMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
213 float_complex_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
214 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
215 FloatComplexMatrix retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
216 dim_vector dv = dims(); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
217 if (dv.length () > 2) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
218 error ("invalid conversion of %s to FloatMatrix", type_name().c_str ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
219 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
220 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
221 retval = FloatComplexMatrix (dv(0), dv(1)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
222 FloatComplex *vec = retval.fortran_vec (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
223 octave_idx_type nel = matrix.numel (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
224 for (octave_idx_type i = 0; i < nel; i++) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
225 vec[i] = FloatComplex (matrix(i).float_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
226 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
227 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
228 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
229 |
4915 | 230 NDArray |
231 array_value (bool = false) const | |
232 { | |
233 NDArray retval (matrix.dims ()); | |
6214 | 234 double *vec = retval.fortran_vec (); |
235 octave_idx_type nel = matrix.numel (); | |
236 for (octave_idx_type i = 0; i < nel; i++) | |
7198 | 237 vec[i] = matrix(i).double_value (); |
4963 | 238 return retval; |
239 } | |
240 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
241 FloatNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
242 float_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
243 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
244 FloatNDArray retval (matrix.dims ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
245 float *vec = retval.fortran_vec (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
246 octave_idx_type nel = matrix.numel (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
247 for (octave_idx_type i = 0; i < nel; i++) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
248 vec[i] = matrix(i).float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
249 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
250 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
251 |
4963 | 252 ComplexNDArray |
253 complex_array_value (bool = false) const | |
254 { | |
255 ComplexNDArray retval (matrix.dims ()); | |
6214 | 256 Complex *vec = retval.fortran_vec (); |
257 octave_idx_type nel = matrix.numel (); | |
258 for (octave_idx_type i = 0; i < nel; i++) | |
7198 | 259 vec[i] = Complex (matrix(i).double_value ()); |
4915 | 260 return retval; |
261 } | |
262 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
263 FloatComplexNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
264 float_complex_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
265 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
266 FloatComplexNDArray retval (matrix.dims ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
267 FloatComplex *vec = retval.fortran_vec (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
268 octave_idx_type nel = matrix.numel (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
269 for (octave_idx_type i = 0; i < nel; i++) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
270 vec[i] = FloatComplex (matrix(i).float_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
271 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
272 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
273 |
5898 | 274 boolNDArray |
5943 | 275 bool_array_value (bool warn = false) const |
5898 | 276 { |
277 boolNDArray retval (dims ()); | |
278 | |
279 octave_idx_type nel = numel (); | |
5943 | 280 |
281 if (warn && matrix.any_element_not_one_or_zero ()) | |
282 gripe_logical_conversion (); | |
283 | |
6214 | 284 bool *vec = retval.fortran_vec (); |
5898 | 285 for (octave_idx_type i = 0; i < nel; i++) |
7198 | 286 vec[i] = matrix(i).bool_value (); |
5898 | 287 |
288 return retval; | |
289 } | |
290 | |
5533 | 291 charNDArray |
292 char_array_value (bool = false) const | |
293 { | |
294 charNDArray retval (dims ()); | |
295 | |
296 octave_idx_type nel = numel (); | |
297 | |
6214 | 298 char *vec = retval.fortran_vec (); |
5533 | 299 for (octave_idx_type i = 0; i < nel; i++) |
7198 | 300 vec[i] = matrix(i).char_value (); |
5533 | 301 |
302 return retval; | |
303 } | |
304 | |
5829 | 305 void increment (void) { matrix += 1; } |
306 | |
307 void decrement (void) { matrix -= 1; } | |
308 | |
4938 | 309 idx_vector index_vector (void) const { return idx_vector (matrix); } |
310 | |
4944 | 311 int write (octave_stream& os, int block_size, |
312 oct_data_conv::data_type output_type, int skip, | |
313 oct_mach_info::float_format flt_fmt) const | |
314 { return os.write (matrix, block_size, output_type, skip, flt_fmt); } | |
315 | |
5900 | 316 mxArray *as_mxArray (void) const |
317 { | |
318 mxArray *retval = new mxArray (OCTAVE_INT_MX_CLASS, dims (), mxREAL); | |
319 | |
320 OCTAVE_INT_T::val_type *pr = static_cast<OCTAVE_INT_T::val_type *> (retval->get_data ()); | |
321 | |
6686 | 322 mwSize nel = numel (); |
5900 | 323 |
324 const OCTAVE_INT_T *p = matrix.data (); | |
325 | |
6686 | 326 for (mwIndex i = 0; i < nel; i++) |
5900 | 327 pr[i] = p[i].value (); |
328 | |
329 return retval; | |
330 } | |
331 | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
332 #define MAT_MAPPER(FCN) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
333 octave_value FCN (void) const { return matrix.FCN (); } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
334 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
335 MAT_MAPPER (abs) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
336 MAT_MAPPER (signum) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
337 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
338 #undef MAT_MAPPER |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
339 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
340 octave_value imag (void) const |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
341 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
342 return OCTAVE_INT_NDARRAY_T (matrix.dims (), |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
343 static_cast<OCTAVE_INT_T>(0)); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
344 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
345 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
346 #define NO_OP_MAPPER(FCN) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
347 octave_value FCN (void) const { return octave_value (matrix); } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
348 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
349 NO_OP_MAPPER (ceil) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
350 NO_OP_MAPPER (conj) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
351 NO_OP_MAPPER (fix) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
352 NO_OP_MAPPER (floor) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
353 NO_OP_MAPPER (real) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
354 NO_OP_MAPPER (round) |
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7503
diff
changeset
|
355 NO_OP_MAPPER (roundb) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
356 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
357 #undef NO_OP_MAPPER |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
358 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
359 #define BOOL_MAPPER(FCN, VAL) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
360 octave_value FCN (void) const { return boolNDArray (matrix.dims (), VAL); } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
361 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
362 BOOL_MAPPER (finite, true) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
363 BOOL_MAPPER (isinf, false) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
364 BOOL_MAPPER (isna, false) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
365 BOOL_MAPPER (isnan, false) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
366 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
367 #undef BOOL_MAPPER |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
368 |
4904 | 369 private: |
370 | |
371 DECLARE_OCTAVE_ALLOCATOR | |
372 | |
373 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA | |
374 }; | |
375 | |
376 class | |
6693 | 377 OCTINTERP_API |
4904 | 378 OCTAVE_VALUE_INT_SCALAR_T |
379 : public octave_base_int_scalar<OCTAVE_INT_T> | |
380 { | |
381 public: | |
382 | |
383 OCTAVE_VALUE_INT_SCALAR_T (void) | |
384 : octave_base_int_scalar<OCTAVE_INT_T> () { } | |
385 | |
386 OCTAVE_VALUE_INT_SCALAR_T (const OCTAVE_INT_T& nda) | |
387 : octave_base_int_scalar<OCTAVE_INT_T> (nda) { } | |
388 | |
389 ~OCTAVE_VALUE_INT_SCALAR_T (void) { } | |
390 | |
5759 | 391 octave_base_value *clone (void) const |
4904 | 392 { return new OCTAVE_VALUE_INT_SCALAR_T (*this); } |
393 | |
5759 | 394 octave_base_value *empty_clone (void) const |
4904 | 395 { return new OCTAVE_VALUE_INT_SCALAR_T (); } |
396 | |
5885 | 397 octave_value do_index_op (const octave_value_list& idx, |
398 bool resize_ok = false) | |
4983 | 399 { |
400 octave_value retval; | |
401 | |
402 if (idx.valid_scalar_indices ()) | |
403 retval = scalar; | |
404 else | |
405 { | |
5775 | 406 // FIXME -- this doesn't solve the problem of |
4983 | 407 // |
408 // a = 1; a([1,1], [1,1], [1,1]) | |
409 // | |
410 // and similar constructions. Hmm... | |
4964 | 411 |
5775 | 412 // FIXME -- using this constructor avoids narrowing the |
4983 | 413 // 1x1 matrix back to a scalar value. Need a better solution |
414 // to this problem. | |
4964 | 415 |
4983 | 416 octave_value tmp |
417 (new OCTAVE_VALUE_INT_MATRIX_T | |
418 (OCTAVE_VALUE_INT_NDARRAY_EXTRACTOR_FUNCTION ())); | |
4964 | 419 |
4983 | 420 retval = tmp.do_index_op (idx, resize_ok); |
421 } | |
4964 | 422 |
4983 | 423 return retval; |
424 } | |
4964 | 425 |
6069 | 426 bool OCTAVE_TYPE_PREDICATE_FUNCTION (void) const { return true; } |
5895 | 427 |
6223 | 428 bool is_integer_type (void) const { return true; } |
429 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
430 private: |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
431 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
432 template <class _int_scalar> |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
433 _int_scalar convert_gripe () const |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
434 { |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
435 typedef _int_scalar dest_el_type; |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
436 typedef OCTAVE_INT_T src_el_type; |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
437 dest_el_type::clear_trunc_flag (); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
438 _int_scalar retval (scalar); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
439 if (dest_el_type::get_trunc_flag ()) |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
440 { |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
441 gripe_truncated_conversion (src_el_type::type_name (), |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
442 dest_el_type::type_name ()); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
443 dest_el_type::clear_trunc_flag (); |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
444 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
445 } |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
446 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
447 return retval; |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
448 } |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
449 |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
450 public: |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
451 |
5533 | 452 octave_int8 |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
453 int8_scalar_value (void) const { return convert_gripe<octave_int8> (); } |
5533 | 454 |
455 octave_int16 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
456 int16_scalar_value (void) const { return convert_gripe<octave_int16> (); } |
5533 | 457 |
458 octave_int32 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
459 int32_scalar_value (void) const { return convert_gripe<octave_int32> (); } |
5533 | 460 |
461 octave_int64 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
462 int64_scalar_value (void) const { return convert_gripe<octave_int64> (); } |
5533 | 463 |
464 octave_uint8 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
465 uint8_scalar_value (void) const { return convert_gripe<octave_uint8> (); } |
5533 | 466 |
467 octave_uint16 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
468 uint16_scalar_value (void) const { return convert_gripe<octave_uint16> (); } |
5533 | 469 |
470 octave_uint32 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
471 uint32_scalar_value (void) const { return convert_gripe<octave_uint32> (); } |
5533 | 472 |
473 octave_uint64 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
474 uint64_scalar_value (void) const { return convert_gripe<octave_uint64> (); } |
5533 | 475 |
476 int8NDArray | |
477 int8_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
478 { return int8NDArray (dim_vector (1, 1), int8_scalar_value ()); } |
4904 | 479 |
5533 | 480 int16NDArray |
481 int16_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
482 { return int16NDArray (dim_vector (1, 1), int16_scalar_value ()); } |
5533 | 483 |
484 int32NDArray | |
485 int32_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
486 { return int32NDArray (dim_vector (1, 1), int32_scalar_value ()); } |
5533 | 487 |
488 int64NDArray | |
489 int64_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
490 { return int64NDArray (dim_vector (1, 1), int64_scalar_value ()); } |
5533 | 491 |
492 uint8NDArray | |
493 uint8_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
494 { return uint8NDArray (dim_vector (1, 1), uint8_scalar_value ()); } |
5533 | 495 |
496 uint16NDArray | |
497 uint16_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
498 { return uint16NDArray (dim_vector (1, 1), uint16_scalar_value ()); } |
5533 | 499 |
500 uint32NDArray | |
501 uint32_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
502 { return uint32NDArray (dim_vector (1, 1), uint32_scalar_value ()); } |
5533 | 503 |
504 uint64NDArray | |
505 uint64_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
506 { return uint64NDArray (dim_vector (1, 1), uint64_scalar_value ()); } |
4904 | 507 |
5731 | 508 octave_value resize (const dim_vector& dv, bool fill = false) const |
4982 | 509 { |
5731 | 510 if (fill) |
511 { | |
512 OCTAVE_INT_NDARRAY_T retval (dv, 0); | |
513 if (dv.numel()) | |
514 retval(0) = scalar; | |
515 return retval; | |
516 } | |
517 else | |
518 { | |
519 OCTAVE_INT_NDARRAY_T retval (dv); | |
520 if (dv.numel()) | |
521 retval(0) = scalar; | |
522 return retval; | |
523 } | |
4982 | 524 } |
525 | |
7198 | 526 double double_value (bool = false) const { return scalar.double_value (); } |
4983 | 527 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
528 float float_value (bool = false) const { return scalar.float_value (); } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
529 |
7198 | 530 double scalar_value (bool = false) const { return scalar.double_value (); } |
4982 | 531 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
532 float float_scalar_value (bool = false) const { return scalar.float_value (); } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
533 |
6214 | 534 Matrix |
535 matrix_value (bool = false) const | |
536 { | |
537 Matrix retval (1, 1); | |
7198 | 538 retval(0,0) = scalar.double_value (); |
6214 | 539 return retval; |
540 } | |
541 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
542 FloatMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
543 float_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
544 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
545 FloatMatrix retval (1, 1); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
546 retval(0,0) = scalar.float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
547 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
548 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
549 |
6214 | 550 ComplexMatrix |
551 complex_matrix_value (bool = false) const | |
552 { | |
553 ComplexMatrix retval (1, 1); | |
7198 | 554 retval(0,0) = Complex (scalar.double_value ()); |
6214 | 555 return retval; |
556 } | |
557 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
558 FloatComplexMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
559 float_complex_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
560 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
561 FloatComplexMatrix retval (1, 1); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
562 retval(0,0) = FloatComplex (scalar.float_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
563 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
564 } |
6214 | 565 |
4915 | 566 NDArray |
567 array_value (bool = false) const | |
568 { | |
5533 | 569 NDArray retval (dim_vector (1, 1)); |
7198 | 570 retval(0) = scalar.double_value (); |
4963 | 571 return retval; |
572 } | |
573 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
574 FloatNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
575 float_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
576 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
577 FloatNDArray retval (dim_vector (1, 1)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
578 retval(0) = scalar.float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
579 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
580 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
581 |
4963 | 582 ComplexNDArray |
583 complex_array_value (bool = false) const | |
584 { | |
5533 | 585 ComplexNDArray retval (dim_vector (1, 1)); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
586 retval(0) = FloatComplex (scalar.double_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
587 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
588 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
589 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
590 FloatComplexNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
591 float_complex_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
592 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
593 FloatComplexNDArray retval (dim_vector (1, 1)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
594 retval(0) = FloatComplex (scalar.float_value ()); |
4915 | 595 return retval; |
596 } | |
597 | |
5898 | 598 boolNDArray |
5943 | 599 bool_array_value (bool warn = false) const |
5898 | 600 { |
601 boolNDArray retval (dim_vector (1, 1)); | |
5943 | 602 |
603 if (warn && scalar != 0.0 && scalar != 1.0) | |
604 gripe_logical_conversion (); | |
605 | |
7198 | 606 retval(0) = scalar.bool_value (); |
5943 | 607 |
5898 | 608 return retval; |
609 } | |
610 | |
5533 | 611 charNDArray |
612 char_array_value (bool = false) const | |
613 { | |
614 charNDArray retval (dim_vector (1, 1)); | |
7198 | 615 retval(0) = scalar.char_value (); |
5533 | 616 return retval; |
617 } | |
618 | |
5829 | 619 void increment (void) { scalar += 1; } |
620 | |
621 void decrement (void) { scalar -= 1; } | |
622 | |
4938 | 623 idx_vector index_vector (void) const { return idx_vector (scalar); } |
624 | |
4944 | 625 int write (octave_stream& os, int block_size, |
5275 | 626 oct_data_conv::data_type output_type, octave_idx_type skip, |
4944 | 627 oct_mach_info::float_format flt_fmt) const |
628 { | |
629 return os.write (OCTAVE_VALUE_INT_NDARRAY_EXTRACTOR_FUNCTION (), | |
630 block_size, output_type, skip, flt_fmt); | |
631 } | |
632 | |
5900 | 633 // Unsafe. This function exists to support the MEX interface. |
634 // You should not use it anywhere else. | |
635 void *mex_get_data (void) const { return scalar.mex_get_data (); } | |
636 | |
637 mxArray *as_mxArray (void) const | |
638 { | |
639 mxArray *retval = new mxArray (OCTAVE_INT_MX_CLASS, 1, 1, mxREAL); | |
640 | |
641 OCTAVE_INT_T::val_type *pr = static_cast<OCTAVE_INT_T::val_type *> (retval->get_data ()); | |
642 | |
643 pr[0] = scalar.value (); | |
644 | |
645 return retval; | |
646 } | |
647 | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
648 #define SCALAR_MAPPER(FCN) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
649 octave_value FCN (void) const { return scalar.FCN (); } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
650 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
651 SCALAR_MAPPER (abs) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
652 SCALAR_MAPPER (signum) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
653 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
654 #undef SCALAR_MAPPER |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
655 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
656 octave_value imag (void) const { return static_cast<OCTAVE_INT_T>(0); } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
657 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
658 #define NO_OP_MAPPER(FCN) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
659 octave_value FCN (void) const { return octave_value (scalar); } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
660 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
661 NO_OP_MAPPER (ceil) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
662 NO_OP_MAPPER (conj) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
663 NO_OP_MAPPER (fix) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
664 NO_OP_MAPPER (floor) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
665 NO_OP_MAPPER (real) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
666 NO_OP_MAPPER (round) |
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7503
diff
changeset
|
667 NO_OP_MAPPER (roundb) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
668 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
669 #undef NO_OP_MAPPER |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
670 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
671 #define BOOL_MAPPER(FCN, VAL) octave_value FCN (void) const { return VAL; } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
672 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
673 BOOL_MAPPER (finite, true) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
674 BOOL_MAPPER (isinf, false) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
675 BOOL_MAPPER (isna, false) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
676 BOOL_MAPPER (isnan, false) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
677 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
678 #undef BOOL_MAPPER |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
679 |
4904 | 680 private: |
681 | |
682 DECLARE_OCTAVE_ALLOCATOR | |
683 | |
684 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA | |
685 }; | |
686 | |
687 /* | |
688 ;;; Local Variables: *** | |
689 ;;; mode: C++ *** | |
690 ;;; End: *** | |
691 */ |