Mercurial > octave
annotate src/ov-re-mat.cc @ 8366:8b1a2555c4e2
implement diagonal matrix objects
* * *
author | Jaroslav Hajek <highegg@gmail.com> |
---|---|
date | Wed, 03 Dec 2008 13:32:57 +0100 |
parents | c777f3ce02d8 |
children | 25bc2d31e1bf |
rev | line source |
---|---|
2376 | 1 /* |
2 | |
7017 | 3 Copyright (C) 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, |
4 2006, 2007 John W. Eaton | |
2376 | 5 |
6 This file is part of Octave. | |
7 | |
8 Octave is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
11 option) any later version. | |
2376 | 12 |
13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
7016 | 19 along with Octave; see the file COPYING. If not, see |
20 <http://www.gnu.org/licenses/>. | |
2376 | 21 |
22 */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
25 #include <config.h> | |
26 #endif | |
27 | |
4100 | 28 #include <climits> |
29 | |
3503 | 30 #include <iostream> |
4726 | 31 #include <vector> |
2901 | 32 |
4944 | 33 #include "data-conv.h" |
2376 | 34 #include "lo-ieee.h" |
35 #include "lo-utils.h" | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
36 #include "lo-specfun.h" |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
37 #include "lo-mappers.h" |
4944 | 38 #include "mach-info.h" |
2376 | 39 #include "mx-base.h" |
4153 | 40 #include "quit.h" |
2376 | 41 |
4901 | 42 #include "defun.h" |
2376 | 43 #include "gripes.h" |
44 #include "oct-obj.h" | |
2979 | 45 #include "oct-lvalue.h" |
4944 | 46 #include "oct-stream.h" |
2410 | 47 #include "ops.h" |
3219 | 48 #include "ov-base.h" |
49 #include "ov-base-mat.h" | |
50 #include "ov-base-mat.cc" | |
2410 | 51 #include "ov-scalar.h" |
2376 | 52 #include "ov-re-mat.h" |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
53 #include "ov-flt-re-mat.h" |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
54 #include "ov-complex.h" |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
55 #include "ov-cx-mat.h" |
7004 | 56 #include "ov-re-sparse.h" |
4901 | 57 #include "ov-type-conv.h" |
2376 | 58 #include "pr-output.h" |
2948 | 59 #include "variables.h" |
2376 | 60 |
4687 | 61 #include "byte-swap.h" |
62 #include "ls-oct-ascii.h" | |
63 #include "ls-utils.h" | |
4805 | 64 #include "ls-hdf5.h" |
4687 | 65 |
4100 | 66 #if ! defined (UCHAR_MAX) |
67 #define UCHAR_MAX 255 | |
68 #endif | |
69 | |
4513 | 70 template class octave_base_matrix<NDArray>; |
2376 | 71 |
3219 | 72 DEFINE_OCTAVE_ALLOCATOR (octave_matrix); |
2477 | 73 |
4612 | 74 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_matrix, "matrix", "double"); |
2376 | 75 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
76 static octave_base_value * |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
77 default_numeric_demotion_function (const octave_base_value& a) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
78 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
79 CAST_CONV_ARG (const octave_matrix&); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
80 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
81 return new octave_float_matrix (v.float_matrix_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
82 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
83 |
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
84 octave_base_value::type_conv_info |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
85 octave_matrix::numeric_demotion_function (void) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
86 { |
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
87 return octave_base_value::type_conv_info(default_numeric_demotion_function, |
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
88 octave_float_matrix::static_type_id ()); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
89 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
90 |
5759 | 91 octave_base_value * |
2410 | 92 octave_matrix::try_narrowing_conversion (void) |
93 { | |
5759 | 94 octave_base_value *retval = 0; |
2410 | 95 |
4513 | 96 if (matrix.nelem () == 1) |
97 retval = new octave_scalar (matrix (0)); | |
2410 | 98 |
99 return retval; | |
100 } | |
101 | |
2376 | 102 bool |
103 octave_matrix::valid_as_scalar_index (void) const | |
104 { | |
5775 | 105 // FIXME |
2376 | 106 return false; |
107 } | |
108 | |
109 double | |
110 octave_matrix::double_value (bool) const | |
111 { | |
4102 | 112 double retval = lo_ieee_nan_value (); |
2376 | 113 |
4645 | 114 if (numel () > 0) |
4455 | 115 { |
5781 | 116 gripe_implicit_conversion ("Octave:array-as-scalar", |
117 "real matrix", "real scalar"); | |
4455 | 118 |
119 retval = matrix (0, 0); | |
120 } | |
2376 | 121 else |
122 gripe_invalid_conversion ("real matrix", "real scalar"); | |
123 | |
124 return retval; | |
125 } | |
126 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
127 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
128 octave_matrix::float_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
129 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
130 float retval = lo_ieee_float_nan_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
131 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
132 if (numel () > 0) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
133 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
134 gripe_implicit_conversion ("Octave:array-as-scalar", |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
135 "real matrix", "real scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
136 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
137 retval = matrix (0, 0); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
138 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
139 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
140 gripe_invalid_conversion ("real matrix", "real scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
141 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
142 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
143 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
144 |
5775 | 145 // FIXME |
4513 | 146 |
147 Matrix | |
148 octave_matrix::matrix_value (bool) const | |
149 { | |
150 return matrix.matrix_value (); | |
151 } | |
152 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
153 FloatMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
154 octave_matrix::float_matrix_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
155 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
156 return FloatMatrix (matrix.matrix_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
157 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
158 |
2376 | 159 Complex |
160 octave_matrix::complex_value (bool) const | |
161 { | |
4102 | 162 double tmp = lo_ieee_nan_value (); |
163 | |
164 Complex retval (tmp, tmp); | |
2376 | 165 |
4455 | 166 if (rows () > 0 && columns () > 0) |
167 { | |
5781 | 168 gripe_implicit_conversion ("Octave:array-as-scalar", |
169 "real matrix", "complex scalar"); | |
4455 | 170 |
171 retval = matrix (0, 0); | |
172 } | |
2376 | 173 else |
174 gripe_invalid_conversion ("real matrix", "complex scalar"); | |
175 | |
176 return retval; | |
177 } | |
178 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
179 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
180 octave_matrix::float_complex_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
181 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
182 float tmp = lo_ieee_float_nan_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
183 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
184 FloatComplex retval (tmp, tmp); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
185 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
186 if (rows () > 0 && columns () > 0) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
187 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
188 gripe_implicit_conversion ("Octave:array-as-scalar", |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
189 "real matrix", "complex scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
190 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
191 retval = matrix (0, 0); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
192 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
193 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
194 gripe_invalid_conversion ("real matrix", "complex scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
195 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
196 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
197 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
198 |
5775 | 199 // FIXME |
4513 | 200 |
201 ComplexMatrix | |
202 octave_matrix::complex_matrix_value (bool) const | |
203 { | |
204 return ComplexMatrix (matrix.matrix_value ()); | |
205 } | |
206 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
207 FloatComplexMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
208 octave_matrix::float_complex_matrix_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
209 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
210 return FloatComplexMatrix (matrix.matrix_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
211 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
212 |
4699 | 213 ComplexNDArray |
214 octave_matrix::complex_array_value (bool) const | |
215 { | |
216 return ComplexNDArray (matrix); | |
217 } | |
218 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
219 FloatComplexNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
220 octave_matrix::float_complex_array_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
221 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
222 return FloatComplexNDArray (matrix); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
223 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
224 |
5898 | 225 boolNDArray |
5943 | 226 octave_matrix::bool_array_value (bool warn) const |
5898 | 227 { |
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7885
diff
changeset
|
228 if (matrix.any_element_is_nan ()) |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7885
diff
changeset
|
229 error ("invalid conversion from NaN to logical"); |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7885
diff
changeset
|
230 else if (warn && matrix.any_element_not_one_or_zero ()) |
5943 | 231 gripe_logical_conversion (); |
232 | |
5898 | 233 return boolNDArray (matrix); |
234 } | |
235 | |
4758 | 236 charNDArray |
237 octave_matrix::char_array_value (bool) const | |
238 { | |
239 charNDArray retval (dims ()); | |
240 | |
5275 | 241 octave_idx_type nel = numel (); |
4758 | 242 |
5275 | 243 for (octave_idx_type i = 0; i < nel; i++) |
4758 | 244 retval.elem (i) = static_cast<char>(matrix.elem (i)); |
245 | |
246 return retval; | |
247 } | |
248 | |
5164 | 249 SparseMatrix |
250 octave_matrix::sparse_matrix_value (bool) const | |
251 { | |
252 return SparseMatrix (matrix.matrix_value ()); | |
253 } | |
254 | |
255 SparseComplexMatrix | |
256 octave_matrix::sparse_complex_matrix_value (bool) const | |
257 { | |
5775 | 258 // FIXME Need a SparseComplexMatrix (Matrix) constructor to make |
5164 | 259 // this function more efficient. Then this should become |
260 // return SparseComplexMatrix (matrix.matrix_value ()); | |
261 return SparseComplexMatrix (sparse_matrix_value ()); | |
262 } | |
263 | |
2376 | 264 octave_value |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
265 octave_matrix::diag (octave_idx_type k) const |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
266 { |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
267 octave_value retval; |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
268 if (k == 0 && matrix.ndims () == 2 |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
269 && (matrix.rows () == 1 || matrix.columns () == 1)) |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
270 retval = DiagMatrix (DiagArray2<double> (matrix)); |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
271 else |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
272 retval = octave_base_matrix<NDArray>::diag (k); |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
273 |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
274 return retval; |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
275 } |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
276 |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
277 octave_value |
5279 | 278 octave_matrix::convert_to_str_internal (bool, bool, char type) const |
2376 | 279 { |
280 octave_value retval; | |
4844 | 281 dim_vector dv = dims (); |
5862 | 282 octave_idx_type nel = dv.numel (); |
283 | |
284 charNDArray chm (dv); | |
2376 | 285 |
5862 | 286 bool warned = false; |
287 | |
288 for (octave_idx_type i = 0; i < nel; i++) | |
2376 | 289 { |
5862 | 290 OCTAVE_QUIT; |
291 | |
292 double d = matrix (i); | |
4844 | 293 |
5862 | 294 if (xisnan (d)) |
295 { | |
296 ::error ("invalid conversion from NaN to character"); | |
297 return retval; | |
298 } | |
299 else | |
4844 | 300 { |
5862 | 301 int ival = NINT (d); |
4844 | 302 |
5862 | 303 if (ival < 0 || ival > UCHAR_MAX) |
304 { | |
305 // FIXME -- is there something | |
306 // better we could do? | |
2376 | 307 |
5862 | 308 ival = 0; |
309 | |
310 if (! warned) | |
311 { | |
312 ::warning ("range error for conversion to character value"); | |
313 warned = true; | |
314 } | |
4844 | 315 } |
2376 | 316 |
5862 | 317 chm (i) = static_cast<char> (ival); |
318 } | |
319 } | |
2376 | 320 |
5862 | 321 retval = octave_value (chm, true, type); |
2376 | 322 |
323 return retval; | |
324 } | |
325 | |
4687 | 326 bool |
6974 | 327 octave_matrix::save_ascii (std::ostream& os) |
4687 | 328 { |
329 dim_vector d = dims (); | |
5958 | 330 |
4687 | 331 if (d.length () > 2) |
332 { | |
333 NDArray tmp = array_value (); | |
334 | |
335 os << "# ndims: " << d.length () << "\n"; | |
336 | |
337 for (int i=0; i < d.length (); i++) | |
338 os << " " << d (i); | |
339 | |
340 os << "\n" << tmp; | |
341 } | |
342 else | |
343 { | |
344 // Keep this case, rather than use generic code above for backward | |
345 // compatiability. Makes load_ascii much more complex!! | |
346 os << "# rows: " << rows () << "\n" | |
347 << "# columns: " << columns () << "\n"; | |
348 | |
5958 | 349 os << matrix_value (); |
4687 | 350 } |
351 | |
352 return true; | |
353 } | |
354 | |
355 bool | |
356 octave_matrix::load_ascii (std::istream& is) | |
357 { | |
358 bool success = true; | |
5099 | 359 |
360 string_vector keywords(2); | |
361 | |
362 keywords[0] = "ndims"; | |
363 keywords[1] = "rows"; | |
4687 | 364 |
5099 | 365 std::string kw; |
5275 | 366 octave_idx_type val = 0; |
5099 | 367 |
368 if (extract_keyword (is, keywords, kw, val, true)) | |
4687 | 369 { |
5099 | 370 if (kw == "ndims") |
4687 | 371 { |
5275 | 372 int mdims = static_cast<int> (val); |
4687 | 373 |
5099 | 374 if (mdims >= 0) |
4687 | 375 { |
5099 | 376 dim_vector dv; |
377 dv.resize (mdims); | |
4687 | 378 |
5099 | 379 for (int i = 0; i < mdims; i++) |
380 is >> dv(i); | |
4687 | 381 |
6717 | 382 if (is) |
383 { | |
384 NDArray tmp(dv); | |
385 | |
386 if (tmp.is_empty ()) | |
387 matrix = tmp; | |
388 else | |
389 { | |
390 is >> tmp; | |
5099 | 391 |
6717 | 392 if (is) |
393 matrix = tmp; | |
394 else | |
395 { | |
396 error ("load: failed to load matrix constant"); | |
397 success = false; | |
398 } | |
399 } | |
400 } | |
401 else | |
4687 | 402 { |
6717 | 403 error ("load: failed to read dimensions"); |
4687 | 404 success = false; |
405 } | |
406 } | |
407 else | |
5099 | 408 { |
6717 | 409 error ("load: failed to extract number of dimensions"); |
5099 | 410 success = false; |
411 } | |
4687 | 412 } |
5099 | 413 else if (kw == "rows") |
4687 | 414 { |
5275 | 415 octave_idx_type nr = val; |
416 octave_idx_type nc = 0; | |
5099 | 417 |
418 if (nr >= 0 && extract_keyword (is, "columns", nc) && nc >= 0) | |
419 { | |
420 if (nr > 0 && nc > 0) | |
421 { | |
422 Matrix tmp (nr, nc); | |
423 is >> tmp; | |
424 if (is) | |
425 matrix = tmp; | |
426 else | |
427 { | |
428 error ("load: failed to load matrix constant"); | |
429 success = false; | |
430 } | |
431 } | |
432 else if (nr == 0 || nc == 0) | |
433 matrix = Matrix (nr, nc); | |
434 else | |
435 panic_impossible (); | |
436 } | |
437 else | |
438 { | |
439 error ("load: failed to extract number of rows and columns"); | |
440 success = false; | |
441 } | |
4687 | 442 } |
5099 | 443 else |
444 panic_impossible (); | |
445 } | |
446 else | |
447 { | |
448 error ("load: failed to extract number of rows and columns"); | |
449 success = false; | |
4687 | 450 } |
451 | |
452 return success; | |
453 } | |
454 | |
455 bool | |
456 octave_matrix::save_binary (std::ostream& os, bool& save_as_floats) | |
457 { | |
458 | |
459 dim_vector d = dims (); | |
460 if (d.length() < 1) | |
461 return false; | |
462 | |
463 // Use negative value for ndims to differentiate with old format!! | |
5828 | 464 int32_t tmp = - d.length(); |
5760 | 465 os.write (reinterpret_cast<char *> (&tmp), 4); |
5275 | 466 for (int i = 0; i < d.length (); i++) |
4687 | 467 { |
468 tmp = d(i); | |
5760 | 469 os.write (reinterpret_cast<char *> (&tmp), 4); |
4687 | 470 } |
471 | |
472 NDArray m = array_value (); | |
473 save_type st = LS_DOUBLE; | |
474 if (save_as_floats) | |
475 { | |
476 if (m.too_large_for_float ()) | |
477 { | |
478 warning ("save: some values too large to save as floats --"); | |
479 warning ("save: saving as doubles instead"); | |
480 } | |
481 else | |
482 st = LS_FLOAT; | |
483 } | |
5775 | 484 else if (d.numel () > 8192) // FIXME -- make this configurable. |
4687 | 485 { |
486 double max_val, min_val; | |
487 if (m.all_integers (max_val, min_val)) | |
488 st = get_save_type (max_val, min_val); | |
489 } | |
490 | |
491 const double *mtmp = m.data (); | |
492 write_doubles (os, mtmp, st, d.numel ()); | |
493 | |
494 return true; | |
495 } | |
496 | |
497 bool | |
498 octave_matrix::load_binary (std::istream& is, bool swap, | |
499 oct_mach_info::float_format fmt) | |
500 { | |
501 char tmp; | |
5828 | 502 int32_t mdims; |
5760 | 503 if (! is.read (reinterpret_cast<char *> (&mdims), 4)) |
4687 | 504 return false; |
505 if (swap) | |
4944 | 506 swap_bytes<4> (&mdims); |
4687 | 507 if (mdims < 0) |
508 { | |
509 mdims = - mdims; | |
5828 | 510 int32_t di; |
4687 | 511 dim_vector dv; |
512 dv.resize (mdims); | |
513 | |
514 for (int i = 0; i < mdims; i++) | |
515 { | |
5760 | 516 if (! is.read (reinterpret_cast<char *> (&di), 4)) |
4687 | 517 return false; |
518 if (swap) | |
4944 | 519 swap_bytes<4> (&di); |
4687 | 520 dv(i) = di; |
521 } | |
522 | |
5157 | 523 // Convert an array with a single dimension to be a row vector. |
524 // Octave should never write files like this, other software | |
525 // might. | |
526 | |
527 if (mdims == 1) | |
528 { | |
529 mdims = 2; | |
530 dv.resize (mdims); | |
531 dv(1) = dv(0); | |
532 dv(0) = 1; | |
533 } | |
534 | |
5760 | 535 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
4687 | 536 return false; |
537 | |
538 NDArray m(dv); | |
539 double *re = m.fortran_vec (); | |
5760 | 540 read_doubles (is, re, static_cast<save_type> (tmp), dv.numel (), swap, fmt); |
4687 | 541 if (error_state || ! is) |
542 return false; | |
543 matrix = m; | |
544 } | |
545 else | |
546 { | |
5828 | 547 int32_t nr, nc; |
4687 | 548 nr = mdims; |
5760 | 549 if (! is.read (reinterpret_cast<char *> (&nc), 4)) |
4687 | 550 return false; |
551 if (swap) | |
4944 | 552 swap_bytes<4> (&nc); |
5760 | 553 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
4687 | 554 return false; |
555 Matrix m (nr, nc); | |
556 double *re = m.fortran_vec (); | |
5275 | 557 octave_idx_type len = nr * nc; |
5760 | 558 read_doubles (is, re, static_cast<save_type> (tmp), len, swap, fmt); |
4687 | 559 if (error_state || ! is) |
560 return false; | |
561 matrix = m; | |
562 } | |
563 return true; | |
564 } | |
565 | |
566 #if defined (HAVE_HDF5) | |
4944 | 567 |
4687 | 568 bool |
569 octave_matrix::save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) | |
570 { | |
4837 | 571 dim_vector dv = dims (); |
572 int empty = save_hdf5_empty (loc_id, name, dv); | |
573 if (empty) | |
4805 | 574 return (empty > 0); |
575 | |
4837 | 576 int rank = dv.length (); |
4687 | 577 hid_t space_hid = -1, data_hid = -1; |
578 bool retval = true; | |
579 NDArray m = array_value (); | |
580 | |
4805 | 581 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); |
582 | |
4687 | 583 // Octave uses column-major, while HDF5 uses row-major ordering |
4805 | 584 for (int i = 0; i < rank; i++) |
4837 | 585 hdims[i] = dv (rank-i-1); |
4805 | 586 |
4815 | 587 space_hid = H5Screate_simple (rank, hdims, 0); |
4687 | 588 |
589 if (space_hid < 0) return false; | |
590 | |
591 hid_t save_type_hid = H5T_NATIVE_DOUBLE; | |
592 | |
593 if (save_as_floats) | |
594 { | |
595 if (m.too_large_for_float ()) | |
596 { | |
597 warning ("save: some values too large to save as floats --"); | |
598 warning ("save: saving as doubles instead"); | |
599 } | |
600 else | |
601 save_type_hid = H5T_NATIVE_FLOAT; | |
602 } | |
603 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS | |
604 // hdf5 currently doesn't support float/integer conversions | |
605 else | |
606 { | |
607 double max_val, min_val; | |
608 | |
609 if (m.all_integers (max_val, min_val)) | |
610 save_type_hid | |
611 = save_type_to_hdf5 (get_save_type (max_val, min_val)); | |
612 } | |
613 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */ | |
614 | |
615 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid, | |
616 H5P_DEFAULT); | |
617 if (data_hid < 0) | |
618 { | |
619 H5Sclose (space_hid); | |
620 return false; | |
621 } | |
622 | |
623 double *mtmp = m.fortran_vec (); | |
624 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, | |
4815 | 625 H5P_DEFAULT, mtmp) >= 0; |
4687 | 626 |
627 H5Dclose (data_hid); | |
628 H5Sclose (space_hid); | |
4837 | 629 |
4687 | 630 return retval; |
631 } | |
632 | |
633 bool | |
634 octave_matrix::load_hdf5 (hid_t loc_id, const char *name, | |
635 bool /* have_h5giterate_bug */) | |
636 { | |
4837 | 637 bool retval = false; |
638 | |
4805 | 639 dim_vector dv; |
640 int empty = load_hdf5_empty (loc_id, name, dv); | |
641 if (empty > 0) | |
642 matrix.resize(dv); | |
4837 | 643 if (empty) |
4805 | 644 return (empty > 0); |
645 | |
4687 | 646 hid_t data_hid = H5Dopen (loc_id, name); |
647 hid_t space_id = H5Dget_space (data_hid); | |
648 | |
649 hsize_t rank = H5Sget_simple_extent_ndims (space_id); | |
650 | |
651 if (rank < 1) | |
652 { | |
653 H5Sclose (space_id); | |
654 H5Dclose (data_hid); | |
655 return false; | |
656 } | |
657 | |
658 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); | |
659 OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank); | |
660 | |
661 H5Sget_simple_extent_dims (space_id, hdims, maxdims); | |
662 | |
663 // Octave uses column-major, while HDF5 uses row-major ordering | |
664 if (rank == 1) | |
665 { | |
666 dv.resize (2); | |
667 dv(0) = 1; | |
668 dv(1) = hdims[0]; | |
669 } | |
670 else | |
671 { | |
672 dv.resize (rank); | |
4815 | 673 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--) |
4687 | 674 dv(j) = hdims[i]; |
675 } | |
676 | |
677 NDArray m (dv); | |
678 double *re = m.fortran_vec (); | |
679 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, | |
4815 | 680 H5P_DEFAULT, re) >= 0) |
4687 | 681 { |
682 retval = true; | |
683 matrix = m; | |
684 } | |
685 | |
686 H5Sclose (space_id); | |
687 H5Dclose (data_hid); | |
4837 | 688 |
4687 | 689 return retval; |
690 } | |
4944 | 691 |
4687 | 692 #endif |
693 | |
4643 | 694 void |
695 octave_matrix::print_raw (std::ostream& os, | |
696 bool pr_as_read_syntax) const | |
697 { | |
698 octave_print_internal (os, matrix, pr_as_read_syntax, | |
699 current_print_indent_level ()); | |
700 } | |
701 | |
5900 | 702 mxArray * |
703 octave_matrix::as_mxArray (void) const | |
704 { | |
705 mxArray *retval = new mxArray (mxDOUBLE_CLASS, dims (), mxREAL); | |
706 | |
707 double *pr = static_cast<double *> (retval->get_data ()); | |
708 | |
6686 | 709 mwSize nel = numel (); |
5900 | 710 |
711 const double *p = matrix.data (); | |
712 | |
6686 | 713 for (mwIndex i = 0; i < nel; i++) |
5900 | 714 pr[i] = p[i]; |
715 | |
716 return retval; | |
717 } | |
718 | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
719 static bool |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
720 any_element_less_than (const NDArray& a, double val) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
721 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
722 octave_idx_type len = a.length (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
723 const double *m = a.fortran_vec (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
724 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
725 for (octave_idx_type i = 0; i < len; i++) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
726 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
727 OCTAVE_QUIT; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
728 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
729 if (m[i] < val) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
730 return true; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
731 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
732 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
733 return false; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
734 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
735 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
736 static bool |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
737 any_element_greater_than (const NDArray& a, double val) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
738 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
739 octave_idx_type len = a.length (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
740 const double *m = a.fortran_vec (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
741 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
742 for (octave_idx_type i = 0; i < len; i++) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
743 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
744 OCTAVE_QUIT; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
745 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
746 if (m[i] > val) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
747 return true; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
748 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
749 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
750 return false; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
751 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
752 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
753 #define ARRAY_MAPPER(MAP, AMAP, FCN) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
754 octave_value \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
755 octave_matrix::MAP (void) const \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
756 { \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
757 static AMAP dmap = FCN; \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
758 return matrix.map (dmap); \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
759 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
760 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
761 #define CD_ARRAY_MAPPER(MAP, RFCN, CFCN, L1, L2) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
762 octave_value \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
763 octave_matrix::MAP (void) const \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
764 { \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
765 static NDArray::dmapper dmap = RFCN; \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
766 static NDArray::cmapper cmap = CFCN; \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
767 \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
768 return (any_element_less_than (matrix, L1) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
769 ? octave_value (matrix.map (cmap)) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
770 : (any_element_greater_than (matrix, L2) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
771 ? octave_value (matrix.map (cmap)) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
772 : octave_value (matrix.map (dmap)))); \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
773 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
774 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
775 static double |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
776 xconj (double x) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
777 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
778 return x; |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
779 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
780 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
781 ARRAY_MAPPER (erf, NDArray::dmapper, ::erf) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
782 ARRAY_MAPPER (erfc, NDArray::dmapper, ::erfc) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
783 ARRAY_MAPPER (gamma, NDArray::dmapper, xgamma) |
7601
8a939b217863
Treat negative values to lgamma and beta correctly
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
784 CD_ARRAY_MAPPER (lgamma, xlgamma, xlgamma, 0.0, octave_Inf) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
785 ARRAY_MAPPER (abs, NDArray::dmapper, ::fabs) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
786 ARRAY_MAPPER (acos, NDArray::dmapper, ::acos) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
787 CD_ARRAY_MAPPER (acosh, ::acosh, ::acosh, 1.0, octave_Inf) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
788 ARRAY_MAPPER (angle, NDArray::dmapper, ::arg) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
789 ARRAY_MAPPER (arg, NDArray::dmapper, ::arg) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
790 CD_ARRAY_MAPPER (asin, ::asin, ::asin, -1.0, 1.0) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
791 ARRAY_MAPPER (asinh, NDArray::dmapper,::asinh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
792 ARRAY_MAPPER (atan, NDArray::dmapper, ::atan) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
793 CD_ARRAY_MAPPER (atanh, ::atanh, ::atanh, -1.0, 1.0) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
794 ARRAY_MAPPER (ceil, NDArray::dmapper, ::ceil) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
795 ARRAY_MAPPER (conj, NDArray::dmapper, xconj) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
796 ARRAY_MAPPER (cos, NDArray::dmapper, ::cos) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
797 ARRAY_MAPPER (cosh, NDArray::dmapper, ::cosh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
798 ARRAY_MAPPER (exp, NDArray::dmapper, ::exp) |
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
799 ARRAY_MAPPER (expm1, NDArray::dmapper, ::expm1) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
800 ARRAY_MAPPER (fix, NDArray::dmapper, ::fix) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
801 ARRAY_MAPPER (floor, NDArray::dmapper, ::floor) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
802 ARRAY_MAPPER (imag, NDArray::dmapper, ::imag) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
803 CD_ARRAY_MAPPER (log, ::log, std::log, 0.0, octave_Inf) |
7740 | 804 CD_ARRAY_MAPPER (log2, xlog2, xlog2, 0.0, octave_Inf) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
805 CD_ARRAY_MAPPER (log10, ::log10, std::log10, 0.0, octave_Inf) |
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
806 CD_ARRAY_MAPPER (log1p, ::log1p, ::log1p, -1.0, octave_Inf) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
807 ARRAY_MAPPER (real, NDArray::dmapper, ::real) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
808 ARRAY_MAPPER (round, NDArray::dmapper, xround) |
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7601
diff
changeset
|
809 ARRAY_MAPPER (roundb, NDArray::dmapper, xroundb) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
810 ARRAY_MAPPER (signum, NDArray::dmapper, ::signum) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
811 ARRAY_MAPPER (sin, NDArray::dmapper, ::sin) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
812 ARRAY_MAPPER (sinh, NDArray::dmapper, ::sinh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
813 CD_ARRAY_MAPPER (sqrt, ::sqrt, std::sqrt, 0.0, octave_Inf) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
814 ARRAY_MAPPER (tan, NDArray::dmapper, ::tan) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
815 ARRAY_MAPPER (tanh, NDArray::dmapper, ::tanh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
816 ARRAY_MAPPER (finite, NDArray::bmapper, xfinite) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
817 ARRAY_MAPPER (isinf, NDArray::bmapper, xisinf) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
818 ARRAY_MAPPER (isna, NDArray::bmapper, octave_is_NA) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
819 ARRAY_MAPPER (isnan, NDArray::bmapper, xisnan) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
820 |
4901 | 821 DEFUN (double, args, , |
822 "-*- texinfo -*-\n\ | |
823 @deftypefn {Built-in Function} {} double (@var{x})\n\ | |
824 Convert @var{x} to double precision type.\n\ | |
825 @end deftypefn") | |
826 { | |
7004 | 827 // The OCTAVE_TYPE_CONV_BODY3 macro declares retval, so they go |
828 // inside their own scopes, and we don't declare retval here to | |
829 // avoid a shadowed declaration warning. | |
830 | |
831 if (args.length () == 1) | |
832 { | |
833 if (args(0).is_sparse_type ()) | |
834 { | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
835 if (args(0).is_complex_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
836 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
837 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_complex_matrix, octave_complex); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
838 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
839 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
840 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
841 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_matrix, octave_scalar); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
842 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
843 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
844 else if (args(0).is_complex_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
845 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
846 OCTAVE_TYPE_CONV_BODY3 (double, octave_complex_matrix, octave_complex); |
7004 | 847 } |
848 else | |
849 { | |
850 OCTAVE_TYPE_CONV_BODY3 (double, octave_matrix, octave_scalar); | |
851 } | |
852 } | |
853 else | |
854 print_usage (); | |
855 | |
856 return octave_value (); | |
4901 | 857 } |
858 | |
2376 | 859 /* |
860 ;;; Local Variables: *** | |
861 ;;; mode: C++ *** | |
862 ;;; End: *** | |
863 */ |