Mercurial > octave
annotate liboctave/numeric/lo-mappers.cc @ 21231:5f318c8ec634
eliminate feature tests from lo-specfun.h
* lo-specfun.h, lo-specfun.cc (xacosh, xasinh, xatanh, xerf, xerfc
xexpm1, xlog1p, xcbrt): Rename to have 'x' prefix. Conditionally
define in .cc file. Change all uses Move complex versions of acosh,
asinh, and atanh functions here.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Tue, 09 Feb 2016 04:15:50 -0500 |
parents | f7121e111991 |
children | b8cf410b5c88 |
rev | line source |
---|---|
1967 | 1 /* |
2 | |
19697
4197fc428c7d
maint: Update copyright notices for 2015.
John W. Eaton <jwe@octave.org>
parents:
19377
diff
changeset
|
3 Copyright (C) 1996-2015 John W. Eaton |
10521
4d1fc073fbb7
add some missing copyright stmts
Jaroslav Hajek <highegg@gmail.com>
parents:
10459
diff
changeset
|
4 Copyright (C) 2010 VZLU Prague |
1967 | 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. | |
1967 | 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/>. | |
1967 | 21 |
22 */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
21202
f7121e111991
maint: indent #ifdef blocks in liboctave and src directories.
Rik <rik@octave.org>
parents:
20791
diff
changeset
|
25 # include <config.h> |
1967 | 26 #endif |
27 | |
28 #include <cfloat> | |
3268 | 29 |
1967 | 30 #include "lo-error.h" |
31 #include "lo-ieee.h" | |
32 #include "lo-mappers.h" | |
7231 | 33 #include "lo-math.h" |
3121 | 34 #include "lo-specfun.h" |
1967 | 35 #include "lo-utils.h" |
36 #include "oct-cmplx.h" | |
37 | |
38 #include "f77-fcn.h" | |
39 | |
3248 | 40 // double -> double mappers. |
1967 | 41 |
11237
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
42 // Both xtrunc and xround belong here so we can keep gnulib:: out of |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
43 // lo-mappers.h. |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
44 |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
45 double |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
46 xtrunc (double x) |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
47 { |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
48 return gnulib::trunc (x); |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
49 } |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
50 |
13737
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
51 double |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
52 xcopysign (double x, double y) |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
53 { |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
54 return gnulib::copysign (x, y); |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
55 } |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
56 |
11525
ab231f944252
avoid exposing gnulib:: in header files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
57 double xfloor (double x) |
ab231f944252
avoid exposing gnulib:: in header files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
58 { |
ab231f944252
avoid exposing gnulib:: in header files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
59 return gnulib::floor (x); |
ab231f944252
avoid exposing gnulib:: in header files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
60 } |
ab231f944252
avoid exposing gnulib:: in header files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
61 |
11237
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
62 double |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
63 xround (double x) |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
64 { |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
65 return gnulib::round (x); |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
66 } |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
67 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11525
diff
changeset
|
68 double |
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
69 xroundb (double x) |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
70 { |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
71 double t = xround (x); |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
72 |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
73 if (fabs (x - t) == 0.5) |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
74 t = 2 * xtrunc (0.5 * t); |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
75 |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
76 return t; |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
77 } |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
78 |
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7231
diff
changeset
|
79 double |
1967 | 80 signum (double x) |
81 { | |
82 double tmp = 0.0; | |
4984 | 83 |
1967 | 84 if (x < 0.0) |
85 tmp = -1.0; | |
86 else if (x > 0.0) | |
87 tmp = 1.0; | |
88 | |
89 return xisnan (x) ? octave_NaN : tmp; | |
90 } | |
91 | |
5904 | 92 double |
93 xlog2 (double x) | |
94 { | |
18847
ff4da3c8ed16
use gnulib log2 modules (bug #42583)
John W. Eaton <jwe@octave.org>
parents:
17843
diff
changeset
|
95 return gnulib::log2 (x); |
5904 | 96 } |
97 | |
7740 | 98 Complex |
99 xlog2 (const Complex& x) | |
100 { | |
101 #if defined (M_LN2) | |
102 static double ln2 = M_LN2; | |
103 #else | |
18928
161ebb78ac1b
use gnulib::log and gnulib::logf functions
John W. Eaton <jwe@octave.org>
parents:
18847
diff
changeset
|
104 static double ln2 = gnulib::log (2); |
7740 | 105 #endif |
106 | |
107 return std::log (x) / ln2; | |
108 } | |
109 | |
5904 | 110 double |
111 xexp2 (double x) | |
112 { | |
113 #if defined (HAVE_EXP2) | |
114 return exp2 (x); | |
115 #else | |
21202
f7121e111991
maint: indent #ifdef blocks in liboctave and src directories.
Rik <rik@octave.org>
parents:
20791
diff
changeset
|
116 # if defined (M_LN2) |
5904 | 117 static double ln2 = M_LN2; |
118 #else | |
18928
161ebb78ac1b
use gnulib::log and gnulib::logf functions
John W. Eaton <jwe@octave.org>
parents:
18847
diff
changeset
|
119 static double ln2 = gnulib::log (2); |
5904 | 120 #endif |
121 | |
122 return exp (x * ln2); | |
123 #endif | |
124 } | |
125 | |
7740 | 126 double |
127 xlog2 (double x, int& exp) | |
128 { | |
17843 | 129 return gnulib::frexp (x, &exp); |
7740 | 130 } |
131 | |
132 Complex | |
133 xlog2 (const Complex& x, int& exp) | |
134 { | |
135 double ax = std::abs (x); | |
136 double lax = xlog2 (ax, exp); | |
9319
0d9178575dd7
fix log2 with 2 outargs, loosen tests to meet IEEE
Jaroslav Hajek <highegg@gmail.com>
parents:
8998
diff
changeset
|
137 return (ax != lax) ? (x / ax) * lax : x; |
7740 | 138 } |
139 | |
3248 | 140 // double -> bool mappers. |
141 | |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19739
diff
changeset
|
142 #if ! defined (HAVE_CMATH_ISNAN) |
3248 | 143 bool |
1967 | 144 xisnan (double x) |
145 { | |
4074 | 146 return lo_ieee_isnan (x); |
1967 | 147 } |
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
148 #endif |
1967 | 149 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19739
diff
changeset
|
150 #if ! defined (HAVE_CMATH_ISFINITE) |
3248 | 151 bool |
1967 | 152 xfinite (double x) |
153 { | |
4074 | 154 return lo_ieee_finite (x); |
1967 | 155 } |
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
156 #endif |
1967 | 157 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19739
diff
changeset
|
158 #if ! defined (HAVE_CMATH_ISINF) |
3248 | 159 bool |
1967 | 160 xisinf (double x) |
161 { | |
4074 | 162 return lo_ieee_isinf (x); |
1967 | 163 } |
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
164 #endif |
1967 | 165 |
4025 | 166 bool |
167 octave_is_NA (double x) | |
168 { | |
169 return lo_ieee_is_NA (x); | |
170 } | |
171 | |
3248 | 172 // (double, double) -> double mappers. |
1967 | 173 |
3248 | 174 // complex -> complex mappers. |
1967 | 175 |
176 Complex | |
177 acos (const Complex& x) | |
178 { | |
179 static Complex i (0, 1); | |
3056 | 180 |
19242
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
181 Complex tmp; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
182 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
183 if (imag (x) == 0.0) |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
184 { |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
185 // If the imaginary part of X is 0, then avoid generating an |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
186 // imaginary part of -0 for the expression 1-x*x. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
187 // This effectively chooses the same phase of the branch cut as Matlab. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
188 double xr = real (x); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
189 tmp = Complex (1.0 - xr*xr); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
190 } |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
191 else |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
192 tmp = 1.0 - x*x; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
193 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
194 return -i * log (x + i * sqrt (tmp)); |
1967 | 195 } |
196 | |
197 Complex | |
198 asin (const Complex& x) | |
199 { | |
200 static Complex i (0, 1); | |
3056 | 201 |
19242
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
202 Complex tmp; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
203 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
204 if (imag (x) == 0.0) |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
205 { |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
206 // If the imaginary part of X is 0, then avoid generating an |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
207 // imaginary part of -0 for the expression 1-x*x. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
208 // This effectively chooses the same phase of the branch cut as Matlab. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
209 double xr = real (x); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
210 tmp = Complex (1.0 - xr*xr); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
211 } |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
212 else |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
213 tmp = 1.0 - x*x; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
214 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
215 return -i * log (i*x + sqrt (tmp)); |
1967 | 216 } |
217 | |
218 Complex | |
219 atan (const Complex& x) | |
220 { | |
221 static Complex i (0, 1); | |
3056 | 222 |
223 return i * log ((i + x) / (i - x)) / 2.0; | |
1967 | 224 } |
225 | |
3248 | 226 // complex -> bool mappers. |
227 | |
228 bool | |
4025 | 229 octave_is_NA (const Complex& x) |
230 { | |
231 return (octave_is_NA (real (x)) || octave_is_NA (imag (x))); | |
232 } | |
233 | |
234 bool | |
235 octave_is_NaN_or_NA (const Complex& x) | |
236 { | |
5389 | 237 return (xisnan (real (x)) || xisnan (imag (x))); |
4025 | 238 } |
239 | |
3248 | 240 // (complex, complex) -> complex mappers. |
241 | |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
242 // FIXME: need to handle NA too? |
4025 | 243 |
3248 | 244 Complex |
245 xmin (const Complex& x, const Complex& y) | |
246 { | |
3757 | 247 return abs (x) <= abs (y) ? x : (xisnan (x) ? x : y); |
3248 | 248 } |
249 | |
250 Complex | |
251 xmax (const Complex& x, const Complex& y) | |
252 { | |
3757 | 253 return abs (x) >= abs (y) ? x : (xisnan (x) ? x : y); |
3248 | 254 } |
255 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
256 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
257 // float -> float mappers. |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
258 |
11237
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
259 // Both xtrunc and xround belong here so we can keep gnulib:: out of |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
260 // lo-mappers.h. |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
261 |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
262 float |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
263 xtrunc (float x) |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
264 { |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
265 return gnulib::truncf (x); |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
266 } |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
267 |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
268 float |
13737
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
269 xcopysign (float x, float y) |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
270 { |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
271 return gnulib::copysignf (x, y); |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
272 } |
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
273 |
15409
c898dbe14e1d
build: Update imported module list from gnulib.
Rik <rik@octave.org>
parents:
15271
diff
changeset
|
274 float xfloor (float x) |
c898dbe14e1d
build: Update imported module list from gnulib.
Rik <rik@octave.org>
parents:
15271
diff
changeset
|
275 { |
c898dbe14e1d
build: Update imported module list from gnulib.
Rik <rik@octave.org>
parents:
15271
diff
changeset
|
276 return gnulib::floorf (x); |
c898dbe14e1d
build: Update imported module list from gnulib.
Rik <rik@octave.org>
parents:
15271
diff
changeset
|
277 } |
c898dbe14e1d
build: Update imported module list from gnulib.
Rik <rik@octave.org>
parents:
15271
diff
changeset
|
278 |
13737
30414ff19d5e
Use copysignf module from gnulib.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
279 float |
11237
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
280 xround (float x) |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
281 { |
15409
c898dbe14e1d
build: Update imported module list from gnulib.
Rik <rik@octave.org>
parents:
15271
diff
changeset
|
282 return gnulib::roundf (x); |
11237
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
283 } |
110e570e5f8d
keep gnulib out of lo-mappers.h
John W. Eaton <jwe@octave.org>
parents:
11212
diff
changeset
|
284 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11525
diff
changeset
|
285 float |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
286 xroundb (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
287 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
288 float t = xround (x); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
289 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
290 if (fabsf (x - t) == 0.5) |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
291 t = 2 * xtrunc (0.5 * t); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
292 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
293 return t; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
294 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
295 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
296 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
297 signum (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
298 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
299 float tmp = 0.0; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
300 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
301 if (x < 0.0) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
302 tmp = -1.0; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
303 else if (x > 0.0) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
304 tmp = 1.0; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
305 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
306 return xisnan (x) ? octave_Float_NaN : tmp; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
307 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
308 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
309 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
310 xlog2 (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
311 { |
18847
ff4da3c8ed16
use gnulib log2 modules (bug #42583)
John W. Eaton <jwe@octave.org>
parents:
17843
diff
changeset
|
312 return gnulib::log2f (x); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
313 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
314 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
315 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
316 xlog2 (const FloatComplex& x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
317 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
318 #if defined (M_LN2) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
319 static float ln2 = M_LN2; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
320 #else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
321 static float ln2 = log (2); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
322 #endif |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
323 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
324 return std::log (x) / ln2; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
325 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
326 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
327 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
328 xexp2 (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
329 { |
15452
4d960b078272
build: Remove unnecessary AC_CHECK_FUNCS calls.
Rik <rik@octave.org>
parents:
15409
diff
changeset
|
330 #if defined (HAVE_EXP2F) |
4d960b078272
build: Remove unnecessary AC_CHECK_FUNCS calls.
Rik <rik@octave.org>
parents:
15409
diff
changeset
|
331 return exp2f (x); |
4d960b078272
build: Remove unnecessary AC_CHECK_FUNCS calls.
Rik <rik@octave.org>
parents:
15409
diff
changeset
|
332 #elif defined (HAVE_EXP2) |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
333 return exp2 (x); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
334 #else |
21202
f7121e111991
maint: indent #ifdef blocks in liboctave and src directories.
Rik <rik@octave.org>
parents:
20791
diff
changeset
|
335 # if defined (M_LN2) |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
336 static float ln2 = M_LN2; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
337 #else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
338 static float ln2 = log2 (2); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
339 #endif |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
340 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
341 return exp (x * ln2); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
342 #endif |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
343 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
344 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
345 float |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
346 xlog2 (float x, int& exp) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
347 { |
17843 | 348 return gnulib::frexpf (x, &exp); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
349 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
350 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
351 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
352 xlog2 (const FloatComplex& x, int& exp) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
353 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
354 float ax = std::abs (x); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
355 float lax = xlog2 (ax, exp); |
9319
0d9178575dd7
fix log2 with 2 outargs, loosen tests to meet IEEE
Jaroslav Hajek <highegg@gmail.com>
parents:
8998
diff
changeset
|
356 return (ax != lax) ? (x / ax) * lax : x; |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
357 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
358 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
359 // float -> bool mappers. |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
360 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19739
diff
changeset
|
361 #if ! defined (HAVE_CMATH_ISNANF) |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
362 bool |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
363 xisnan (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
364 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
365 return lo_ieee_isnan (x); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
366 } |
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
367 #endif |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
368 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19739
diff
changeset
|
369 #if ! defined (HAVE_CMATH_ISFINITEF) |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
370 bool |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
371 xfinite (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
372 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
373 return lo_ieee_finite (x); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
374 } |
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
375 #endif |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
376 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19739
diff
changeset
|
377 #if ! defined (HAVE_CMATH_ISINFF) |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
378 bool |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
379 xisinf (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
380 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
381 return lo_ieee_isinf (x); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
382 } |
8998
a48fba01e4ac
optimize isnan/isinf/isfinite mappers
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
383 #endif |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
384 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
385 bool |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
386 octave_is_NA (float x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
387 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
388 return lo_ieee_is_NA (x); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
389 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
390 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
391 // (float, float) -> float mappers. |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
392 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
393 // complex -> complex mappers. |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
394 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
395 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
396 acos (const FloatComplex& x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
397 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
398 static FloatComplex i (0, 1); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
399 |
19242
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
400 FloatComplex tmp; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
401 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
402 if (imag (x) == 0.0f) |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
403 { |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
404 // If the imaginary part of X is 0, then avoid generating an |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
405 // imaginary part of -0 for the expression 1-x*x. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
406 // This effectively chooses the same phase of the branch cut as Matlab. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
407 float xr = real (x); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
408 tmp = FloatComplex (1.0f - xr*xr); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
409 } |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
410 else |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
411 tmp = 1.0f - x*x; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
412 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
413 return -i * log (x + i * sqrt (tmp)); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
414 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
415 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
416 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
417 asin (const FloatComplex& x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
418 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
419 static FloatComplex i (0, 1); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
420 |
19242
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
421 FloatComplex tmp; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
422 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
423 if (imag (x) == 0.0f) |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
424 { |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
425 // If the imaginary part of X is 0, then avoid generating an |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
426 // imaginary part of -0 for the expression 1-x*x. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
427 // This effectively chooses the same phase of the branch cut as Matlab. |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
428 float xr = real (x); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
429 tmp = FloatComplex (1.0f - xr*xr); |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
430 } |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
431 else |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
432 tmp = 1.0f - x*x; |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
433 |
ba7e42dea4b2
Fix returned phase of asin, acos outside principal branch (bug #43349).
Rik <rik@octave.org>
parents:
18928
diff
changeset
|
434 return -i * log (i*x + sqrt (tmp)); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
435 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
436 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
437 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
438 atan (const FloatComplex& x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
439 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
440 static FloatComplex i (0, 1); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
441 |
19738
9155bab86647
use 0.0f style constants instead of static_cast<float> (0.0)
John W. Eaton <jwe@octave.org>
parents:
19730
diff
changeset
|
442 return i * log ((i + x) / (i - x)) / 2.0f; |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
443 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
444 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
445 // complex -> bool mappers. |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
446 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
447 bool |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
448 octave_is_NA (const FloatComplex& x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
449 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
450 return (octave_is_NA (real (x)) || octave_is_NA (imag (x))); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
451 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
452 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
453 bool |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
454 octave_is_NaN_or_NA (const FloatComplex& x) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
455 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
456 return (xisnan (real (x)) || xisnan (imag (x))); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
457 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
458 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
459 // (complex, complex) -> complex mappers. |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
460 |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
461 // FIXME: need to handle NA too? |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
462 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
463 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
464 xmin (const FloatComplex& x, const FloatComplex& y) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
465 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
466 return abs (x) <= abs (y) ? x : (xisnan (x) ? x : y); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
467 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
468 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
469 FloatComplex |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
470 xmax (const FloatComplex& x, const FloatComplex& y) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
471 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
472 return abs (x) >= abs (y) ? x : (xisnan (x) ? x : y); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
473 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7740
diff
changeset
|
474 |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
475 Complex |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
476 rc_acos (double x) |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
477 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
478 return fabs (x) > 1.0 ? acos (Complex (x)) : Complex (acos (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
479 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
480 |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
481 FloatComplex |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
482 rc_acos (float x) |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
483 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
484 return fabsf (x) > 1.0f ? acos (FloatComplex (x)) : FloatComplex (acosf (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
485 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
486 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
487 Complex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
488 rc_acosh (double x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
489 { |
21231
5f318c8ec634
eliminate feature tests from lo-specfun.h
John W. Eaton <jwe@octave.org>
parents:
21202
diff
changeset
|
490 return x < 1.0 ? xacosh (Complex (x)) : Complex (xacosh (x)); |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
491 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
492 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
493 FloatComplex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
494 rc_acosh (float x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
495 { |
21231
5f318c8ec634
eliminate feature tests from lo-specfun.h
John W. Eaton <jwe@octave.org>
parents:
21202
diff
changeset
|
496 return x < 1.0f ? xacosh (FloatComplex (x)) : FloatComplex (xacosh (x)); |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
497 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
498 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
499 Complex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
500 rc_asin (double x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
501 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
502 return fabs (x) > 1.0 ? asin (Complex (x)) : Complex (asin (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
503 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
504 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
505 FloatComplex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
506 rc_asin (float x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
507 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
508 return fabsf (x) > 1.0f ? asin (FloatComplex (x)) : FloatComplex (asinf (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
509 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
510 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
511 Complex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
512 rc_atanh (double x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
513 { |
21231
5f318c8ec634
eliminate feature tests from lo-specfun.h
John W. Eaton <jwe@octave.org>
parents:
21202
diff
changeset
|
514 return fabs (x) > 1.0 ? xatanh (Complex (x)) : Complex (xatanh (x)); |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
515 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
516 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
517 FloatComplex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
518 rc_atanh (float x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
519 { |
21231
5f318c8ec634
eliminate feature tests from lo-specfun.h
John W. Eaton <jwe@octave.org>
parents:
21202
diff
changeset
|
520 return fabsf (x) > 1.0f ? xatanh (FloatComplex (x)) |
5f318c8ec634
eliminate feature tests from lo-specfun.h
John W. Eaton <jwe@octave.org>
parents:
21202
diff
changeset
|
521 : FloatComplex (xatanh (x)); |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
522 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
523 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
524 Complex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
525 rc_log (double x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
526 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
527 const double pi = 3.14159265358979323846; |
19375
264ff6bf7475
use gnulib:: namespace for log, logf, localtime, and gmtime
John W. Eaton <jwe@octave.org>
parents:
18847
diff
changeset
|
528 return x < 0.0 ? Complex (gnulib::log (-x), pi) : Complex (gnulib::log (x)); |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
529 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
530 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
531 FloatComplex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
532 rc_log (float x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
533 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
534 const float pi = 3.14159265358979323846f; |
19375
264ff6bf7475
use gnulib:: namespace for log, logf, localtime, and gmtime
John W. Eaton <jwe@octave.org>
parents:
18847
diff
changeset
|
535 return (x < 0.0f |
264ff6bf7475
use gnulib:: namespace for log, logf, localtime, and gmtime
John W. Eaton <jwe@octave.org>
parents:
18847
diff
changeset
|
536 ? FloatComplex (gnulib::logf (-x), pi) |
264ff6bf7475
use gnulib:: namespace for log, logf, localtime, and gmtime
John W. Eaton <jwe@octave.org>
parents:
18847
diff
changeset
|
537 : FloatComplex (gnulib::logf (x))); |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
538 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
539 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
540 Complex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
541 rc_log2 (double x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
542 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
543 const double pil2 = 4.53236014182719380962; // = pi / log(2) |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
544 return x < 0.0 ? Complex (xlog2 (-x), pil2) : Complex (xlog2 (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
545 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
546 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
547 FloatComplex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
548 rc_log2 (float x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
549 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
550 const float pil2 = 4.53236014182719380962f; // = pi / log(2) |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
551 return x < 0.0f ? FloatComplex (xlog2 (-x), pil2) : FloatComplex (xlog2 (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
552 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
553 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
554 Complex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
555 rc_log10 (double x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
556 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
557 const double pil10 = 1.36437635384184134748; // = pi / log(10) |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
558 return x < 0.0 ? Complex (log10 (-x), pil10) : Complex (log10 (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
559 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
560 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
561 FloatComplex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
562 rc_log10 (float x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
563 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
564 const float pil10 = 1.36437635384184134748f; // = pi / log(10) |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
565 return x < 0.0f ? FloatComplex (log10 (-x), pil10) |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
566 : FloatComplex (log10f (x)); |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
567 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
568 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
569 Complex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
570 rc_sqrt (double x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
571 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
572 return x < 0.0 ? Complex (0.0, sqrt (-x)) : Complex (sqrt (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
573 } |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
574 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
575 FloatComplex |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
576 rc_sqrt (float x) |
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
577 { |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
578 return x < 0.0f ? FloatComplex (0.0f, sqrtf (-x)) : FloatComplex (sqrtf (x)); |
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
579 } |
11010
9478b216752e
simplify more array tests
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
580 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
581 bool |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
582 xnegative_sign (double x) |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
583 { |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
584 return __lo_ieee_signbit (x); |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
585 } |
11010
9478b216752e
simplify more array tests
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
586 |
11212
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
587 bool |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
588 xnegative_sign (float x) |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
589 { |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
590 return __lo_ieee_float_signbit (x); |
ce27d6f4e134
use templates and inline for more lo-mappers functionos
John W. Eaton <jwe@octave.org>
parents:
11211
diff
changeset
|
591 } |
11211
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
592 |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
593 // Convert X to the nearest integer value. Should not pass NaN to |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
594 // this function. |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
595 |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
596 // Sometimes you need a large integer, but not always. |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
597 |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
598 octave_idx_type |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
599 NINTbig (double x) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
600 { |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
601 if (x > std::numeric_limits<octave_idx_type>::max ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
602 return std::numeric_limits<octave_idx_type>::max (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
603 else if (x < std::numeric_limits<octave_idx_type>::min ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
604 return std::numeric_limits<octave_idx_type>::min (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
605 else |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
606 return static_cast<octave_idx_type> ((x > 0) ? (x + 0.5) : (x - 0.5)); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
607 } |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
608 |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
609 octave_idx_type |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
610 NINTbig (float x) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
611 { |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
612 if (x > std::numeric_limits<octave_idx_type>::max ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
613 return std::numeric_limits<octave_idx_type>::max (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
614 else if (x < std::numeric_limits<octave_idx_type>::min ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
615 return std::numeric_limits<octave_idx_type>::min (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
616 else |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
617 return static_cast<octave_idx_type> ((x > 0) ? (x + 0.5) : (x - 0.5)); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
618 } |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
619 |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
620 int |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
621 NINT (double x) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
622 { |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
623 if (x > std::numeric_limits<int>::max ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
624 return std::numeric_limits<int>::max (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
625 else if (x < std::numeric_limits<int>::min ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
626 return std::numeric_limits<int>::min (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
627 else |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
628 return static_cast<int> ((x > 0) ? (x + 0.5) : (x - 0.5)); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
629 } |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
630 |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
631 int |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
632 NINT (float x) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
633 { |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
634 if (x > std::numeric_limits<int>::max ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
635 return std::numeric_limits<int>::max (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
636 else if (x < std::numeric_limits<int>::min ()) |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
637 return std::numeric_limits<int>::min (); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
638 else |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
639 return static_cast<int> ((x > 0) ? (x + 0.5) : (x - 0.5)); |
2554b4a0806e
use templates for some lo-mappers functions
John W. Eaton <jwe@octave.org>
parents:
11209
diff
changeset
|
640 } |