/[base]/head/lib/msun/src/math.h
ViewVC logotype

Contents of /head/lib/msun/src/math.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 271651 - (show annotations) (download)
Mon Sep 15 23:21:57 2014 UTC (9 years, 6 months ago) by kargl
File MIME type: text/plain
File size: 14068 byte(s)
* Makefile:
  . Hook e_lgammal[_r].c to the build.
  . Create man page links for lgammal[-r].3.

* Symbol.map:
  . Sort lgammal to its rightful place.
  . Add FBSD_1.4 section for the new lgamal_r symbol.

* ld128/e_lgammal_r.c:
  . 128-bit implementataion of lgammal_r().

* ld80/e_lgammal_r.c:
  . Intel 80-bit format implementation of lgammal_r().

* src/e_lgamma.c:
  . Expose lgammal as a weak reference to lgamma for platforms
    where long double is mapped to double.

* src/e_lgamma_r.c:
  . Use integer literal constants instead of real literal constants.
    Let compiler(s) do the job of conversion to the appropriate type.
  . Expose lgammal_r as a weak reference to lgamma_r for platforms
    where long double is mapped to double.

* src/e_lgammaf_r.c:
  . Fixed the Cygnus Support conversion of e_lgamma_r.c to float.
    This includes the generation of new polynomial and rational
    approximations with fewer terms.  For each approximation, include
    a comment on an estimate of the accuracy over the relevant domain.
  . Use integer literal constants instead of real literal constants.
    Let compiler(s) do the job of conversion to the appropriate type.
    This allows the removal of several explicit casts of double values
    to float.

* src/e_lgammal.c:
  . Wrapper for lgammal() about lgammal_r().

* src/imprecise.c:
  . Remove the lgamma.

* src/math.h:
  . Add a prototype for lgammal_r().

* man/lgamma.3:
  . Document the new functions.

Reviewed by:	bde

