Mercurial > octave
annotate src/ov-intx.h @ 10405:cc69a17ec801
remove integer math warnings
author | Jaroslav Hajek <highegg@gmail.com> |
---|---|
date | Tue, 09 Mar 2010 08:06:30 +0100 |
parents | f3b65e1ae355 |
children | 4d1fc073fbb7 |
rev | line source |
---|---|
4904 | 1 /* |
2 | |
8920 | 3 Copyright (C) 2004, 2005, 2006, 2007, 2008 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 | |
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
25 #include <iosfwd> |
4904 | 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 |
8321
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
45 : public octave_base_int_matrix<intNDArray<OCTAVE_INT_T> > |
4904 | 46 { |
47 public: | |
48 | |
49 OCTAVE_VALUE_INT_MATRIX_T (void) | |
8321
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
50 : octave_base_int_matrix<intNDArray<OCTAVE_INT_T> > () { } |
4904 | 51 |
8321
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
52 OCTAVE_VALUE_INT_MATRIX_T (const intNDArray<OCTAVE_INT_T>& nda) |
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
53 : octave_base_int_matrix<intNDArray<OCTAVE_INT_T> > (nda) { } |
4904 | 54 |
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9685
diff
changeset
|
55 OCTAVE_VALUE_INT_MATRIX_T (const Array<OCTAVE_INT_T>& nda) |
8321
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
56 : octave_base_int_matrix<intNDArray<OCTAVE_INT_T> > |
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
57 (intNDArray<OCTAVE_INT_T> (nda)) { } |
7064 | 58 |
4904 | 59 ~OCTAVE_VALUE_INT_MATRIX_T (void) { } |
60 | |
5759 | 61 octave_base_value *clone (void) const |
4904 | 62 { return new OCTAVE_VALUE_INT_MATRIX_T (*this); } |
63 | |
5759 | 64 octave_base_value *empty_clone (void) const |
4904 | 65 { return new OCTAVE_VALUE_INT_MATRIX_T (); } |
66 | |
6069 | 67 bool OCTAVE_TYPE_PREDICATE_FUNCTION (void) const { return true; } |
5895 | 68 |
6223 | 69 bool is_integer_type (void) const { return true; } |
70 | |
9685 | 71 builtin_type_t builtin_type (void) const { return OCTAVE_INT_BTYP; } |
72 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
73 public: |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
74 |
5533 | 75 int8NDArray |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
76 int8_array_value (void) const { return int8NDArray (matrix); } |
5533 | 77 |
78 int16NDArray | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
79 int16_array_value (void) const { return int16NDArray (matrix); } |
5533 | 80 |
81 int32NDArray | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
82 int32_array_value (void) const { return int32NDArray (matrix); } |
5533 | 83 |
84 int64NDArray | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
85 int64_array_value (void) const { return int64NDArray (matrix); } |
5533 | 86 |
87 uint8NDArray | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
88 uint8_array_value (void) const { return uint8NDArray (matrix); } |
5533 | 89 |
90 uint16NDArray | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
91 uint16_array_value (void) const { return uint16NDArray (matrix); } |
5533 | 92 |
93 uint32NDArray | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
94 uint32_array_value (void) const { return uint32NDArray (matrix); } |
5533 | 95 |
96 uint64NDArray | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
97 uint64_array_value (void) const { return uint64NDArray (matrix); } |
4904 | 98 |
4982 | 99 double |
100 double_value (bool = false) const | |
101 { | |
102 double retval = lo_ieee_nan_value (); | |
103 | |
104 if (numel () > 0) | |
10313 | 105 { |
106 gripe_implicit_conversion ("Octave:array-as-scalar", | |
107 type_name (), "real scalar"); | |
4982 | 108 |
10313 | 109 retval = matrix(0).double_value (); |
110 } | |
4982 | 111 else |
10313 | 112 gripe_invalid_conversion (type_name (), "real scalar"); |
4982 | 113 |
114 return retval; | |
115 | |
116 } | |
117 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
118 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
119 float_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
120 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
121 float retval = lo_ieee_float_nan_value (); |
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 if (numel () > 0) |
10313 | 124 { |
125 gripe_implicit_conversion ("Octave:array-as-scalar", | |
126 type_name (), "real scalar"); | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
127 |
10313 | 128 retval = matrix(0).float_value (); |
129 } | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
130 else |
10313 | 131 gripe_invalid_conversion (type_name (), "real scalar"); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
132 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
133 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
134 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
135 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
136 |
4983 | 137 double scalar_value (bool = false) const { return double_value (); } |
4982 | 138 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
139 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
|
140 |
6214 | 141 Matrix |
142 matrix_value (bool = false) const | |
143 { | |
144 Matrix retval; | |
145 dim_vector dv = dims (); | |
146 if (dv.length () > 2) | |
10313 | 147 error ("invalid conversion of %s to Matrix", type_name().c_str ()); |
6214 | 148 else |
10313 | 149 { |
150 retval = Matrix (dv(0), dv(1)); | |
151 double *vec = retval.fortran_vec (); | |
152 octave_idx_type nel = matrix.numel (); | |
153 for (octave_idx_type i = 0; i < nel; i++) | |
154 vec[i] = matrix(i).double_value (); | |
155 } | |
6214 | 156 return retval; |
157 } | |
158 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
159 FloatMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
160 float_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
161 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
162 FloatMatrix retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
163 dim_vector dv = dims (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
164 if (dv.length () > 2) |
10313 | 165 error ("invalid conversion of %s to FloatMatrix", type_name().c_str ()); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
166 else |
10313 | 167 { |
168 retval = FloatMatrix (dv(0), dv(1)); | |
169 float *vec = retval.fortran_vec (); | |
170 octave_idx_type nel = matrix.numel (); | |
171 for (octave_idx_type i = 0; i < nel; i++) | |
172 vec[i] = matrix(i).float_value (); | |
173 } | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
174 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
175 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
176 |
6214 | 177 ComplexMatrix |
178 complex_matrix_value (bool = false) const | |
179 { | |
180 ComplexMatrix retval; | |
181 dim_vector dv = dims(); | |
182 if (dv.length () > 2) | |
10313 | 183 error ("invalid conversion of %s to Matrix", type_name().c_str ()); |
6214 | 184 else |
10313 | 185 { |
186 retval = ComplexMatrix (dv(0), dv(1)); | |
187 Complex *vec = retval.fortran_vec (); | |
188 octave_idx_type nel = matrix.numel (); | |
189 for (octave_idx_type i = 0; i < nel; i++) | |
190 vec[i] = Complex (matrix(i).double_value ()); | |
191 } | |
6214 | 192 return retval; |
193 } | |
194 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
195 FloatComplexMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
196 float_complex_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
197 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
198 FloatComplexMatrix retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
199 dim_vector dv = dims(); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
200 if (dv.length () > 2) |
10313 | 201 error ("invalid conversion of %s to FloatMatrix", type_name().c_str ()); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
202 else |
10313 | 203 { |
204 retval = FloatComplexMatrix (dv(0), dv(1)); | |
205 FloatComplex *vec = retval.fortran_vec (); | |
206 octave_idx_type nel = matrix.numel (); | |
207 for (octave_idx_type i = 0; i < nel; i++) | |
208 vec[i] = FloatComplex (matrix(i).float_value ()); | |
209 } | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
210 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
211 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
212 |
4915 | 213 NDArray |
214 array_value (bool = false) const | |
215 { | |
216 NDArray retval (matrix.dims ()); | |
6214 | 217 double *vec = retval.fortran_vec (); |
218 octave_idx_type nel = matrix.numel (); | |
219 for (octave_idx_type i = 0; i < nel; i++) | |
7198 | 220 vec[i] = matrix(i).double_value (); |
4963 | 221 return retval; |
222 } | |
223 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
224 FloatNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
225 float_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
226 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
227 FloatNDArray retval (matrix.dims ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
228 float *vec = retval.fortran_vec (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
229 octave_idx_type nel = matrix.numel (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
230 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
|
231 vec[i] = matrix(i).float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
232 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
233 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
234 |
4963 | 235 ComplexNDArray |
236 complex_array_value (bool = false) const | |
237 { | |
238 ComplexNDArray retval (matrix.dims ()); | |
6214 | 239 Complex *vec = retval.fortran_vec (); |
240 octave_idx_type nel = matrix.numel (); | |
241 for (octave_idx_type i = 0; i < nel; i++) | |
7198 | 242 vec[i] = Complex (matrix(i).double_value ()); |
4915 | 243 return retval; |
244 } | |
245 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
246 FloatComplexNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
247 float_complex_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
248 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
249 FloatComplexNDArray retval (matrix.dims ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
250 FloatComplex *vec = retval.fortran_vec (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
251 octave_idx_type nel = matrix.numel (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
252 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
|
253 vec[i] = FloatComplex (matrix(i).float_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
254 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
255 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
256 |
5898 | 257 boolNDArray |
5943 | 258 bool_array_value (bool warn = false) const |
5898 | 259 { |
260 boolNDArray retval (dims ()); | |
261 | |
262 octave_idx_type nel = numel (); | |
5943 | 263 |
264 if (warn && matrix.any_element_not_one_or_zero ()) | |
265 gripe_logical_conversion (); | |
266 | |
6214 | 267 bool *vec = retval.fortran_vec (); |
5898 | 268 for (octave_idx_type i = 0; i < nel; i++) |
7198 | 269 vec[i] = matrix(i).bool_value (); |
5898 | 270 |
271 return retval; | |
272 } | |
273 | |
5533 | 274 charNDArray |
275 char_array_value (bool = false) const | |
276 { | |
277 charNDArray retval (dims ()); | |
278 | |
279 octave_idx_type nel = numel (); | |
280 | |
6214 | 281 char *vec = retval.fortran_vec (); |
5533 | 282 for (octave_idx_type i = 0; i < nel; i++) |
7198 | 283 vec[i] = matrix(i).char_value (); |
5533 | 284 |
285 return retval; | |
286 } | |
287 | |
9606
a04352386a6b
clear index cache on ++,-- operators
Jaroslav Hajek <highegg@gmail.com>
parents:
9358
diff
changeset
|
288 // Use matrix_ref here to clear index cache. |
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
289 void increment (void) |
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
290 { |
9606
a04352386a6b
clear index cache on ++,-- operators
Jaroslav Hajek <highegg@gmail.com>
parents:
9358
diff
changeset
|
291 matrix_ref() += OCTAVE_INT_T (1); |
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
292 } |
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
293 |
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
294 void decrement (void) |
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
295 { |
9606
a04352386a6b
clear index cache on ++,-- operators
Jaroslav Hajek <highegg@gmail.com>
parents:
9358
diff
changeset
|
296 matrix_ref() -= OCTAVE_INT_T (1); |
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
297 } |
5829 | 298 |
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9606
diff
changeset
|
299 void changesign (void) |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9606
diff
changeset
|
300 { |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9606
diff
changeset
|
301 matrix_ref ().changesign (); |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9606
diff
changeset
|
302 } |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9606
diff
changeset
|
303 |
9350
16a5f9e1fdb3
cache idx_vector result in matrices once used for indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
304 idx_vector index_vector (void) const |
16a5f9e1fdb3
cache idx_vector result in matrices once used for indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
305 { return idx_cache ? *idx_cache : set_idx_cache (idx_vector (matrix)); } |
4938 | 306 |
4944 | 307 int write (octave_stream& os, int block_size, |
10313 | 308 oct_data_conv::data_type output_type, int skip, |
309 oct_mach_info::float_format flt_fmt) const | |
4944 | 310 { return os.write (matrix, block_size, output_type, skip, flt_fmt); } |
311 | |
9358
d4b1314a7c31
mex.cc (mxArray_octave_value::get_data): avoid enumerating types that can be handled as foreign
John W. Eaton <jwe@octave.org>
parents:
9350
diff
changeset
|
312 // Unsafe. This function exists to support the MEX interface. |
d4b1314a7c31
mex.cc (mxArray_octave_value::get_data): avoid enumerating types that can be handled as foreign
John W. Eaton <jwe@octave.org>
parents:
9350
diff
changeset
|
313 // You should not use it anywhere else. |
d4b1314a7c31
mex.cc (mxArray_octave_value::get_data): avoid enumerating types that can be handled as foreign
John W. Eaton <jwe@octave.org>
parents:
9350
diff
changeset
|
314 void *mex_get_data (void) const { return matrix.mex_get_data (); } |
d4b1314a7c31
mex.cc (mxArray_octave_value::get_data): avoid enumerating types that can be handled as foreign
John W. Eaton <jwe@octave.org>
parents:
9350
diff
changeset
|
315 |
5900 | 316 mxArray *as_mxArray (void) const |
317 { | |
318 mxArray *retval = new mxArray (OCTAVE_INT_MX_CLASS, dims (), mxREAL); | |
319 | |
320 OCTAVE_INT_T::val_type *pr = static_cast<OCTAVE_INT_T::val_type *> (retval->get_data ()); | |
321 | |
6686 | 322 mwSize nel = numel (); |
5900 | 323 |
324 const OCTAVE_INT_T *p = matrix.data (); | |
325 | |
6686 | 326 for (mwIndex i = 0; i < nel; i++) |
5900 | 327 pr[i] = p[i].value (); |
328 | |
329 return retval; | |
330 } | |
331 | |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
332 octave_value map (unary_mapper_t umap) const |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
333 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
334 switch (umap) |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
335 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
336 case umap_abs: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
337 return matrix.abs (); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
338 case umap_signum: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
339 return matrix.signum (); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
340 case umap_ceil: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
341 case umap_conj: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
342 case umap_fix: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
343 case umap_floor: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
344 case umap_real: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
345 case umap_round: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
346 return matrix; |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
347 case umap_imag: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
348 return intNDArray<OCTAVE_INT_T> (matrix.dims (), OCTAVE_INT_T ()); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
349 case umap_isnan: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
350 case umap_isna: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
351 case umap_isinf: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
352 return boolNDArray (matrix.dims (), false); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
353 case umap_finite: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
354 return boolNDArray (matrix.dims (), true); |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
355 |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
356 default: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
357 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
358 octave_matrix m (array_value ()); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
359 return m.map (umap); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
360 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
361 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
362 } |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
363 |
4904 | 364 private: |
365 | |
366 DECLARE_OCTAVE_ALLOCATOR | |
367 | |
368 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA | |
369 }; | |
370 | |
371 class | |
6693 | 372 OCTINTERP_API |
4904 | 373 OCTAVE_VALUE_INT_SCALAR_T |
374 : public octave_base_int_scalar<OCTAVE_INT_T> | |
375 { | |
376 public: | |
377 | |
378 OCTAVE_VALUE_INT_SCALAR_T (void) | |
379 : octave_base_int_scalar<OCTAVE_INT_T> () { } | |
380 | |
381 OCTAVE_VALUE_INT_SCALAR_T (const OCTAVE_INT_T& nda) | |
382 : octave_base_int_scalar<OCTAVE_INT_T> (nda) { } | |
383 | |
384 ~OCTAVE_VALUE_INT_SCALAR_T (void) { } | |
385 | |
5759 | 386 octave_base_value *clone (void) const |
4904 | 387 { return new OCTAVE_VALUE_INT_SCALAR_T (*this); } |
388 | |
5759 | 389 octave_base_value *empty_clone (void) const |
8389
ff5892c8ddd0
fix integer assignment to non-existing variables
Jaroslav Hajek <highegg@gmail.com>
parents:
8321
diff
changeset
|
390 { return new OCTAVE_VALUE_INT_MATRIX_T (); } |
4904 | 391 |
5885 | 392 octave_value do_index_op (const octave_value_list& idx, |
10313 | 393 bool resize_ok = false) |
4983 | 394 { |
8437
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
395 // FIXME -- this doesn't solve the problem of |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
396 // |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
397 // a = 1; a([1,1], [1,1], [1,1]) |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
398 // |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
399 // and similar constructions. Hmm... |
4964 | 400 |
8437
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
401 // FIXME -- using this constructor avoids narrowing the |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
402 // 1x1 matrix back to a scalar value. Need a better solution |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
403 // to this problem. |
4964 | 404 |
8437
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
405 octave_value tmp |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
406 (new OCTAVE_VALUE_INT_MATRIX_T |
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
407 (OCTAVE_VALUE_INT_NDARRAY_EXTRACTOR_FUNCTION ())); |
4964 | 408 |
8437
f00578b495e9
remove valid_as_scalar_index
Jaroslav Hajek <highegg@gmail.com>
parents:
8389
diff
changeset
|
409 return tmp.do_index_op (idx, resize_ok); |
4983 | 410 } |
4964 | 411 |
6069 | 412 bool OCTAVE_TYPE_PREDICATE_FUNCTION (void) const { return true; } |
5895 | 413 |
6223 | 414 bool is_integer_type (void) const { return true; } |
415 | |
9685 | 416 builtin_type_t builtin_type (void) const { return OCTAVE_INT_BTYP; } |
417 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
418 public: |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
419 |
5533 | 420 octave_int8 |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
421 int8_scalar_value (void) const { return octave_int8 (scalar); } |
5533 | 422 |
423 octave_int16 | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
424 int16_scalar_value (void) const { return octave_int16 (scalar); } |
5533 | 425 |
426 octave_int32 | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
427 int32_scalar_value (void) const { return octave_int32 (scalar); } |
5533 | 428 |
429 octave_int64 | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
430 int64_scalar_value (void) const { return octave_int64 (scalar); } |
5533 | 431 |
432 octave_uint8 | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
433 uint8_scalar_value (void) const { return octave_uint8 (scalar); } |
5533 | 434 |
435 octave_uint16 | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
436 uint16_scalar_value (void) const { return octave_uint16 (scalar); } |
5533 | 437 |
438 octave_uint32 | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
439 uint32_scalar_value (void) const { return octave_uint32 (scalar); } |
5533 | 440 |
441 octave_uint64 | |
10405
cc69a17ec801
remove integer math warnings
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
442 uint64_scalar_value (void) const { return octave_uint64 (scalar); } |
5533 | 443 |
444 int8NDArray | |
445 int8_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
446 { return int8NDArray (dim_vector (1, 1), int8_scalar_value ()); } |
4904 | 447 |
5533 | 448 int16NDArray |
449 int16_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
450 { return int16NDArray (dim_vector (1, 1), int16_scalar_value ()); } |
5533 | 451 |
452 int32NDArray | |
453 int32_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
454 { return int32NDArray (dim_vector (1, 1), int32_scalar_value ()); } |
5533 | 455 |
456 int64NDArray | |
457 int64_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
458 { return int64NDArray (dim_vector (1, 1), int64_scalar_value ()); } |
5533 | 459 |
460 uint8NDArray | |
461 uint8_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
462 { return uint8NDArray (dim_vector (1, 1), uint8_scalar_value ()); } |
5533 | 463 |
464 uint16NDArray | |
465 uint16_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
466 { return uint16NDArray (dim_vector (1, 1), uint16_scalar_value ()); } |
5533 | 467 |
468 uint32NDArray | |
469 uint32_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
470 { return uint32NDArray (dim_vector (1, 1), uint32_scalar_value ()); } |
5533 | 471 |
472 uint64NDArray | |
473 uint64_array_value (void) const | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
474 { return uint64NDArray (dim_vector (1, 1), uint64_scalar_value ()); } |
4904 | 475 |
5731 | 476 octave_value resize (const dim_vector& dv, bool fill = false) const |
4982 | 477 { |
5731 | 478 if (fill) |
10313 | 479 { |
480 intNDArray<OCTAVE_INT_T> retval (dv, 0); | |
481 if (dv.numel()) | |
482 retval(0) = scalar; | |
483 return retval; | |
484 } | |
5731 | 485 else |
10313 | 486 { |
487 intNDArray<OCTAVE_INT_T> retval (dv); | |
488 if (dv.numel()) | |
489 retval(0) = scalar; | |
490 return retval; | |
491 } | |
4982 | 492 } |
493 | |
7198 | 494 double double_value (bool = false) const { return scalar.double_value (); } |
4983 | 495 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
496 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
|
497 |
7198 | 498 double scalar_value (bool = false) const { return scalar.double_value (); } |
4982 | 499 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
500 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
|
501 |
6214 | 502 Matrix |
503 matrix_value (bool = false) const | |
504 { | |
505 Matrix retval (1, 1); | |
7198 | 506 retval(0,0) = scalar.double_value (); |
6214 | 507 return retval; |
508 } | |
509 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
510 FloatMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
511 float_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
512 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
513 FloatMatrix retval (1, 1); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
514 retval(0,0) = scalar.float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
515 return retval; |
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 |
6214 | 518 ComplexMatrix |
519 complex_matrix_value (bool = false) const | |
520 { | |
521 ComplexMatrix retval (1, 1); | |
7198 | 522 retval(0,0) = Complex (scalar.double_value ()); |
6214 | 523 return retval; |
524 } | |
525 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
526 FloatComplexMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
527 float_complex_matrix_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
528 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
529 FloatComplexMatrix retval (1, 1); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
530 retval(0,0) = FloatComplex (scalar.float_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
531 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
532 } |
6214 | 533 |
4915 | 534 NDArray |
535 array_value (bool = false) const | |
536 { | |
5533 | 537 NDArray retval (dim_vector (1, 1)); |
7198 | 538 retval(0) = scalar.double_value (); |
4963 | 539 return retval; |
540 } | |
541 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
542 FloatNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
543 float_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
544 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
545 FloatNDArray retval (dim_vector (1, 1)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
546 retval(0) = scalar.float_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
547 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
548 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
549 |
4963 | 550 ComplexNDArray |
551 complex_array_value (bool = false) const | |
552 { | |
5533 | 553 ComplexNDArray retval (dim_vector (1, 1)); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
554 retval(0) = FloatComplex (scalar.double_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
555 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
556 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
557 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
558 FloatComplexNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
559 float_complex_array_value (bool = false) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
560 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
561 FloatComplexNDArray retval (dim_vector (1, 1)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7636
diff
changeset
|
562 retval(0) = FloatComplex (scalar.float_value ()); |
4915 | 563 return retval; |
564 } | |
565 | |
5898 | 566 boolNDArray |
5943 | 567 bool_array_value (bool warn = false) const |
5898 | 568 { |
569 boolNDArray retval (dim_vector (1, 1)); | |
5943 | 570 |
571 if (warn && scalar != 0.0 && scalar != 1.0) | |
572 gripe_logical_conversion (); | |
573 | |
7198 | 574 retval(0) = scalar.bool_value (); |
5943 | 575 |
5898 | 576 return retval; |
577 } | |
578 | |
5533 | 579 charNDArray |
580 char_array_value (bool = false) const | |
581 { | |
582 charNDArray retval (dim_vector (1, 1)); | |
7198 | 583 retval(0) = scalar.char_value (); |
5533 | 584 return retval; |
585 } | |
586 | |
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
587 void increment (void) |
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
588 { |
8321
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
589 scalar += OCTAVE_INT_T (1); |
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
590 } |
5829 | 591 |
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
592 void decrement (void) |
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
593 { |
8321
69b6127f6962
better use of templates in ov-intx.h
John W. Eaton <jwe@octave.org>
parents:
8039
diff
changeset
|
594 scalar -= OCTAVE_INT_T (1); |
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
7999
diff
changeset
|
595 } |
5829 | 596 |
4938 | 597 idx_vector index_vector (void) const { return idx_vector (scalar); } |
598 | |
4944 | 599 int write (octave_stream& os, int block_size, |
10313 | 600 oct_data_conv::data_type output_type, octave_idx_type skip, |
601 oct_mach_info::float_format flt_fmt) const | |
4944 | 602 { |
603 return os.write (OCTAVE_VALUE_INT_NDARRAY_EXTRACTOR_FUNCTION (), | |
10313 | 604 block_size, output_type, skip, flt_fmt); |
4944 | 605 } |
606 | |
5900 | 607 // Unsafe. This function exists to support the MEX interface. |
608 // You should not use it anywhere else. | |
609 void *mex_get_data (void) const { return scalar.mex_get_data (); } | |
610 | |
611 mxArray *as_mxArray (void) const | |
612 { | |
613 mxArray *retval = new mxArray (OCTAVE_INT_MX_CLASS, 1, 1, mxREAL); | |
614 | |
615 OCTAVE_INT_T::val_type *pr = static_cast<OCTAVE_INT_T::val_type *> (retval->get_data ()); | |
616 | |
617 pr[0] = scalar.value (); | |
618 | |
619 return retval; | |
620 } | |
621 | |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
622 octave_value map (unary_mapper_t umap) const |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
623 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
624 switch (umap) |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
625 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
626 case umap_abs: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
627 return scalar.abs (); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
628 case umap_signum: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
629 return scalar.signum (); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
630 case umap_ceil: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
631 case umap_conj: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
632 case umap_fix: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
633 case umap_floor: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
634 case umap_real: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
635 case umap_round: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
636 return scalar; |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
637 case umap_imag: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
638 return OCTAVE_INT_T (); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
639 case umap_isnan: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
640 case umap_isna: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
641 case umap_isinf: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
642 return false; |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
643 case umap_finite: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
644 return true; |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
645 |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
646 default: |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
647 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
648 octave_scalar m (scalar_value ()); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
649 return m.map (umap); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
650 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
651 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
652 } |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7201
diff
changeset
|
653 |
4904 | 654 private: |
655 | |
656 DECLARE_OCTAVE_ALLOCATOR | |
657 | |
658 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA | |
659 }; |