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