Mercurial > hg > octave-lyh
annotate src/ov-complex.cc @ 7829:8ca8e97e8c0a
Add rendering interface for surface object (no implementation yet).
* * *
Add surface properties.
* * *
Add cdata -> RGB color conversion function. Use it in surface objects.
* * *
Add normals automatic computation to surface objects.
* * *
Make sure the correct "get" method is called.
* * *
Extend scaler interface to accept NDArray.
* * *
Surface rendering (1st part).
* * *
Fix wrong indexing.
* * *
Fix bug in xget_ancestor argument declaration.
* * *
Initialize OpenGL context correctly. Fix bug in surface rendering.
* * *
Set material color when rendering surface facets.
* * *
Add rendering of surface mesh and markers.
author | Michael Goffioul <michael.goffioul@gmail.com> |
---|---|
date | Thu, 14 Feb 2008 12:17:44 +0100 |
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> |
2901 | 29 |
2376 | 30 #include "lo-ieee.h" |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
31 #include "lo-specfun.h" |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
32 #include "lo-mappers.h" |
2376 | 33 |
34 #include "oct-obj.h" | |
4944 | 35 #include "oct-stream.h" |
2410 | 36 #include "ops.h" |
2376 | 37 #include "ov-complex.h" |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
38 #include "ov-flt-complex.h" |
3223 | 39 #include "ov-base.h" |
40 #include "ov-base-scalar.h" | |
41 #include "ov-base-scalar.cc" | |
2423 | 42 #include "ov-cx-mat.h" |
2410 | 43 #include "ov-scalar.h" |
2376 | 44 #include "gripes.h" |
45 #include "pr-output.h" | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
46 #include "ops.h" |
2376 | 47 |
4687 | 48 #include "ls-oct-ascii.h" |
49 #include "ls-hdf5.h" | |
50 | |
3223 | 51 template class octave_base_scalar<Complex>; |
52 | |
3219 | 53 DEFINE_OCTAVE_ALLOCATOR (octave_complex); |
2376 | 54 |
4612 | 55 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_complex, |
56 "complex scalar", "double"); | |
2376 | 57 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
58 static octave_base_value * |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
59 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
|
60 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
61 CAST_CONV_ARG (const octave_complex&); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
62 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
63 return new octave_float_complex (v.float_complex_value ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
64 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
65 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
66 octave_base_value::type_conv_fcn |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
67 octave_complex::numeric_demotion_function (void) const |
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 default_numeric_demotion_function; |
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 |
5759 | 72 octave_base_value * |
2410 | 73 octave_complex::try_narrowing_conversion (void) |
74 { | |
5759 | 75 octave_base_value *retval = 0; |
2410 | 76 |
5450 | 77 double im = std::imag (scalar); |
78 | |
79 if (im == 0.0 && ! lo_ieee_signbit (im)) | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
80 retval = new octave_scalar (std::real (scalar)); |
2410 | 81 |
82 return retval; | |
83 } | |
84 | |
2376 | 85 octave_value |
5885 | 86 octave_complex::do_index_op (const octave_value_list& idx, bool resize_ok) |
2376 | 87 { |
88 octave_value retval; | |
89 | |
3933 | 90 if (idx.valid_scalar_indices ()) |
2376 | 91 retval = scalar; |
92 else | |
93 { | |
5775 | 94 // FIXME -- this doesn't solve the problem of |
2376 | 95 // |
96 // a = i; a([1,1], [1,1], [1,1]) | |
97 // | |
98 // and similar constructions. Hmm... | |
99 | |
5775 | 100 // FIXME -- using this constructor avoids narrowing the |
2423 | 101 // 1x1 matrix back to a scalar value. Need a better solution |
102 // to this problem. | |
103 | |
104 octave_value tmp (new octave_complex_matrix (complex_matrix_value ())); | |
2376 | 105 |
3933 | 106 retval = tmp.do_index_op (idx, resize_ok); |
2376 | 107 } |
108 | |
109 return retval; | |
110 } | |
111 | |
112 double | |
113 octave_complex::double_value (bool force_conversion) const | |
114 { | |
4102 | 115 double retval = lo_ieee_nan_value (); |
2376 | 116 |
5781 | 117 if (! force_conversion) |
118 gripe_implicit_conversion ("Octave:imag-to-real", | |
119 "complex scalar", "real scalar"); | |
2376 | 120 |
4451 | 121 retval = std::real (scalar); |
2376 | 122 |
123 return retval; | |
124 } | |
125 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
126 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
127 octave_complex::float_value (bool force_conversion) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
128 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
129 float retval = lo_ieee_float_nan_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
130 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
131 if (! force_conversion) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
132 gripe_implicit_conversion ("Octave:imag-to-real", |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
133 "complex scalar", "real scalar"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
134 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
135 retval = std::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 return retval; |
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 |
2376 | 140 Matrix |
141 octave_complex::matrix_value (bool force_conversion) const | |
142 { | |
143 Matrix retval; | |
144 | |
5781 | 145 if (! force_conversion) |
146 gripe_implicit_conversion ("Octave:imag-to-real", | |
147 "complex scalar", "real matrix"); | |
2376 | 148 |
4451 | 149 retval = Matrix (1, 1, std::real (scalar)); |
2376 | 150 |
151 return retval; | |
152 } | |
153 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
154 FloatMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
155 octave_complex::float_matrix_value (bool force_conversion) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
156 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
157 FloatMatrix retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
158 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
159 if (! force_conversion) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
160 gripe_implicit_conversion ("Octave:imag-to-real", |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
161 "complex scalar", "real matrix"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
162 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
163 retval = FloatMatrix (1, 1, std::real (scalar)); |
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 return retval; |
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 |
4569 | 168 NDArray |
169 octave_complex::array_value (bool force_conversion) const | |
170 { | |
171 NDArray retval; | |
172 | |
5781 | 173 if (! force_conversion) |
174 gripe_implicit_conversion ("Octave:imag-to-real", | |
175 "complex scalar", "real matrix"); | |
4569 | 176 |
177 retval = NDArray (dim_vector (1, 1), std::real (scalar)); | |
178 | |
179 return retval; | |
180 } | |
181 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
182 FloatNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
183 octave_complex::float_array_value (bool force_conversion) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
184 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
185 FloatNDArray retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
186 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
187 if (! force_conversion) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
188 gripe_implicit_conversion ("Octave:imag-to-real", |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
189 "complex scalar", "real matrix"); |
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 = FloatNDArray (dim_vector (1, 1), std::real (scalar)); |
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 return retval; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
194 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
195 |
2376 | 196 Complex |
197 octave_complex::complex_value (bool) const | |
198 { | |
199 return scalar; | |
200 } | |
201 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
202 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
203 octave_complex::float_complex_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
204 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
205 return static_cast<FloatComplex> (scalar); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
206 } |
2376 | 207 |
208 ComplexMatrix | |
209 octave_complex::complex_matrix_value (bool) const | |
210 { | |
211 return ComplexMatrix (1, 1, scalar); | |
212 } | |
213 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
214 FloatComplexMatrix |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
215 octave_complex::float_complex_matrix_value (bool) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
216 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
217 return FloatComplexMatrix (1, 1, static_cast<FloatComplex> (scalar)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
218 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
219 |
4569 | 220 ComplexNDArray |
4664 | 221 octave_complex::complex_array_value (bool /* force_conversion */) const |
4569 | 222 { |
223 return ComplexNDArray (dim_vector (1, 1), scalar); | |
224 } | |
225 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
226 FloatComplexNDArray |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
227 octave_complex::float_complex_array_value (bool /* force_conversion */) const |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
228 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
229 return FloatComplexNDArray (dim_vector (1, 1), static_cast<FloatComplex> (scalar)); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
230 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
231 |
5731 | 232 octave_value |
233 octave_complex::resize (const dim_vector& dv, bool fill) const | |
234 { | |
235 if (fill) | |
236 { | |
237 ComplexNDArray retval (dv, ComplexNDArray::resize_fill_value ()); | |
238 | |
239 if (dv.numel ()) | |
240 retval(0) = scalar; | |
241 | |
242 return retval; | |
243 } | |
244 else | |
245 { | |
246 ComplexNDArray retval (dv); | |
247 | |
248 if (dv.numel ()) | |
249 retval(0) = scalar; | |
250 | |
251 return retval; | |
252 } | |
253 } | |
254 | |
4687 | 255 bool |
6974 | 256 octave_complex::save_ascii (std::ostream& os) |
4687 | 257 { |
258 Complex c = complex_value (); | |
259 | |
5958 | 260 octave_write_complex (os, c); |
4687 | 261 |
5958 | 262 os << "\n"; |
4687 | 263 |
264 return true; | |
265 } | |
266 | |
267 bool | |
268 octave_complex::load_ascii (std::istream& is) | |
269 { | |
270 scalar = octave_read_complex (is); | |
271 | |
272 if (!is) | |
273 { | |
274 error ("load: failed to load complex scalar constant"); | |
275 return false; | |
276 } | |
277 | |
278 return true; | |
279 } | |
280 | |
281 | |
282 bool | |
283 octave_complex::save_binary (std::ostream& os, bool& /* save_as_floats */) | |
284 { | |
5760 | 285 char tmp = static_cast<char> (LS_DOUBLE); |
286 os.write (reinterpret_cast<char *> (&tmp), 1); | |
4687 | 287 Complex ctmp = complex_value (); |
5760 | 288 os.write (reinterpret_cast<char *> (&ctmp), 16); |
4687 | 289 |
290 return true; | |
291 } | |
292 | |
293 bool | |
294 octave_complex::load_binary (std::istream& is, bool swap, | |
295 oct_mach_info::float_format fmt) | |
296 { | |
297 char tmp; | |
5760 | 298 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
4687 | 299 return false; |
300 | |
301 Complex ctmp; | |
5760 | 302 read_doubles (is, reinterpret_cast<double *> (&ctmp), |
303 static_cast<save_type> (tmp), 2, swap, fmt); | |
4687 | 304 if (error_state || ! is) |
305 return false; | |
306 | |
307 scalar = ctmp; | |
308 return true; | |
309 } | |
310 | |
311 #if defined (HAVE_HDF5) | |
4944 | 312 |
4687 | 313 bool |
314 octave_complex::save_hdf5 (hid_t loc_id, const char *name, | |
315 bool /* save_as_floats */) | |
316 { | |
317 hsize_t dimens[3]; | |
318 hid_t space_hid = -1, type_hid = -1, data_hid = -1; | |
319 bool retval = true; | |
320 | |
4815 | 321 space_hid = H5Screate_simple (0, dimens, 0); |
4837 | 322 if (space_hid < 0) |
323 return false; | |
4687 | 324 |
325 type_hid = hdf5_make_complex_type (H5T_NATIVE_DOUBLE); | |
326 if (type_hid < 0) | |
327 { | |
328 H5Sclose (space_hid); | |
329 return false; | |
330 } | |
331 | |
332 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, H5P_DEFAULT); | |
333 if (data_hid < 0) | |
334 { | |
335 H5Sclose (space_hid); | |
336 H5Tclose (type_hid); | |
337 return false; | |
338 } | |
339 | |
340 Complex tmp = complex_value (); | |
341 retval = H5Dwrite (data_hid, type_hid, H5S_ALL, H5S_ALL, H5P_DEFAULT, | |
4815 | 342 &tmp) >= 0; |
4687 | 343 |
344 H5Dclose (data_hid); | |
345 H5Tclose (type_hid); | |
346 H5Sclose (space_hid); | |
4837 | 347 |
4687 | 348 return retval; |
349 } | |
350 | |
351 bool | |
352 octave_complex::load_hdf5 (hid_t loc_id, const char *name, | |
353 bool /* have_h5giterate_bug */) | |
354 { | |
355 bool retval = false; | |
356 hid_t data_hid = H5Dopen (loc_id, name); | |
357 hid_t type_hid = H5Dget_type (data_hid); | |
358 | |
359 hid_t complex_type = hdf5_make_complex_type (H5T_NATIVE_DOUBLE); | |
360 | |
361 if (! hdf5_types_compatible (type_hid, complex_type)) | |
362 { | |
4837 | 363 H5Tclose (complex_type); |
4687 | 364 H5Dclose (data_hid); |
365 return false; | |
366 } | |
367 | |
368 hid_t space_id = H5Dget_space (data_hid); | |
369 hsize_t rank = H5Sget_simple_extent_ndims (space_id); | |
370 | |
371 if (rank != 0) | |
372 { | |
4837 | 373 H5Tclose (complex_type); |
4687 | 374 H5Sclose (space_id); |
375 H5Dclose (data_hid); | |
376 return false; | |
377 } | |
378 | |
379 // complex scalar: | |
380 Complex ctmp; | |
381 if (H5Dread (data_hid, complex_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, | |
4815 | 382 &ctmp) >= 0) |
4687 | 383 { |
384 retval = true; | |
385 scalar = ctmp; | |
386 } | |
387 | |
4837 | 388 H5Tclose (complex_type); |
4687 | 389 H5Sclose (space_id); |
390 H5Dclose (data_hid); | |
4837 | 391 |
4687 | 392 return retval; |
393 } | |
4944 | 394 |
4687 | 395 #endif |
396 | |
5900 | 397 mxArray * |
398 octave_complex::as_mxArray (void) const | |
399 { | |
400 mxArray *retval = new mxArray (mxDOUBLE_CLASS, 1, 1, mxCOMPLEX); | |
401 | |
402 double *pr = static_cast<double *> (retval->get_data ()); | |
403 double *pi = static_cast<double *> (retval->get_imag_data ()); | |
404 | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
405 pr[0] = std::real (scalar); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
406 pi[0] = std::imag (scalar); |
5900 | 407 |
408 return retval; | |
409 } | |
410 | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
411 static double |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
412 xabs (const Complex& x) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
413 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
414 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
|
415 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
416 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
417 static double |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
418 ximag (const Complex& x) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
419 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
420 return x.imag (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
421 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
422 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
423 static double |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
424 xreal (const Complex& x) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
425 { |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
426 return x.real (); |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
427 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
428 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
429 #define COMPLEX_MAPPER(MAP, FCN) \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
430 octave_value \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
431 octave_complex::MAP (void) const \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
432 { \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
433 return octave_value (FCN (scalar)); \ |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
434 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
435 |
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
|
436 #define SCALAR_MAPPER(MAP, 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
|
437 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
|
438 octave_complex::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
|
439 { \ |
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
|
440 if (scalar.imag () == 0) \ |
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
|
441 return octave_value (FCN (scalar.real ())); \ |
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
|
442 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
|
443 { \ |
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
|
444 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
|
445 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
|
446 } \ |
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
|
447 } |
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
|
448 |
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
|
449 #define CD_SCALAR_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
|
450 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
|
451 octave_complex::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
|
452 { \ |
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
|
453 if (scalar.imag () == 0) \ |
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
|
454 { \ |
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
|
455 double re = scalar.real (); \ |
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
|
456 return (re < L1 || re > 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
|
457 ? octave_value (CFCN (scalar)) \ |
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
|
458 : octave_value (RFCN (re))); \ |
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
|
459 } \ |
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
|
460 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
|
461 { \ |
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
|
462 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
|
463 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
|
464 } \ |
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
|
465 } |
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
|
466 |
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
|
467 SCALAR_MAPPER (erf, ::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
|
468 SCALAR_MAPPER (erfc, ::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
|
469 SCALAR_MAPPER (gamma, 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
|
470 CD_SCALAR_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
|
471 |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
472 COMPLEX_MAPPER (abs, xabs) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
473 COMPLEX_MAPPER (acos, ::acos) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
474 COMPLEX_MAPPER (acosh, ::acosh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
475 COMPLEX_MAPPER (angle, std::arg) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
476 COMPLEX_MAPPER (arg, std::arg) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
477 COMPLEX_MAPPER (asin, ::asin) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
478 COMPLEX_MAPPER (asinh, ::asinh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
479 COMPLEX_MAPPER (atan, ::atan) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
480 COMPLEX_MAPPER (atanh, ::atanh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
481 COMPLEX_MAPPER (ceil, ::ceil) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
482 COMPLEX_MAPPER (conj, std::conj) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
483 COMPLEX_MAPPER (cos, std::cos) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
484 COMPLEX_MAPPER (cosh, std::cosh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
485 COMPLEX_MAPPER (exp, std::exp) |
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
486 COMPLEX_MAPPER (expm1, ::expm1) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
487 COMPLEX_MAPPER (fix, ::fix) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
488 COMPLEX_MAPPER (floor, ::floor) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
489 COMPLEX_MAPPER (imag, ximag) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
490 COMPLEX_MAPPER (log, std::log) |
7740 | 491 COMPLEX_MAPPER (log2, xlog2) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
492 COMPLEX_MAPPER (log10, std::log10) |
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
493 COMPLEX_MAPPER (log1p, ::log1p) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
494 COMPLEX_MAPPER (real, xreal) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
495 COMPLEX_MAPPER (round, xround) |
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7503
diff
changeset
|
496 COMPLEX_MAPPER (roundb, xroundb) |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
497 COMPLEX_MAPPER (signum, ::signum) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
498 COMPLEX_MAPPER (sin, std::sin) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
499 COMPLEX_MAPPER (sinh, std::sinh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
500 COMPLEX_MAPPER (sqrt, std::sqrt) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
501 COMPLEX_MAPPER (tan, std::tan) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
502 COMPLEX_MAPPER (tanh, std::tanh) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
503 COMPLEX_MAPPER (finite, xfinite) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
504 COMPLEX_MAPPER (isinf, xisinf) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
505 COMPLEX_MAPPER (isna, octave_is_NA) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
506 COMPLEX_MAPPER (isnan, xisnan) |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
507 |
2376 | 508 /* |
509 ;;; Local Variables: *** | |
510 ;;; mode: C++ *** | |
511 ;;; End: *** | |
512 */ |