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