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