y1l(3) - f38

1y0(3)                      Library Functions Manual                      y0(3)
2
3
4

NAME

6       y0, y0f, y0l, y1, y1f, y1l, yn, ynf, ynl - Bessel functions of the sec‐
7       ond kind
8

LIBRARY

10       Math library (libm, -lm)
11

SYNOPSIS

13       #include <math.h>
14
15       double y0(double x);
16       double y1(double x);
17       double yn(int n, double x);
18
19       float y0f(float x);
20       float y1f(float x);
21       float ynf(int n, float x);
22
23       long double y0l(long double x);
24       long double y1l(long double x);
25       long double ynl(int n, long double x);
26
27   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
28
29       y0(), y1(), yn():
30           _XOPEN_SOURCE
31               || /* Since glibc 2.19: */ _DEFAULT_SOURCE
32               || /* glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE
33
34       y0f(), y0l(), y1f(), y1l(), ynf(), ynl():
35           _XOPEN_SOURCE >= 600
36               || (_ISOC99_SOURCE && _XOPEN_SOURCE)
37               || /* Since glibc 2.19: */ _DEFAULT_SOURCE
38               || /* glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE
39

DESCRIPTION

41       The y0() and y1() functions return Bessel functions of x of the  second
42       kind  of  orders  0 and 1, respectively.  The yn() function returns the
43       Bessel function of x of the second kind of order n.
44
45       The value of x must be positive.
46
47       The y0f(), y1f(), and ynf() functions are versions that take and return
48       float  values.  The y0l(), y1l(), and ynl() functions are versions that
49       take and return long double values.
50

RETURN VALUE

52       On success, these functions return the appropriate Bessel value of  the
53       second kind for x.
54
55       If x is a NaN, a NaN is returned.
56
57       If  x  is  negative,  a  domain  error occurs, and the functions return
58       -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL, respectively.  (POSIX.1-2001 also
59       allows a NaN return for this case.)
60
61       If  x  is 0.0, a pole error occurs, and the functions return -HUGE_VAL,
62       -HUGE_VALF, or -HUGE_VALL, respectively.
63
64       If the result underflows, a range error occurs, and the  functions  re‐
65       turn 0.0
66
67       If the result overflows, a range error occurs, and the functions return
68       -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL, respectively.  (POSIX.1-2001 also
69       allows a 0.0 return for this case.)
70

ERRORS

72       See  math_error(7) for information on how to determine whether an error
73       has occurred when calling these functions.
74
75       The following errors can occur:
76
77       Domain error: x is negative
78              errno is set  to  EDOM.   An  invalid  floating-point  exception
79              (FE_INVALID) is raised.
80
81       Pole error: x is 0.0
82              errno  is  set to ERANGE and an FE_DIVBYZERO exception is raised
83              (but see BUGS).
84
85       Range error: result underflow
86              errno is set to ERANGE.  No FE_UNDERFLOW exception  is  returned
87              by fetestexcept(3) for this case.
88
89       Range error: result overflow
90              errno  is  set  to ERANGE (but see BUGS).  An overflow floating-
91              point exception (FE_OVERFLOW) is raised.
92

ATTRIBUTES

94       For an  explanation  of  the  terms  used  in  this  section,  see  at‐
95       tributes(7).
96
97       ┌────────────────────────────────────────────┬───────────────┬─────────┐
98       │Interface                                   │ Attribute     │ Value   │
99       ├────────────────────────────────────────────┼───────────────┼─────────┤
100       │y0(), y0f(), y0l()                          │ Thread safety │ MT-Safe │
101       ├────────────────────────────────────────────┼───────────────┼─────────┤
102       │y1(), y1f(), y1l()                          │ Thread safety │ MT-Safe │
103       ├────────────────────────────────────────────┼───────────────┼─────────┤
104       │yn(), ynf(), ynl()                          │ Thread safety │ MT-Safe │
105       └────────────────────────────────────────────┴───────────────┴─────────┘
106

STANDARDS

108       y0()
109       y1()
110       yn()   POSIX.1-2008.
111
112       Others:
113              BSD.
114

HISTORY

116       y0()
117       y1()
118       yn()   SVr4, 4.3BSD, POSIX.1-2001.
119
120       Others:
121              BSD.
122

BUGS

124       Before  glibc 2.19, these functions misdiagnosed pole errors: errno was
125       set to EDOM, instead  of  ERANGE  and  no  FE_DIVBYZERO  exception  was
126       raised.
127
128       Before  glibc  2.17,  did not set errno for "range error: result under‐
129       flow".
130
131       In glibc 2.3.2 and earlier, these functions do  not  raise  an  invalid
132       floating-point exception (FE_INVALID) when a domain error occurs.
133