1 /*
2 * ====================================================
3 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
4 *
5 * Developed at SunPro, a Sun Microsystems, Inc. business.
6 * Permission to use, copy, modify, and distribute this
7 * software is freely granted, provided that this notice
8 * is preserved.
9 * ====================================================
10 */
11
12 /*
13 * from: @(#)fdlibm.h 5.1 93/09/24
14 * $FreeBSD$
15 */
16
17 #ifndef _MATH_H_
18 #define _MATH_H_
19
20 #include <sys/cdefs.h>
21 #include <sys/_types.h>
22 #include <machine/_limits.h>
23
24 /*
25 * ANSI/POSIX
26 */
27 extern const union __infinity_un {
28 unsigned char __uc[8];
29 double __ud;
30 } __infinity;
31
32 extern const union __nan_un {
33 unsigned char __uc[sizeof(float)];
34 float __uf;
35 } __nan;
36
37 #if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
38 #define __MATH_BUILTIN_CONSTANTS
39 #endif
40
41 #if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
42 #define __MATH_BUILTIN_RELOPS
43 #endif
44
45 #ifdef __MATH_BUILTIN_CONSTANTS
46 #define HUGE_VAL __builtin_huge_val()
47 #else
48 #define HUGE_VAL (__infinity.__ud)
49 #endif
50
51 #if __ISO_C_VISIBLE >= 1999
52 #define FP_ILOGB0 (-__INT_MAX)
53 #define FP_ILOGBNAN __INT_MAX
54
55 #ifdef __MATH_BUILTIN_CONSTANTS
56 #define HUGE_VALF __builtin_huge_valf()
57 #define HUGE_VALL __builtin_huge_vall()
58 #define INFINITY __builtin_inff()
59 #define NAN __builtin_nanf("")
60 #else
61 #define HUGE_VALF (float)HUGE_VAL
62 #define HUGE_VALL (long double)HUGE_VAL
63 #define INFINITY HUGE_VALF
64 #define NAN (__nan.__uf)
65 #endif /* __MATH_BUILTIN_CONSTANTS */
66
67 #define MATH_ERRNO 1
68 #define MATH_ERREXCEPT 2
69 #define math_errhandling MATH_ERREXCEPT
70
71 #define FP_FAST_FMAF 1
72
73 /* Symbolic constants to classify floating point numbers. */
74 #define FP_INFINITE 0x01
75 #define FP_NAN 0x02
76 #define FP_NORMAL 0x04
77 #define FP_SUBNORMAL 0x08
78 #define FP_ZERO 0x10
79
80 #if (__STDC_VERSION__ >= 201112L && defined(__clang__)) || \
81 __has_extension(c_generic_selections)
82 #define __fp_type_select(x, f, d, ld) _Generic((x), \
83 float: f(x), \
84 double: d(x), \
85 long double: ld(x), \
86 volatile float: f(x), \
87 volatile double: d(x), \
88 volatile long double: ld(x), \
89 volatile const float: f(x), \
90 volatile const double: d(x), \
91 volatile const long double: ld(x), \
92 const float: f(x), \
93 const double: d(x), \
94 const long double: ld(x))
95 #elif __GNUC_PREREQ__(3, 1) && !defined(__cplusplus)
96 #define __fp_type_select(x, f, d, ld) __builtin_choose_expr( \
97 __builtin_types_compatible_p(__typeof(x), long double), ld(x), \
98 __builtin_choose_expr( \
99 __builtin_types_compatible_p(__typeof(x), double), d(x), \
100 __builtin_choose_expr( \
101 __builtin_types_compatible_p(__typeof(x), float), f(x), (void)0)))
102 #else
103 #define __fp_type_select(x, f, d, ld) \
104 ((sizeof(x) == sizeof(float)) ? f(x) \
105 : (sizeof(x) == sizeof(double)) ? d(x) \
106 : ld(x))
107 #endif
108
109 #define fpclassify(x) \
110 __fp_type_select(x, __fpclassifyf, __fpclassifyd, __fpclassifyl)
111 #define isfinite(x) __fp_type_select(x, __isfinitef, __isfinite, __isfinitel)
112 #define isinf(x) __fp_type_select(x, __isinff, __isinf, __isinfl)
113 #define isnan(x) \
114 __fp_type_select(x, __inline_isnanf, __inline_isnan, __inline_isnanl)
115 #define isnormal(x) __fp_type_select(x, __isnormalf, __isnormal, __isnormall)
116
117 #ifdef __MATH_BUILTIN_RELOPS
118 #define isgreater(x, y) __builtin_isgreater((x), (y))
119 #define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
120 #define isless(x, y) __builtin_isless((x), (y))
121 #define islessequal(x, y) __builtin_islessequal((x), (y))
122 #define islessgreater(x, y) __builtin_islessgreater((x), (y))
123 #define isunordered(x, y) __builtin_isunordered((x), (y))
124 #else
125 #define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
126 #define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
127 #define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
128 #define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
129 #define islessgreater(x, y) (!isunordered((x), (y)) && \
130 ((x) > (y) || (y) > (x)))
131 #define isunordered(x, y) (isnan(x) || isnan(y))
132 #endif /* __MATH_BUILTIN_RELOPS */
133
134 #define signbit(x) __fp_type_select(x, __signbitf, __signbit, __signbitl)
135
136 typedef __double_t double_t;
137 typedef __float_t float_t;
138 #endif /* __ISO_C_VISIBLE >= 1999 */
139
140 /*
141 * XOPEN/SVID
142 */
143 #if __BSD_VISIBLE || __XSI_VISIBLE
144 #define M_E 2.7182818284590452354 /* e */
145 #define M_LOG2E 1.4426950408889634074 /* log 2e */
146 #define M_LOG10E 0.43429448190325182765 /* log 10e */
147 #define M_LN2 0.69314718055994530942 /* log e2 */
148 #define M_LN10 2.30258509299404568402 /* log e10 */
149 #define M_PI 3.14159265358979323846 /* pi */
150 #define M_PI_2 1.57079632679489661923 /* pi/2 */
151 #define M_PI_4 0.78539816339744830962 /* pi/4 */
152 #define M_1_PI 0.31830988618379067154 /* 1/pi */
153 #define M_2_PI 0.63661977236758134308 /* 2/pi */
154 #define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
155 #define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
156 #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
157
158 #define MAXFLOAT ((float)3.40282346638528860e+38)
159 extern int signgam;
160 #endif /* __BSD_VISIBLE || __XSI_VISIBLE */
161
162 #if __BSD_VISIBLE
163 #if 0
164 /* Old value from 4.4BSD-Lite math.h; this is probably better. */
165 #define HUGE HUGE_VAL
166 #else
167 #define HUGE MAXFLOAT
168 #endif
169 #endif /* __BSD_VISIBLE */
170
171 /*
172 * Most of these functions depend on the rounding mode and have the side
173 * effect of raising floating-point exceptions, so they are not declared
174 * as __pure2. In C99, FENV_ACCESS affects the purity of these functions.
175 */
176 __BEGIN_DECLS
177 /*
178 * ANSI/POSIX
179 */
180 int __fpclassifyd(double) __pure2;
181 int __fpclassifyf(float) __pure2;
182 int __fpclassifyl(long double) __pure2;
183 int __isfinitef(float) __pure2;
184 int __isfinite(double) __pure2;
185 int __isfinitel(long double) __pure2;
186 int __isinff(float) __pure2;
187 int __isinf(double) __pure2;
188 int __isinfl(long double) __pure2;
189 int __isnormalf(float) __pure2;
190 int __isnormal(double) __pure2;
191 int __isnormall(long double) __pure2;
192 int __signbit(double) __pure2;
193 int __signbitf(float) __pure2;
194 int __signbitl(long double) __pure2;
195
196 static __inline int
197 __inline_isnan(__const double __x)
198 {
199
200 return (__x != __x);
201 }
202
203 static __inline int
204 __inline_isnanf(__const float __x)
205 {
206
207 return (__x != __x);
208 }
209
210 static __inline int
211 __inline_isnanl(__const long double __x)
212 {
213
214 return (__x != __x);
215 }
216
217 /*
218 * Version 2 of the Single UNIX Specification (UNIX98) defined isnan() and
219 * isinf() as functions taking double. C99, and the subsequent POSIX revisions
220 * (SUSv3, POSIX.1-2001, define it as a macro that accepts any real floating
221 * point type. If we are targeting SUSv2 and C99 or C11 (or C++11) then we
222 * expose the newer definition, assuming that the language spec takes
223 * precedence over the operating system interface spec.
224 */
225 #if __XSI_VISIBLE > 0 && __XSI_VISIBLE < 600 && __ISO_C_VISIBLE < 1999
226 #undef isinf
227 #undef isnan
228 int isinf(double);
229 int isnan(double);
230 #endif
231
232 double acos(double);
233 double asin(double);
234 double atan(double);
235 double atan2(double, double);
236 double cos(double);
237 double sin(double);
238 double tan(double);
239
240 double cosh(double);
241 double sinh(double);
242 double tanh(double);
243
244 double exp(double);
245 double frexp(double, int *); /* fundamentally !__pure2 */
246 double ldexp(double, int);
247 double log(double);
248 double log10(double);
249 double modf(double, double *); /* fundamentally !__pure2 */
250
251 double pow(double, double);
252 double sqrt(double);
253
254 double ceil(double);
255 double fabs(double) __pure2;
256 double floor(double);
257 double fmod(double, double);
258
259 /*
260 * These functions are not in C90.
261 */
262 #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE
263 double acosh(double);
264 double asinh(double);
265 double atanh(double);
266 double cbrt(double);
267 double erf(double);
268 double erfc(double);
269 double exp2(double);
270 double expm1(double);
271 double fma(double, double, double);
272 double hypot(double, double);
273 int ilogb(double) __pure2;
274 double lgamma(double);
275 long long llrint(double);
276 long long llround(double);
277 double log1p(double);
278 double log2(double);
279 double logb(double);
280 long lrint(double);
281 long lround(double);
282 double nan(const char *) __pure2;
283 double nextafter(double, double);
284 double remainder(double, double);
285 double remquo(double, double, int *);
286 double rint(double);
287 #endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
288
289 #if __BSD_VISIBLE || __XSI_VISIBLE
290 double j0(double);
291 double j1(double);
292 double jn(int, double);
293 double y0(double);
294 double y1(double);
295 double yn(int, double);
296
297 #if __XSI_VISIBLE <= 500 || __BSD_VISIBLE
298 double gamma(double);
299 #endif
300
301 #if __XSI_VISIBLE <= 600 || __BSD_VISIBLE
302 double scalb(double, double);
303 #endif
304 #endif /* __BSD_VISIBLE || __XSI_VISIBLE */
305
306 #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999
307 double copysign(double, double) __pure2;
308 double fdim(double, double);
309 double fmax(double, double) __pure2;
310 double fmin(double, double) __pure2;
311 double nearbyint(double);
312 double round(double);
313 double scalbln(double, long);
314 double scalbn(double, int);
315 double tgamma(double);
316 double trunc(double);
317 #endif
318
319 /*
320 * BSD math library entry points
321 */
322 #if __BSD_VISIBLE
323 double drem(double, double);
324 int finite(double) __pure2;
325 int isnanf(float) __pure2;
326
327 /*
328 * Reentrant version of gamma & lgamma; passes signgam back by reference
329 * as the second argument; user must allocate space for signgam.
330 */
331 double gamma_r(double, int *);
332 double lgamma_r(double, int *);
333
334 /*
335 * IEEE Test Vector
336 */
337 double significand(double);
338 #endif /* __BSD_VISIBLE */
339
340 /* float versions of ANSI/POSIX functions */
341 #if __ISO_C_VISIBLE >= 1999
342 float acosf(float);
343 float asinf(float);
344 float atanf(float);
345 float atan2f(float, float);
346 float cosf(float);
347 float sinf(float);
348 float tanf(float);
349
350 float coshf(float);
351 float sinhf(float);
352 float tanhf(float);
353
354 float exp2f(float);
355 float expf(float);
356 float expm1f(float);
357 float frexpf(float, int *); /* fundamentally !__pure2 */
358 int ilogbf(float) __pure2;
359 float ldexpf(float, int);
360 float log10f(float);
361 float log1pf(float);
362 float log2f(float);
363 float logf(float);
364 float modff(float, float *); /* fundamentally !__pure2 */
365
366 float powf(float, float);
367 float sqrtf(float);
368
369 float ceilf(float);
370 float fabsf(float) __pure2;
371 float floorf(float);
372 float fmodf(float, float);
373 float roundf(float);
374
375 float erff(float);
376 float erfcf(float);
377 float hypotf(float, float);
378 float lgammaf(float);
379 float tgammaf(float);
380
381 float acoshf(float);
382 float asinhf(float);
383 float atanhf(float);
384 float cbrtf(float);
385 float logbf(float);
386 float copysignf(float, float) __pure2;
387 long long llrintf(float);
388 long long llroundf(float);
389 long lrintf(float);
390 long lroundf(float);
391 float nanf(const char *) __pure2;
392 float nearbyintf(float);
393 float nextafterf(float, float);
394 float remainderf(float, float);
395 float remquof(float, float, int *);
396 float rintf(float);
397 float scalblnf(float, long);
398 float scalbnf(float, int);
399 float truncf(float);
400
401 float fdimf(float, float);
402 float fmaf(float, float, float);
403 float fmaxf(float, float) __pure2;
404 float fminf(float, float) __pure2;
405 #endif
406
407 /*
408 * float versions of BSD math library entry points
409 */
410 #if __BSD_VISIBLE
411 float dremf(float, float);
412 int finitef(float) __pure2;
413 float gammaf(float);
414 float j0f(float);
415 float j1f(float);
416 float jnf(int, float);
417 float scalbf(float, float);
418 float y0f(float);
419 float y1f(float);
420 float ynf(int, float);
421
422 /*
423 * Float versions of reentrant version of gamma & lgamma; passes
424 * signgam back by reference as the second argument; user must
425 * allocate space for signgam.
426 */
427 float gammaf_r(float, int *);
428 float lgammaf_r(float, int *);
429
430 /*
431 * float version of IEEE Test Vector
432 */
433 float significandf(float);
434 #endif /* __BSD_VISIBLE */
435
436 /*
437 * long double versions of ISO/POSIX math functions
438 */
439 #if __ISO_C_VISIBLE >= 1999
440 long double acoshl(long double);
441 long double acosl(long double);
442 long double asinhl(long double);
443 long double asinl(long double);
444 long double atan2l(long double, long double);
445 long double atanhl(long double);
446 long double atanl(long double);
447 long double cbrtl(long double);
448 long double ceill(long double);
449 long double copysignl(long double, long double) __pure2;
450 long double coshl(long double);
451 long double cosl(long double);
452 long double erfcl(long double);
453 long double erfl(long double);
454 long double exp2l(long double);
455 long double expl(long double);
456 long double expm1l(long double);
457 long double fabsl(long double) __pure2;
458 long double fdiml(long double, long double);
459 long double floorl(long double);
460 long double fmal(long double, long double, long double);
461 long double fmaxl(long double, long double) __pure2;
462 long double fminl(long double, long double) __pure2;
463 long double fmodl(long double, long double);
464 long double frexpl(long double value, int *); /* fundamentally !__pure2 */
465 long double hypotl(long double, long double);
466 int ilogbl(long double) __pure2;
467 long double ldexpl(long double, int);
468 long double lgammal(long double);
469 long long llrintl(long double);
470 long long llroundl(long double);
471 long double log10l(long double);
472 long double log1pl(long double);
473 long double log2l(long double);
474 long double logbl(long double);
475 long double logl(long double);
476 long lrintl(long double);
477 long lroundl(long double);
478 long double modfl(long double, long double *); /* fundamentally !__pure2 */
479 long double nanl(const char *) __pure2;
480 long double nearbyintl(long double);
481 long double nextafterl(long double, long double);
482 double nexttoward(double, long double);
483 float nexttowardf(float, long double);
484 long double nexttowardl(long double, long double);
485 long double powl(long double, long double);
486 long double remainderl(long double, long double);
487 long double remquol(long double, long double, int *);
488 long double rintl(long double);
489 long double roundl(long double);
490 long double scalblnl(long double, long);
491 long double scalbnl(long double, int);
492 long double sinhl(long double);
493 long double sinl(long double);
494 long double sqrtl(long double);
495 long double tanhl(long double);
496 long double tanl(long double);
497 long double tgammal(long double);
498 long double truncl(long double);
499 #endif /* __ISO_C_VISIBLE >= 1999 */
500
501 #if __BSD_VISIBLE
502 long double lgammal_r(long double, int *);
503 #endif
504
505 __END_DECLS
506
507 #endif /* !_MATH_H_ */

Properties

Name Value
svn:keywords FreeBSD=%H

  ViewVC Help
Powered by ViewVC 1.1.27