--- /dev/null
+ACOS(3) BSD Programmer's Manual ACOS(3)
+
+N\bNA\bAM\bME\bE
+ a\bac\bco\bos\bs - arc cosine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ a\bac\bco\bos\bs(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The a\bac\bco\bos\bs() function computes the principal value of the arc cosine of _\bx.
+ A domain error occurs for arguments not in the range [-1, +1]. For a
+ discussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The a\bac\bco\bos\bs() function returns the arc cosine in the range [0, pi] radians.
+ On the VAX and Tahoe, if:
+
+ |_\bx| > 1,
+
+ a\bac\bco\bos\bs(_\bx) sets the global variable _\be_\br_\br_\bn_\bo to EDOM and a reserved operand
+ fault is generated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ sin(3), cos(3), tan(3), asin(3), atan(3), atan2(3), sinh(3),
+ cosh(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The a\bac\bco\bos\bs() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+ACOSH(3) BSD Programmer's Manual ACOSH(3)
+
+N\bNA\bAM\bME\bE
+ a\bac\bco\bos\bsh\bh - inverse hyperbolic cosine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ a\bac\bco\bos\bsh\bh(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The a\bac\bco\bos\bsh\bh() function computes the inverse hyperbolic cosine of the real
+ argument _\bx. For a discussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The a\bac\bco\bos\bsh\bh() function returns the inverse hyperbolic cosine of _\bx. On the
+ VAX and Tahoe, if the argument is less than one a\bac\bco\bos\bsh\bh() sets the global
+ variable _\be_\br_\br_\bn_\bo to EDOM and causes a reserved operand fault.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ asinh(3), atanh(3), exp(3), infnan(3) math(3),
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The a\bac\bco\bos\bsh\bh() function appeared in 4.3BSD.
+
+4.3 Berkeley Distribution June 4, 1993 1
--- /dev/null
+ASIN(3) BSD Programmer's Manual ASIN(3)
+
+N\bNA\bAM\bME\bE
+ a\bas\bsi\bin\bn - arc sine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ a\bas\bsi\bin\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The a\bas\bsi\bin\bn() function computes the principal value of the arc sine of _\bx. A
+ domain error occurs for arguments not in the range [-1, +1]. For a dis-
+ cussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The a\bas\bsi\bin\bn() function returns the arc sine in the range [-pi/2, +pi/2] ra-
+ dians. On the VAX, and Tahoe , if:
+
+ |_\bx| > 1
+
+ the global variable _\be_\br_\br_\bn_\bo is set to EDOM and a reserved operand fault
+ generated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), atan(3), atan2(3), cos(3), cosh(3), sin(3), sinh(3),
+ tan(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The a\bas\bsi\bin\bn() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+ASINH(3) BSD Programmer's Manual ASINH(3)
+
+N\bNA\bAM\bME\bE
+ a\bas\bsi\bin\bnh\bh - inverse hyperbolic sine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ a\bas\bsi\bin\bnh\bh(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The a\bas\bsi\bin\bnh\bh() function computes the inverse hyperbolic sine of the real ar-
+ gument _\bx. For a discussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The a\bas\bsi\bin\bnh\bh() function returns the inverse hyperbolic sine of _\bx.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acosh(3), atanh(3), exp(3), infnan(3) math(3),
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The a\bas\bsi\bin\bnh\bh() function appeared in 4.3BSD.
+
+4.3 Berkeley Distribution June 4, 1993 1
--- /dev/null
+ATAN(3) BSD Programmer's Manual ATAN(3)
+
+N\bNA\bAM\bME\bE
+ a\bat\bta\ban\bn - arc tangent function of one variable
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ a\bat\bta\ban\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The a\bat\bta\ban\bn() function computes the principal value of the arc tangent of _\bx.
+ For a discussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The a\bat\bta\ban\bn() function returns the arc tangent in the range [-pi/2, +pi/2]
+ radians.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), asin(3), atan2(3), cos(3), cosh(3), sin(3), sinh(3),
+ tan(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The a\bat\bta\ban\bn() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+ATAN2(3) BSD Programmer's Manual ATAN2(3)
+
+N\bNA\bAM\bME\bE
+ a\bat\bta\ban\bn2\b2 - arc tangent function of two variables
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ a\bat\bta\ban\bn2\b2(_\bd_\bo_\bu_\bb_\bl_\be _\by, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The atan2 function computes the principal value of the arc tangent of
+ _\by_\b/_\bx, using the signs of both arguments to determine the quadrant of the
+ return value.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The atan2 function, if successful, returns the arc tangent of _\by_\b/_\bx in the
+ range [-pi, +pi] radians. If both _\bx and _\by are zero, the global variable
+ _\be_\br_\br_\bn_\bo is set to EDOM. On the VAX:
+
+ a\bat\bta\ban\bn2\b2(_\by, _\bx):= a\bat\bta\ban\bn(_\by_\b/_\bx) if _\bx > 0,
+ sign(_\by)*(pi - a\bat\bta\ban\bn(|_\by_\b/_\bx|)) if _\bx < 0,
+ 0 if x = y = 0, or
+ sign(_\by)*pi/2 if _\bx = 0 _\by.
+
+N\bNO\bOT\bTE\bES\bS
+ The function a\bat\bta\ban\bn2\b2() defines "if x > 0," a\bat\bta\ban\bn2\b2(_\b0, _\b0) = 0 on a VAX despite
+ that previously a\bat\bta\ban\bn2\b2(_\b0, _\b0) may have generated an error message. The
+ reasons for assigning a value to a\bat\bta\ban\bn2\b2(_\b0, _\b0) are these:
+
+ 1. Programs that test arguments to avoid computing a\bat\bta\ban\bn2\b2(_\b0, _\b0)
+ must be indifferent to its value. Programs that require it to
+ be invalid are vulnerable to diverse reactions to that inva-
+ lidity on diverse computer systems.
+
+ 2. The a\bat\bta\ban\bn2\b2() function is used mostly to convert from rectangu-
+ lar (x,y) to polar (r,theta) coordinates that must satisfy x =
+ r*cos theta and y = r*sin theta. These equations are satis-
+ fied when (x=0,y=0) is mapped to (r=0,theta=0) on a VAX. In
+ general, conversions to polar coordinates should be computed
+ thus:
+
+ r := hypot(x,y); ... := sqrt(x*x+y*y)
+ theta := atan2(y,x).
+
+ 3. The foregoing formulas need not be altered to cope in a rea-
+ sonable way with signed zeros and infinities on a machine that
+ conforms to IEEE 754; the versions of hypot(3) and a\bat\bta\ban\bn2\b2()
+ provided for such a machine are designed to handle all cases.
+ That is why a\bat\bta\ban\bn2\b2(_\b+_\b-_\b0, _\b-_\b0) = +-pi for instance. In general
+ the formulas above are equivalent to these:
+
+ r := sqrt(x*x+y*y); if r = 0 then x := copysign(1,x);
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), asin(3), atan(3), cos(3), cosh(3), sin(3), sinh(3),
+ tan(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The a\bat\bta\ban\bn2\b2() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+ATANH(3) BSD Programmer's Manual ATANH(3)
+
+N\bNA\bAM\bME\bE
+ a\bat\bta\ban\bnh\bh - inverse hyperbolic tangent function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ a\bat\bta\ban\bnh\bh(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The a\bat\bta\ban\bnh\bh() function computes the inverse hyperbolic tangent of the real
+ argument _\bx. For a discussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The a\bat\bta\ban\bnh\bh() function returns the inverse hyperbolic tangent of _\bx if suc-
+ cessful. On the VAX and Tahoe, if the argument has absolute value bigger
+ than or equal to 1, a\bat\bta\ban\bnh\bh() sets the global variable _\be_\br_\br_\bn_\bo to EDOM and a
+ reserved operand fault is generated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acosh(3), asinh(3), exp(3), infnan(3) math(3),
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The a\bat\bta\ban\bnh\bh() function appeared in 4.3BSD.
+
+4.3 Berkeley Distribution June 4, 1993 1
--- /dev/null
+HYPOT(3) BSD Programmer's Manual HYPOT(3)
+
+N\bNA\bAM\bME\bE
+ h\bhy\byp\bpo\bot\bt, c\bca\bab\bbs\bs - euclidean distance and complex absolute value functions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ h\bhy\byp\bpo\bot\bt(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ s\bst\btr\bru\buc\bct\bt {\b{d\bdo\bou\bub\bbl\ble\be x\bx,\b, y\by;\b;}\b} z\bz;\b;
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bca\bab\bbs\bs(_\bz);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The h\bhy\byp\bpo\bot\bt() and c\bca\bab\bbs\bs() functions computes the sqrt(x*x+y*y) in such a way
+ that underflow will not happen, and overflow occurs only if the final re-
+ sult deserves it.
+
+ h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bv) = h\bhy\byp\bpo\bot\bt(_\bv, _\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = +infinity for all _\bv, including
+ _\bN_\ba_\bN.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf,\b, e\bet\btc\bc.\b.)\b)
+ Below 0.97 _\bu_\bl_\bp_\bs. Consequently h\bhy\byp\bpo\bot\bt(_\b5_\b._\b0, _\b1_\b2_\b._\b0) = 13.0 exactly; in gener-
+ al, hypot and cabs return an integer whenever an integer might be expect-
+ ed.
+
+ The same cannot be said for the shorter and faster version of hypot and
+ cabs that is provided in the comments in cabs.c; its error can exceed 1.2
+ _\bu_\bl_\bp_\bs.
+
+N\bNO\bOT\bTE\bES\bS
+ As might be expected, h\bhy\byp\bpo\bot\bt(_\bv, _\bN_\ba_\bN) and h\bhy\byp\bpo\bot\bt(_\bN_\ba_\bN, _\bv) are _\bN_\ba_\bN for all
+ _\bf_\bi_\bn_\bi_\bt_\be _\bv; with "reserved operand" in place of "_\bN_\ba_\bN", the same is true on
+ a VAX. But programmers on machines other than a VAX (if has no infinity)
+ might be surprised at first to discover that h\bhy\byp\bpo\bot\bt(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bN_\ba_\bN) =
+ +infinity. This is intentional; it happens because h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bv) =
+ +infinity for _\ba_\bl_\bl _\bv, finite or infinite. Hence h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bv) is in-
+ dependent of _\bv. Unlike the reserved operand fault on a VAX, the IEEE _\bN_\ba_\bN
+ is designed to disappear when it turns out to be irrelevant, as it does
+ in h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bN_\ba_\bN).
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), sqrt(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ Both a h\bhy\byp\bpo\bot\bt() function and a c\bca\bab\bbs\bs() function appeared in Version 7 AT&T
+ UNIX.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+CEIL(3) BSD Programmer's Manual CEIL(3)
+
+N\bNA\bAM\bME\bE
+ c\bce\bei\bil\bl - smallest integral value not greater than x
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bce\bei\bil\bl(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The c\bce\bei\bil\bl() function computes the smallest integral value not less than _\bx.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The c\bce\bei\bil\bl() function returns the smallest integral value expressed as a
+ double.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ abs(3), fabs(3), floor(3), rint(3), ieee(3), math.3
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The c\bce\bei\bil\bl() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+IEEE(3) BSD Programmer's Manual IEEE(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn, d\bdr\bre\bem\bm, f\bfi\bin\bni\bit\bte\be, l\blo\bog\bgb\bb, s\bsc\bca\bal\blb\bb - IEEE 754 floating point support
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ d\bdr\bre\bem\bm(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bi_\bn_\bt
+ f\bfi\bin\bni\bit\bte\be(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bgb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsc\bca\bal\blb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bi_\bn_\bt _\bn);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions are required for, or recommended by the IEEE standard 754
+ for floating-point arithmetic.
+
+ The c\bco\bop\bpy\bys\bsi\big\bgn\bn() function returns _\bx with its sign changed to _\by's.
+
+ The d\bdr\bre\bem\bm() function returns the remainder _\br := _\bx - _\bn_\b*_\by where _\bn is the in-
+ teger nearest the exact value of _\bx/_\by; moreover if |_\bn - _\bx/_\by| = 1/2 then _\bn
+ is even. Consequently the remainder is computed exactly and |_\br| <=
+ |_\by|/2. But d\bdr\bre\bem\bm(_\bx, _\b0) is exceptional. (See below under _\bD_\bI_\bA_\bG_\bN_\bO_\bS_\bT_\bI_\bC_\bS.)
+
+ The f\bfi\bin\bni\bit\bte\be() function returns the value 1 just when -infinity < _\bx < +in-
+ finity; otherwise a zero is returned (when |_\bx| = infinity or _\bx is _\bN_\ba_\bN or
+ is the VAX's reserved operand).
+
+ The l\blo\bog\bgb\bb() function returns _\bx's exponent _\bn, a signed integer converted to
+ double-precision floating-point and so chosen that 1 (<= |_\bx|2**_\bn < 2 un-
+ less _\bx = 0 or (only on machines that conform to IEEE 754) |_\bx| = infinity
+ or _\bx lies between 0 and the Underflow Threshold. (See below under _\bB_\bU_\bG_\bS.)
+
+ The s\bsc\bca\bal\blb\bb() function returns _\bx*(2**_\bn) computed, for integer n, without
+ first computing 2*_\bn.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The IEEE standard 754 defines d\bdr\bre\bem\bm(_\bx, _\b0) and d\bdr\bre\bem\bm(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\by) to be in-
+ valid operations that produce a _\bN_\ba_\bN. On the VAX, d\bdr\bre\bem\bm(_\bx, _\b0) generates a
+ reserved operand fault. No infinity exists on a VAX.
+
+ IEEE 754 defines l\blo\bog\bgb\bb(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = infinity and l\blo\bog\bgb\bb(_\b0) = -infinity, and
+ requires the latter to signal Division-by-Zero. But on a VAX, l\blo\bog\bgb\bb(_\b0) =
+ 1.0 - 2.0**31 = -2,147,483,647.0. And if the correct value of s\bsc\bca\bal\blb\bb()
+ would overflow on a VAX, it generates a reserved operand fault and sets
+ the global variable _\be_\br_\br_\bn_\bo to ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ floor(3), math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bie\bee\bee\be functions appeared in 4.3BSD.
+
+B\bBU\bUG\bGS\bS
+ Should d\bdr\bre\bem\bm(_\bx, _\b0) and l\blo\bog\bgb\bb(_\b0) on a VAX signal invalidity by setting _\be_\br_\br_\bn_\bo
+ = EDOM ? Should l\blo\bog\bgb\bb(_\b0) return -1.7e38?
+
+ IEEE 754 currently specifies that l\blo\bog\bgb\bb(_\bd_\be_\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b.) = l\blo\bog\bgb\bb(_\bt_\bi_\bn_\bi_\be_\bs_\bt
+ _\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b. _\b> _\b0) but the consensus has changed to the specification in
+ the new proposed IEEE standard p854, namely that l\blo\bog\bgb\bb(_\bx) satisfy
+
+ 1 <= s\bsc\bca\bal\blb\bb(|_\bx|, _\b-_\bl_\bo_\bg_\bb_\b(_\bx_\b)) < Radix ... = 2 for IEEE 754
+
+ for every x except 0, infinity and _\bN_\ba_\bN. Almost every program that as-
+ sumes 754's specification will work correctly if l\blo\bog\bgb\bb() follows 854's
+ specification instead.
+
+ IEEE 754 requires c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\bN_\ba_\bN_\b)) = +-_\bx but says nothing else about the
+ sign of a _\bN_\ba_\bN. A _\bN_\ba_\bN _\b(_\bNot _\ba _\bNumber) is similar in spirit to the VAX's
+ reserved operand, but very different in important details. Since the
+ sign bit of a reserved operand makes it look negative,
+
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\br_\be_\bs_\be_\br_\bv_\be_\bd _\bo_\bp_\be_\br_\ba_\bn_\bd) = -_\bx;
+
+ should this return the reserved operand instead?
+
+4.3 Berkeley Distribution June 4, 1993 2
--- /dev/null
+COS(3) BSD Programmer's Manual COS(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bos\bs - cosine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bos\bs(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The c\bco\bos\bs() function computes the cosine of _\bx (measured in radians). A
+ large magnitude argument may yield a result with little or no signifi-
+ cance. For a discussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The c\bco\bos\bs() function returns the cosine value.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ sin(3), tan(3), asin(3), acos(3), atan(3), atan2(3), sinh(3),
+ cosh(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The a\bac\bco\bos\bs() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+COSH(3) BSD Programmer's Manual COSH(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bos\bsh\bh - hyperbolic cosine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bos\bsh\bh(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The c\bco\bos\bsh\bh() function computes the hyperbolic cosine of _\bx.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The c\bco\bos\bsh\bh() function returns the hyperbolic cosine unless the magnitude of
+ _\bx is too large; in this event, the global variable _\be_\br_\br_\bn_\bo is set to
+ ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), asin(3), atan(3), atan2(3), cos(3), sin(3), sinh(3),
+ tan(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The c\bco\bos\bsh\bh() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+CURSES(3) BSD Programmer's Manual CURSES(3)
+
+N\bNA\bAM\bME\bE
+ c\bcu\bur\brs\bse\bes\bs - screen functions with ``optimal'' cursor motion
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ c\bcc\bc [_\bf_\bl_\ba_\bg_\bs] _\bf_\bi_\bl_\be_\bs -\b-l\blc\bcu\bur\brs\bse\bes\bs -\b-l\blt\bte\ber\brm\bmc\bca\bap\bp [_\bl_\bi_\bb_\br_\ba_\br_\bi_\be_\bs]
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These routines give the user a method of updating screens with reasonable
+ optimization. They keep an image of the current screen, and the user
+ sets up an image of a new one. Then the r\bre\bef\bfr\bre\bes\bsh\bh() tells the routines to
+ make the current screen look like the new one. In order to initialize
+ the routines, the routine i\bin\bni\bit\bts\bsc\bcr\br() must be called before any of the oth-
+ er routines that deal with windows and screens are used. The routine
+ e\ben\bnd\bdw\bwi\bin\bn() should be called before exiting.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ioctl(2), getenv(3), tty(4), termcap(5)
+
+ Ken Arnold, _\bS_\bc_\br_\be_\be_\bn _\bU_\bp_\bd_\ba_\bt_\bi_\bn_\bg _\ba_\bn_\bd _\bC_\bu_\br_\bs_\bo_\br _\bM_\bo_\bv_\be_\bm_\be_\bn_\bt _\bO_\bp_\bt_\bi_\bm_\bi_\bz_\ba_\bt_\bi_\bo_\bn_\b: _\bA _\bL_\bi_\bb_\br_\ba_\br_\by
+ _\bP_\ba_\bc_\bk_\ba_\bg_\be.
+
+A\bAU\bUT\bTH\bHO\bOR\bR
+ Ken Arnold
+
+F\bFU\bUN\bNC\bCT\bTI\bIO\bON\bNS\bS
+ addch(ch) add a character to _\bs_\bt_\bd_\bs_\bc_\br
+ addstr(str) add a string to _\bs_\bt_\bd_\bs_\bc_\br
+ box(win,vert,hor) draw a box around a window
+ cbreak() set cbreak mode
+ clear() clear _\bs_\bt_\bd_\bs_\bc_\br
+ clearok(scr,boolf) set clear flag for _\bs_\bc_\br
+ clrtobot() clear to bottom on _\bs_\bt_\bd_\bs_\bc_\br
+ clrtoeol() clear to end of line on
+ _\bs_\bt_\bd_\bs_\bc_\br
+ delch() delete a character
+ deleteln() delete a line
+ delwin(win) delete _\bs_\bt_\bd_\bs_\bc_\br
+ echo() set echo mode
+ endwin() end window modes
+ erase() erase _\bs_\bt_\bd_\bs_\bc_\br
+ flusok(win,boolf) set flush-on-refresh flag
+ for _\bw_\bi_\bn
+ getch() get a char through _\bs_\bt_\bd_\bs_\bc_\br
+ getcap(name) get terminal capability _\bn_\ba_\bm_\be
+ getstr(str) get a string through _\bs_\bt_\bd_\bs_\bc_\br
+ gettmode() get tty modes
+ getyx(win,y,x) get (y,x) co-ordinates
+ inch() get char at current (y,x)
+ co-ordinates
+ initscr() initialize screens
+ insch(c) insert a char
+ insertln() insert a line
+ leaveok(win,boolf) set leave flag for _\bs_\bt_\bd_\bs_\bc_\br
+ longname(termbuf,name) get long name from _\bt_\be_\br_\bm_\bb_\bu_\bf
+ move(y,x) move to (y,x) on _\bs_\bt_\bd_\bs_\bc_\br
+ mvcur(lasty,lastx,newy,newx) actually move cursor
+ newwin(lines,cols,begin_y,begin_x) create a new window
+ nl() set newline mapping
+ nocbreak() unset cbreak mode
+ noecho() unset echo mode
+ nonl() unset newline mapping
+
+
+ noraw() unset raw mode
+ overlay(win1,win2) overlay win1 on win2
+ overwrite(win1,win2) overwrite win1 on top of
+ win2
+ printw(fmt,arg1,arg2,...) printf on _\bs_\bt_\bd_\bs_\bc_\br
+ raw() set raw mode
+ refresh() make current screen look
+ like _\bs_\bt_\bd_\bs_\bc_\br
+ resetty() reset tty flags to stored
+ value
+ savetty() stored current tty flags
+ scanw(fmt,arg1,arg2,...) scanf through _\bs_\bt_\bd_\bs_\bc_\br
+ scroll(win) scroll _\bw_\bi_\bn one line
+ scrollok(win,boolf) set scroll flag
+ setterm(name) set term variables for name
+ standend() end standout mode
+ standout() start standout mode
+ subwin(win,lines,cols,begin_y,begin_x) create a subwindow
+ touchline(win,y,sx,ex) mark line _\by _\bs_\bx through _\bs_\by as
+ changed
+ touchoverlap(win1,win2) mark overlap of _\bw_\bi_\bn_\b1 on _\bw_\bi_\bn_\b2
+ as changed
+ touchwin(win) change all of _\bw_\bi_\bn
+ unctrl(ch) printable version of _\bc_\bh
+ waddch(win,ch) add char to _\bw_\bi_\bn
+ waddstr(win,str) add string to _\bw_\bi_\bn
+ wclear(win) clear _\bw_\bi_\bn
+ wclrtobot(win) clear to bottom of _\bw_\bi_\bn
+ wclrtoeol(win) clear to end of line on _\bw_\bi_\bn
+ wdelch(win,c) delete char from _\bw_\bi_\bn
+ wdeleteln(win) delete line from _\bw_\bi_\bn
+ werase(win) erase _\bw_\bi_\bn
+ wgetch(win) get a char through _\bw_\bi_\bn
+ wgetstr(win,str) get a string through _\bw_\bi_\bn
+ winch(win) get char at current (y,x) in
+ _\bw_\bi_\bn
+ winsch(win,c) insert char into _\bw_\bi_\bn
+ winsertln(win) insert line into _\bw_\bi_\bn
+ wmove(win,y,x) set current (y,x) co-
+ ordinates on _\bw_\bi_\bn
+ wprintw(win,fmt,arg1,arg2,...) printf on _\bw_\bi_\bn
+ wrefresh(win) make screen look like _\bw_\bi_\bn
+ wscanw(win,fmt,arg1,arg2,...) scanf through _\bw_\bi_\bn
+ wstandend(win) end standout mode on _\bw_\bi_\bn
+ wstandout(win) start standout mode on _\bw_\bi_\bn
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The c\bcu\bur\brs\bse\bes\bs package appeared in 4.0BSD.
+
+4th Berkeley Distribution June 4, 1993 2
--- /dev/null
+IEEE(3) BSD Programmer's Manual IEEE(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn, d\bdr\bre\bem\bm, f\bfi\bin\bni\bit\bte\be, l\blo\bog\bgb\bb, s\bsc\bca\bal\blb\bb - IEEE 754 floating point support
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ d\bdr\bre\bem\bm(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bi_\bn_\bt
+ f\bfi\bin\bni\bit\bte\be(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bgb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsc\bca\bal\blb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bi_\bn_\bt _\bn);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions are required for, or recommended by the IEEE standard 754
+ for floating-point arithmetic.
+
+ The c\bco\bop\bpy\bys\bsi\big\bgn\bn() function returns _\bx with its sign changed to _\by's.
+
+ The d\bdr\bre\bem\bm() function returns the remainder _\br := _\bx - _\bn_\b*_\by where _\bn is the in-
+ teger nearest the exact value of _\bx/_\by; moreover if |_\bn - _\bx/_\by| = 1/2 then _\bn
+ is even. Consequently the remainder is computed exactly and |_\br| <=
+ |_\by|/2. But d\bdr\bre\bem\bm(_\bx, _\b0) is exceptional. (See below under _\bD_\bI_\bA_\bG_\bN_\bO_\bS_\bT_\bI_\bC_\bS.)
+
+ The f\bfi\bin\bni\bit\bte\be() function returns the value 1 just when -infinity < _\bx < +in-
+ finity; otherwise a zero is returned (when |_\bx| = infinity or _\bx is _\bN_\ba_\bN or
+ is the VAX's reserved operand).
+
+ The l\blo\bog\bgb\bb() function returns _\bx's exponent _\bn, a signed integer converted to
+ double-precision floating-point and so chosen that 1 (<= |_\bx|2**_\bn < 2 un-
+ less _\bx = 0 or (only on machines that conform to IEEE 754) |_\bx| = infinity
+ or _\bx lies between 0 and the Underflow Threshold. (See below under _\bB_\bU_\bG_\bS.)
+
+ The s\bsc\bca\bal\blb\bb() function returns _\bx*(2**_\bn) computed, for integer n, without
+ first computing 2*_\bn.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The IEEE standard 754 defines d\bdr\bre\bem\bm(_\bx, _\b0) and d\bdr\bre\bem\bm(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\by) to be in-
+ valid operations that produce a _\bN_\ba_\bN. On the VAX, d\bdr\bre\bem\bm(_\bx, _\b0) generates a
+ reserved operand fault. No infinity exists on a VAX.
+
+ IEEE 754 defines l\blo\bog\bgb\bb(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = infinity and l\blo\bog\bgb\bb(_\b0) = -infinity, and
+ requires the latter to signal Division-by-Zero. But on a VAX, l\blo\bog\bgb\bb(_\b0) =
+ 1.0 - 2.0**31 = -2,147,483,647.0. And if the correct value of s\bsc\bca\bal\blb\bb()
+ would overflow on a VAX, it generates a reserved operand fault and sets
+ the global variable _\be_\br_\br_\bn_\bo to ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ floor(3), math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bie\bee\bee\be functions appeared in 4.3BSD.
+
+B\bBU\bUG\bGS\bS
+ Should d\bdr\bre\bem\bm(_\bx, _\b0) and l\blo\bog\bgb\bb(_\b0) on a VAX signal invalidity by setting _\be_\br_\br_\bn_\bo
+ = EDOM ? Should l\blo\bog\bgb\bb(_\b0) return -1.7e38?
+
+ IEEE 754 currently specifies that l\blo\bog\bgb\bb(_\bd_\be_\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b.) = l\blo\bog\bgb\bb(_\bt_\bi_\bn_\bi_\be_\bs_\bt
+ _\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b. _\b> _\b0) but the consensus has changed to the specification in
+ the new proposed IEEE standard p854, namely that l\blo\bog\bgb\bb(_\bx) satisfy
+
+ 1 <= s\bsc\bca\bal\blb\bb(|_\bx|, _\b-_\bl_\bo_\bg_\bb_\b(_\bx_\b)) < Radix ... = 2 for IEEE 754
+
+ for every x except 0, infinity and _\bN_\ba_\bN. Almost every program that as-
+ sumes 754's specification will work correctly if l\blo\bog\bgb\bb() follows 854's
+ specification instead.
+
+ IEEE 754 requires c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\bN_\ba_\bN_\b)) = +-_\bx but says nothing else about the
+ sign of a _\bN_\ba_\bN. A _\bN_\ba_\bN _\b(_\bNot _\ba _\bNumber) is similar in spirit to the VAX's
+ reserved operand, but very different in important details. Since the
+ sign bit of a reserved operand makes it look negative,
+
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\br_\be_\bs_\be_\br_\bv_\be_\bd _\bo_\bp_\be_\br_\ba_\bn_\bd) = -_\bx;
+
+ should this return the reserved operand instead?
+
+4.3 Berkeley Distribution June 4, 1993 2
--- /dev/null
+
+
+
+ECVT(3) BSD Programmer's Manual ECVT(3)
+
+
+N\bNA\bAM\bME\bE
+ ecvt, fcvt, gcvt - output conversion
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ c\bch\bha\bar\br *\b*e\bec\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, d\bde\bec\bcp\bpt\bt,\b, s\bsi\big\bgn\bn)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ i\bin\bnt\bt n\bnd\bdi\big\bgi\bit\bt,\b, *\b*d\bde\bec\bcp\bpt\bt,\b, *\b*s\bsi\big\bgn\bn;\b;
+
+ c\bch\bha\bar\br *\b*f\bfc\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, d\bde\bec\bcp\bpt\bt,\b, s\bsi\big\bgn\bn)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ i\bin\bnt\bt n\bnd\bdi\big\bgi\bit\bt,\b, *\b*d\bde\bec\bcp\bpt\bt,\b, *\b*s\bsi\big\bgn\bn;\b;
+
+ c\bch\bha\bar\br *\b*g\bgc\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, b\bbu\buf\bf)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ c\bch\bha\bar\br *\b*b\bbu\buf\bf;\b;
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhe\bes\bse\be i\bin\bnt\bte\ber\brf\bfa\bac\bce\bes\bs a\bar\bre\be o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by p\bpr\bri\bin\bnt\btf\bf(\b(3\b3)\b).\b.
+ T\bTh\bhe\bey\by a\bar\bre\be a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bm-\b-
+ p\bpa\bat\bt.\b.
+
+ _\bE_\bc_\bv_\bt converts the _\bv_\ba_\bl_\bu_\be to a null-terminated string of
+ _\bn_\bd_\bi_\bg_\bi_\bt ASCII digits and returns a pointer thereto. The
+ position of the decimal point relative to the beginning of
+ the string is stored indirectly through _\bd_\be_\bc_\bp_\bt (negative
+ means to the left of the returned digits). If the sign of
+ the result is negative, the word pointed to by _\bs_\bi_\bg_\bn is
+ non-zero, otherwise it is zero. The low-order digit is
+ rounded.
+
+ _\bF_\bc_\bv_\bt is identical to _\be_\bc_\bv_\bt, except that the correct digit
+ has been rounded for Fortran F-format output of the number
+ of digits specified by _\bn_\bd_\bi_\bg_\bi_\bt_\bs.
+
+ _\bG_\bc_\bv_\bt converts the _\bv_\ba_\bl_\bu_\be to a null-terminated ASCII string
+ in _\bb_\bu_\bf and returns a pointer to _\bb_\bu_\bf_\b. It attempts to pro-
+ duce _\bn_\bd_\bi_\bg_\bi_\bt significant digits in Fortran F format if pos-
+ sible, otherwise E format, ready for printing. Trailing
+ zeros may be suppressed.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ printf(3)
+
+B\bBU\bUG\bGS\bS
+ The return values point to static data whose content is
+ overwritten by each call.
+
+
+
+
+
+
+
+
+7th Edition May 28, 1992 1
+
+
+
+
+
--- /dev/null
+ERF(3) BSD Programmer's Manual ERF(3)
+
+N\bNA\bAM\bME\bE
+ e\ber\brf\bf, e\ber\brf\bfc\bc - error function operators
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\ber\brf\bf(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\ber\brf\bfc\bc(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions calculate the error function of _\bx.
+
+ The e\ber\brf\bf() calculates the error function of x; where
+
+ erf(x) = 2/sqrt(pi)*integral from 0 to x of exp(-t*t) dt.
+
+ The e\ber\brf\bfc\bc() function calculates the complementary error function of _\bx;
+ that is e\ber\brf\bfc\bc() subtracts the result of the error function e\ber\brf\bf(_\bx) from
+ 1.0. This is useful, since for large _\bx places disappear.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The e\ber\brf\bf() and e\ber\brf\bfc\bc() functions appeared in 4.3BSD.
+
+4.3 Berkeley Distribution June 4, 1993 1
--- /dev/null
+ERF(3) BSD Programmer's Manual ERF(3)
+
+N\bNA\bAM\bME\bE
+ e\ber\brf\bf, e\ber\brf\bfc\bc - error function operators
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\ber\brf\bf(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\ber\brf\bfc\bc(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions calculate the error function of _\bx.
+
+ The e\ber\brf\bf() calculates the error function of x; where
+
+ erf(x) = 2/sqrt(pi)*integral from 0 to x of exp(-t*t) dt.
+
+ The e\ber\brf\bfc\bc() function calculates the complementary error function of _\bx;
+ that is e\ber\brf\bfc\bc() subtracts the result of the error function e\ber\brf\bf(_\bx) from
+ 1.0. This is useful, since for large _\bx places disappear.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The e\ber\brf\bf() and e\ber\brf\bfc\bc() functions appeared in 4.3BSD.
+
+4.3 Berkeley Distribution June 4, 1993 1
--- /dev/null
+EXP(3) BSD Programmer's Manual EXP(3)
+
+N\bNA\bAM\bME\bE
+ e\bex\bxp\bp, e\bex\bxp\bpm\bm1\b1, l\blo\bog\bg, l\blo\bog\bg1\b10\b0, l\blo\bog\bg1\b1p\bp, p\bpo\bow\bw - exponential, logarithm, power func-
+ tions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bpm\bm1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b10\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b1p\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ p\bpo\bow\bw(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The e\bex\bxp\bp() function computes the exponential value of the given argument
+ _\bx.
+
+ The e\bex\bxp\bpm\bm1\b1() function computes the value exp(x)-1 accurately even for tiny
+ argument _\bx.
+
+ The l\blo\bog\bg() function computes the value for the natural logarithm of the
+ argument x.
+
+ The l\blo\bog\bg1\b10\b0() function computes the value for the logarithm of argument _\bx
+ to base 10.
+
+ The l\blo\bog\bg1\b1p\bp() function computes the value of log(1+x) accurately even for
+ tiny argument _\bx.
+
+ The p\bpo\bow\bw() computes the value of _\bx to the exponent _\by.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf e\bet\btc\bc.\b.)\b)
+ exp(x), log(x), expm1(x) and log1p(x) are accurate to within an _\bu_\bp, and
+ log10(x) to within about 2 _\bu_\bp_\bs; an _\bu_\bp is one _\bU_\bn_\bi_\bt in the _\bL_\ba_\bs_\bt _\bP_\bl_\ba_\bc_\be. The
+ error in p\bpo\bow\bw(_\bx, _\by) is below about 2 _\bu_\bp_\bs when its magnitude is moderate,
+ but increases as p\bpo\bow\bw(_\bx, _\by) approaches the over/underflow thresholds until
+ almost as many bits could be lost as are occupied by the floating-point
+ format's exponent field; that is 8 bits for VAX D and 11 bits for IEEE
+ 754 Double. No such drastic loss has been exposed by testing; the worst
+ errors observed have been below 20 _\bu_\bp_\bs for VAX D, 300 _\bu_\bp_\bs for IEEE 754
+ Double. Moderate values of p\bpo\bow\bw() are accurate enough that p\bpo\bow\bw(_\bi_\bn_\bt_\be_\bg_\be_\br,
+ _\bi_\bn_\bt_\be_\bg_\be_\br) is exact until it is bigger than 2**56 on a VAX, 2**53 for IEEE
+ 754.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ These functions will return the approprate computation unless an error
+ occurs or an argument is out of range. The functions e\bex\bxp\bp(), e\bex\bxp\bpm\bm1\b1() and
+ p\bpo\bow\bw() detect if the computed value will overflow, set the global variable
+ _\be_\br_\br_\bn_\bo _\bt_\bo RANGE and cause a reserved operand fault on a VAX or Tahoe. The
+ function p\bpo\bow\bw(_\bx, _\by) checks to see if _\bx < 0 and _\by is not an integer, in the
+ event this is true, the global variable _\be_\br_\br_\bn_\bo is set to EDOM and on the
+ VAX and Tahoe generate a reserved operand fault. On a VAX and Tahoe,
+ _\be_\br_\br_\bn_\bo is set to EDOM and the reserved operand is returned by log unless _\bx
+ > 0, by l\blo\bog\bg1\b1p\bp() unless _\bx > -1.
+
+N\bNO\bOT\bTE\bES\bS
+ The functions exp(x)-1 and log(1+x) are called expm1 and logp1 in BASIC
+ on the Hewlett-Packard HP-71B and APPLE Macintosh, EXP1 and LN1 in Pas-
+ cal, exp1 and log1 in C on APPLE Macintoshes, where they have been pro-
+ vided to make sure financial calculations of ((1+x)**n-1)/x, namely
+ expm1(n*log1p(x))/x, will be accurate when x is tiny. They also provide
+ accurate inverse hyperbolic functions.
+
+ The function p\bpo\bow\bw(_\bx, _\b0) returns x**0 = 1 for all x including x = 0, Infin-
+ ity (not found on a VAX), and _\bN_\ba_\bN (the reserved operand on a VAX).
+ Previous implementations of pow may have defined x**0 to be undefined in
+ some or all of these cases. Here are reasons for returning x**0 = 1 al-
+ ways:
+
+ 1. Any program that already tests whether x is zero (or infinite or
+ _\bN_\ba_\bN) before computing x**0 cannot care whether 0**0 = 1 or not.
+ Any program that depends upon 0**0 to be invalid is dubious any-
+ way since that expression's meaning and, if invalid, its conse-
+ quences vary from one computer system to another.
+
+ 2. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x, in-
+ cluding x = 0. This is compatible with the convention that ac-
+ cepts a[0] as the value of polynomial
+
+ p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
+
+ at x = 0 rather than reject a[0]*0**0 as invalid.
+
+ 3. Analysts will accept 0**0 = 1 despite that x**y can approach any-
+ thing or nothing as x and y approach 0 independently. The reason
+ for setting 0**0 = 1 anyway is this:
+
+ If x(z) and y(z) are _\ba_\bn_\by functions analytic (expandable in
+ power series) in z around z = 0, and if there x(0) = y(0) =
+ 0, then x(z)**y(z) -> 1 as z -> 0.
+
+ 4. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and then _\bN_\ba_\bN**0 =
+ 1 too because x**0 = 1 for all finite and infinite x, i.e., inde-
+ pendently of x.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A e\bex\bxp\bp(), l\blo\bog\bg() and p\bpo\bow\bw() function appeared in Version 6 AT&T UNIX. A
+ l\blo\bog\bg1\b10\b0() function appeared in Version 7 AT&T UNIX. The l\blo\bog\bg1\b1p\bp() and
+ e\bex\bxp\bpm\bm1\b1() functions appeared in 4.3BSD.
+
+4th Berkeley Distribution June 4, 1993 2
--- /dev/null
+EXP(3) BSD Programmer's Manual EXP(3)
+
+N\bNA\bAM\bME\bE
+ e\bex\bxp\bp, e\bex\bxp\bpm\bm1\b1, l\blo\bog\bg, l\blo\bog\bg1\b10\b0, l\blo\bog\bg1\b1p\bp, p\bpo\bow\bw - exponential, logarithm, power func-
+ tions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bpm\bm1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b10\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b1p\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ p\bpo\bow\bw(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The e\bex\bxp\bp() function computes the exponential value of the given argument
+ _\bx.
+
+ The e\bex\bxp\bpm\bm1\b1() function computes the value exp(x)-1 accurately even for tiny
+ argument _\bx.
+
+ The l\blo\bog\bg() function computes the value for the natural logarithm of the
+ argument x.
+
+ The l\blo\bog\bg1\b10\b0() function computes the value for the logarithm of argument _\bx
+ to base 10.
+
+ The l\blo\bog\bg1\b1p\bp() function computes the value of log(1+x) accurately even for
+ tiny argument _\bx.
+
+ The p\bpo\bow\bw() computes the value of _\bx to the exponent _\by.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf e\bet\btc\bc.\b.)\b)
+ exp(x), log(x), expm1(x) and log1p(x) are accurate to within an _\bu_\bp, and
+ log10(x) to within about 2 _\bu_\bp_\bs; an _\bu_\bp is one _\bU_\bn_\bi_\bt in the _\bL_\ba_\bs_\bt _\bP_\bl_\ba_\bc_\be. The
+ error in p\bpo\bow\bw(_\bx, _\by) is below about 2 _\bu_\bp_\bs when its magnitude is moderate,
+ but increases as p\bpo\bow\bw(_\bx, _\by) approaches the over/underflow thresholds until
+ almost as many bits could be lost as are occupied by the floating-point
+ format's exponent field; that is 8 bits for VAX D and 11 bits for IEEE
+ 754 Double. No such drastic loss has been exposed by testing; the worst
+ errors observed have been below 20 _\bu_\bp_\bs for VAX D, 300 _\bu_\bp_\bs for IEEE 754
+ Double. Moderate values of p\bpo\bow\bw() are accurate enough that p\bpo\bow\bw(_\bi_\bn_\bt_\be_\bg_\be_\br,
+ _\bi_\bn_\bt_\be_\bg_\be_\br) is exact until it is bigger than 2**56 on a VAX, 2**53 for IEEE
+ 754.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ These functions will return the approprate computation unless an error
+ occurs or an argument is out of range. The functions e\bex\bxp\bp(), e\bex\bxp\bpm\bm1\b1() and
+ p\bpo\bow\bw() detect if the computed value will overflow, set the global variable
+ _\be_\br_\br_\bn_\bo _\bt_\bo RANGE and cause a reserved operand fault on a VAX or Tahoe. The
+ function p\bpo\bow\bw(_\bx, _\by) checks to see if _\bx < 0 and _\by is not an integer, in the
+ event this is true, the global variable _\be_\br_\br_\bn_\bo is set to EDOM and on the
+ VAX and Tahoe generate a reserved operand fault. On a VAX and Tahoe,
+ _\be_\br_\br_\bn_\bo is set to EDOM and the reserved operand is returned by log unless _\bx
+ > 0, by l\blo\bog\bg1\b1p\bp() unless _\bx > -1.
+
+N\bNO\bOT\bTE\bES\bS
+ The functions exp(x)-1 and log(1+x) are called expm1 and logp1 in BASIC
+ on the Hewlett-Packard HP-71B and APPLE Macintosh, EXP1 and LN1 in Pas-
+ cal, exp1 and log1 in C on APPLE Macintoshes, where they have been pro-
+ vided to make sure financial calculations of ((1+x)**n-1)/x, namely
+ expm1(n*log1p(x))/x, will be accurate when x is tiny. They also provide
+ accurate inverse hyperbolic functions.
+
+ The function p\bpo\bow\bw(_\bx, _\b0) returns x**0 = 1 for all x including x = 0, Infin-
+ ity (not found on a VAX), and _\bN_\ba_\bN (the reserved operand on a VAX).
+ Previous implementations of pow may have defined x**0 to be undefined in
+ some or all of these cases. Here are reasons for returning x**0 = 1 al-
+ ways:
+
+ 1. Any program that already tests whether x is zero (or infinite or
+ _\bN_\ba_\bN) before computing x**0 cannot care whether 0**0 = 1 or not.
+ Any program that depends upon 0**0 to be invalid is dubious any-
+ way since that expression's meaning and, if invalid, its conse-
+ quences vary from one computer system to another.
+
+ 2. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x, in-
+ cluding x = 0. This is compatible with the convention that ac-
+ cepts a[0] as the value of polynomial
+
+ p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
+
+ at x = 0 rather than reject a[0]*0**0 as invalid.
+
+ 3. Analysts will accept 0**0 = 1 despite that x**y can approach any-
+ thing or nothing as x and y approach 0 independently. The reason
+ for setting 0**0 = 1 anyway is this:
+
+ If x(z) and y(z) are _\ba_\bn_\by functions analytic (expandable in
+ power series) in z around z = 0, and if there x(0) = y(0) =
+ 0, then x(z)**y(z) -> 1 as z -> 0.
+
+ 4. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and then _\bN_\ba_\bN**0 =
+ 1 too because x**0 = 1 for all finite and infinite x, i.e., inde-
+ pendently of x.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A e\bex\bxp\bp(), l\blo\bog\bg() and p\bpo\bow\bw() function appeared in Version 6 AT&T UNIX. A
+ l\blo\bog\bg1\b10\b0() function appeared in Version 7 AT&T UNIX. The l\blo\bog\bg1\b1p\bp() and
+ e\bex\bxp\bpm\bm1\b1() functions appeared in 4.3BSD.
+
+4th Berkeley Distribution June 4, 1993 2
--- /dev/null
+FABS(3) BSD Programmer's Manual FABS(3)
+
+N\bNA\bAM\bME\bE
+ f\bfa\bab\bbs\bs - floating-point absolute value function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ f\bfa\bab\bbs\bs(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The f\bfa\bab\bbs\bs() function computes the absolute value of a floating-point num-
+ ber _\bx.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The f\bfa\bab\bbs\bs() function returns the absolute value of _\bx.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ abs(3), ceil(3), floor(3), rint(3), ieee(3), math.3
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The f\bfa\bab\bbs\bs() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+
+
+
+ECVT(3) BSD Programmer's Manual ECVT(3)
+
+
+N\bNA\bAM\bME\bE
+ ecvt, fcvt, gcvt - output conversion
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ c\bch\bha\bar\br *\b*e\bec\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, d\bde\bec\bcp\bpt\bt,\b, s\bsi\big\bgn\bn)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ i\bin\bnt\bt n\bnd\bdi\big\bgi\bit\bt,\b, *\b*d\bde\bec\bcp\bpt\bt,\b, *\b*s\bsi\big\bgn\bn;\b;
+
+ c\bch\bha\bar\br *\b*f\bfc\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, d\bde\bec\bcp\bpt\bt,\b, s\bsi\big\bgn\bn)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ i\bin\bnt\bt n\bnd\bdi\big\bgi\bit\bt,\b, *\b*d\bde\bec\bcp\bpt\bt,\b, *\b*s\bsi\big\bgn\bn;\b;
+
+ c\bch\bha\bar\br *\b*g\bgc\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, b\bbu\buf\bf)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ c\bch\bha\bar\br *\b*b\bbu\buf\bf;\b;
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhe\bes\bse\be i\bin\bnt\bte\ber\brf\bfa\bac\bce\bes\bs a\bar\bre\be o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by p\bpr\bri\bin\bnt\btf\bf(\b(3\b3)\b).\b.
+ T\bTh\bhe\bey\by a\bar\bre\be a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bm-\b-
+ p\bpa\bat\bt.\b.
+
+ _\bE_\bc_\bv_\bt converts the _\bv_\ba_\bl_\bu_\be to a null-terminated string of
+ _\bn_\bd_\bi_\bg_\bi_\bt ASCII digits and returns a pointer thereto. The
+ position of the decimal point relative to the beginning of
+ the string is stored indirectly through _\bd_\be_\bc_\bp_\bt (negative
+ means to the left of the returned digits). If the sign of
+ the result is negative, the word pointed to by _\bs_\bi_\bg_\bn is
+ non-zero, otherwise it is zero. The low-order digit is
+ rounded.
+
+ _\bF_\bc_\bv_\bt is identical to _\be_\bc_\bv_\bt, except that the correct digit
+ has been rounded for Fortran F-format output of the number
+ of digits specified by _\bn_\bd_\bi_\bg_\bi_\bt_\bs.
+
+ _\bG_\bc_\bv_\bt converts the _\bv_\ba_\bl_\bu_\be to a null-terminated ASCII string
+ in _\bb_\bu_\bf and returns a pointer to _\bb_\bu_\bf_\b. It attempts to pro-
+ duce _\bn_\bd_\bi_\bg_\bi_\bt significant digits in Fortran F format if pos-
+ sible, otherwise E format, ready for printing. Trailing
+ zeros may be suppressed.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ printf(3)
+
+B\bBU\bUG\bGS\bS
+ The return values point to static data whose content is
+ overwritten by each call.
+
+
+
+
+
+
+
+
+7th Edition May 28, 1992 1
+
+
+
+
+
--- /dev/null
+IEEE(3) BSD Programmer's Manual IEEE(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn, d\bdr\bre\bem\bm, f\bfi\bin\bni\bit\bte\be, l\blo\bog\bgb\bb, s\bsc\bca\bal\blb\bb - IEEE 754 floating point support
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ d\bdr\bre\bem\bm(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bi_\bn_\bt
+ f\bfi\bin\bni\bit\bte\be(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bgb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsc\bca\bal\blb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bi_\bn_\bt _\bn);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions are required for, or recommended by the IEEE standard 754
+ for floating-point arithmetic.
+
+ The c\bco\bop\bpy\bys\bsi\big\bgn\bn() function returns _\bx with its sign changed to _\by's.
+
+ The d\bdr\bre\bem\bm() function returns the remainder _\br := _\bx - _\bn_\b*_\by where _\bn is the in-
+ teger nearest the exact value of _\bx/_\by; moreover if |_\bn - _\bx/_\by| = 1/2 then _\bn
+ is even. Consequently the remainder is computed exactly and |_\br| <=
+ |_\by|/2. But d\bdr\bre\bem\bm(_\bx, _\b0) is exceptional. (See below under _\bD_\bI_\bA_\bG_\bN_\bO_\bS_\bT_\bI_\bC_\bS.)
+
+ The f\bfi\bin\bni\bit\bte\be() function returns the value 1 just when -infinity < _\bx < +in-
+ finity; otherwise a zero is returned (when |_\bx| = infinity or _\bx is _\bN_\ba_\bN or
+ is the VAX's reserved operand).
+
+ The l\blo\bog\bgb\bb() function returns _\bx's exponent _\bn, a signed integer converted to
+ double-precision floating-point and so chosen that 1 (<= |_\bx|2**_\bn < 2 un-
+ less _\bx = 0 or (only on machines that conform to IEEE 754) |_\bx| = infinity
+ or _\bx lies between 0 and the Underflow Threshold. (See below under _\bB_\bU_\bG_\bS.)
+
+ The s\bsc\bca\bal\blb\bb() function returns _\bx*(2**_\bn) computed, for integer n, without
+ first computing 2*_\bn.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The IEEE standard 754 defines d\bdr\bre\bem\bm(_\bx, _\b0) and d\bdr\bre\bem\bm(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\by) to be in-
+ valid operations that produce a _\bN_\ba_\bN. On the VAX, d\bdr\bre\bem\bm(_\bx, _\b0) generates a
+ reserved operand fault. No infinity exists on a VAX.
+
+ IEEE 754 defines l\blo\bog\bgb\bb(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = infinity and l\blo\bog\bgb\bb(_\b0) = -infinity, and
+ requires the latter to signal Division-by-Zero. But on a VAX, l\blo\bog\bgb\bb(_\b0) =
+ 1.0 - 2.0**31 = -2,147,483,647.0. And if the correct value of s\bsc\bca\bal\blb\bb()
+ would overflow on a VAX, it generates a reserved operand fault and sets
+ the global variable _\be_\br_\br_\bn_\bo to ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ floor(3), math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bie\bee\bee\be functions appeared in 4.3BSD.
+
+B\bBU\bUG\bGS\bS
+ Should d\bdr\bre\bem\bm(_\bx, _\b0) and l\blo\bog\bgb\bb(_\b0) on a VAX signal invalidity by setting _\be_\br_\br_\bn_\bo
+ = EDOM ? Should l\blo\bog\bgb\bb(_\b0) return -1.7e38?
+
+ IEEE 754 currently specifies that l\blo\bog\bgb\bb(_\bd_\be_\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b.) = l\blo\bog\bgb\bb(_\bt_\bi_\bn_\bi_\be_\bs_\bt
+ _\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b. _\b> _\b0) but the consensus has changed to the specification in
+ the new proposed IEEE standard p854, namely that l\blo\bog\bgb\bb(_\bx) satisfy
+
+ 1 <= s\bsc\bca\bal\blb\bb(|_\bx|, _\b-_\bl_\bo_\bg_\bb_\b(_\bx_\b)) < Radix ... = 2 for IEEE 754
+
+ for every x except 0, infinity and _\bN_\ba_\bN. Almost every program that as-
+ sumes 754's specification will work correctly if l\blo\bog\bgb\bb() follows 854's
+ specification instead.
+
+ IEEE 754 requires c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\bN_\ba_\bN_\b)) = +-_\bx but says nothing else about the
+ sign of a _\bN_\ba_\bN. A _\bN_\ba_\bN _\b(_\bNot _\ba _\bNumber) is similar in spirit to the VAX's
+ reserved operand, but very different in important details. Since the
+ sign bit of a reserved operand makes it look negative,
+
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\br_\be_\bs_\be_\br_\bv_\be_\bd _\bo_\bp_\be_\br_\ba_\bn_\bd) = -_\bx;
+
+ should this return the reserved operand instead?
+
+4.3 Berkeley Distribution June 4, 1993 2
--- /dev/null
+FLOOR(3) BSD Programmer's Manual FLOOR(3)
+
+N\bNA\bAM\bME\bE
+ f\bfl\blo\boo\bor\br - largest integral value not greater than x
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ f\bfl\blo\boo\bor\br(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The f\bfl\blo\boo\bor\br() function computes the largest integral value not greater than
+ _\bx.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The f\bfl\blo\boo\bor\br() function returns the largest integral value expressed as a
+ double.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ abs(3), ieee(3), fabs(3), floor(3), rint(3), math(3)
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The f\bfl\blo\boo\bor\br() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+FMOD(3) BSD Programmer's Manual FMOD(3)
+
+N\bNA\bAM\bME\bE
+ f\bfm\bmo\bod\bd - floating-point remainder function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ f\bfm\bmo\bod\bd(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The f\bfm\bmo\bod\bd() function computes the floating-point remainder of _\bx/ _\by.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The f\bfm\bmo\bod\bd() function returns the value _\bx_\b-_\bi_\b*_\by, for some integer _\bi such
+ that, if _\by is non-zero, the result has the same sign as _\bx and magnitude
+ less than the magnitude of _\by. If _\by is zero, whether a domain error occurs
+ or the f\bfm\bmo\bod\bd() function returns zero is implementation-defined.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3)
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The f\bfm\bmo\bod\bd() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+FTIME(3) BSD Programmer's Manual FTIME(3)
+
+N\bNA\bAM\bME\bE
+ f\bft\bti\bim\bme\be - get date and time
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/t\bty\byp\bpe\bes\bs.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/t\bti\bim\bme\beb\bb.\b.h\bh>\b>
+
+ _\bs_\bt_\br_\bu_\bc_\bt _\bt_\bi_\bm_\be_\bb _\b*
+ f\bft\bti\bim\bme\be(_\bs_\bt_\br_\bu_\bc_\bt _\bt_\bi_\bm_\be_\bb _\b*_\bt_\bp);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhi\bis\bs i\bin\bnt\bte\ber\brf\bfa\bac\bce\be i\bis\bs o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by g\bge\bet\btt\bti\bim\bme\beo\bof\bfd\bda\bay\by(\b(2\b2)\b).\b.
+
+ I\bIt\bt i\bis\bs a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ The f\bft\bti\bim\bme\be() routine fills in a structure pointed to by its argument, as
+ defined by <_\bs_\by_\bs_\b/_\bt_\bi_\bm_\be_\bb_\b._\bh>:
+
+ /*
+ * Structure returned by ftime system call
+ */
+ struct timeb
+ {
+ time_t time;
+ unsigned short millitm;
+ short timezone;
+ short dstflag;
+ };
+
+ The structure contains the time since the epoch in seconds, up to 1000
+ milliseconds of more-precise interval, the local time zone (measured in
+ minutes of time westward from Greenwich), and a flag that, if nonzero,
+ indicates that Daylight Saving time applies locally during the appropri-
+ ate part of the year.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ gettimeofday(2), settimeofday(2), time(2), ctime(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The f\bft\bti\bim\bme\be function appeared in 4.2BSD.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+LGAMMA(3) BSD Programmer's Manual LGAMMA(3)
+
+N\bNA\bAM\bME\bE
+ l\blg\bga\bam\bmm\bma\ba g\bga\bam\bmm\bma\ba - log gamma function, gamma function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\be_\bx_\bt_\be_\br_\bn _\bi_\bn_\bt _\bs_\bi_\bg_\bn_\bg_\ba_\bm;
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blg\bga\bam\bmm\bma\ba(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ g\bga\bam\bmm\bma\ba(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN _
+ L\bLg\bga\bam\bmm\bma\ba(_\bx) returns ln|| (x)|.
+ _
+ The external integer _\bs_\bi_\bg_\bn_\bg_\ba_\bm returns the sign of | (x).
+ _
+ G\bGa\bam\bmm\bma\ba(_\bx) returns | (x), with no effect on _\bs_\bi_\bg_\bn_\bg_\ba_\bm.
+
+I\bID\bDI\bIO\bOS\bSY\bYN\bNC\bCR\bRA\bAS\bSI\bIE\bES\bS
+ Do\b_ not use the expression ``signgam*exp(lgamma(x))'' to compute g :=
+ | (x). Instead use a program like this (in C):
+
+ lg = lgamma(x); g = signgam*exp(lg);
+
+ Only after l\blg\bga\bam\bmm\bma\ba() has returned can signgam be correct.
+
+ For arguments in its range, g\bga\bam\bmm\bma\ba() is preferred, as for positive argu-
+ ments it is accurate to within one unit in the last place. Exponentia-
+ tion of l\blg\bga\bam\bmm\bma\ba() will lose up to 10 significant bits.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ G\bGa\bam\bmm\bma\ba() and l\blg\bga\bam\bmm\bma\ba() return appropriate values unless an arguent is out
+ of range. Overflow will occur for sufficiently large positive values,
+ and non-positive integers. On the VAX, the reserved operator is re-
+ turned, and _\be_\br_\br_\bn_\bo is set to ERANGE For large non-integer negative values,
+ g\bga\bam\bmm\bma\ba() will underflow.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The l\blg\bga\bam\bmm\bma\ba function appeared in 4.3BSD. The g\bga\bam\bmm\bma\ba function appeared in
+ 4.4BSD. The name g\bga\bam\bmm\bma\ba() was originally dedicated to the l\blg\bga\bam\bmm\bma\ba() func-
+ tion, so some old code may no longer be compatible.
+
+4.3 Berkeley Distribution June 4, 1993 1
--- /dev/null
+
+
+
+ECVT(3) BSD Programmer's Manual ECVT(3)
+
+
+N\bNA\bAM\bME\bE
+ ecvt, fcvt, gcvt - output conversion
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ c\bch\bha\bar\br *\b*e\bec\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, d\bde\bec\bcp\bpt\bt,\b, s\bsi\big\bgn\bn)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ i\bin\bnt\bt n\bnd\bdi\big\bgi\bit\bt,\b, *\b*d\bde\bec\bcp\bpt\bt,\b, *\b*s\bsi\big\bgn\bn;\b;
+
+ c\bch\bha\bar\br *\b*f\bfc\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, d\bde\bec\bcp\bpt\bt,\b, s\bsi\big\bgn\bn)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ i\bin\bnt\bt n\bnd\bdi\big\bgi\bit\bt,\b, *\b*d\bde\bec\bcp\bpt\bt,\b, *\b*s\bsi\big\bgn\bn;\b;
+
+ c\bch\bha\bar\br *\b*g\bgc\bcv\bvt\bt(\b(v\bva\bal\blu\bue\be,\b, n\bnd\bdi\big\bgi\bit\bt,\b, b\bbu\buf\bf)\b)
+ d\bdo\bou\bub\bbl\ble\be v\bva\bal\blu\bue\be;\b;
+ c\bch\bha\bar\br *\b*b\bbu\buf\bf;\b;
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhe\bes\bse\be i\bin\bnt\bte\ber\brf\bfa\bac\bce\bes\bs a\bar\bre\be o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by p\bpr\bri\bin\bnt\btf\bf(\b(3\b3)\b).\b.
+ T\bTh\bhe\bey\by a\bar\bre\be a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bm-\b-
+ p\bpa\bat\bt.\b.
+
+ _\bE_\bc_\bv_\bt converts the _\bv_\ba_\bl_\bu_\be to a null-terminated string of
+ _\bn_\bd_\bi_\bg_\bi_\bt ASCII digits and returns a pointer thereto. The
+ position of the decimal point relative to the beginning of
+ the string is stored indirectly through _\bd_\be_\bc_\bp_\bt (negative
+ means to the left of the returned digits). If the sign of
+ the result is negative, the word pointed to by _\bs_\bi_\bg_\bn is
+ non-zero, otherwise it is zero. The low-order digit is
+ rounded.
+
+ _\bF_\bc_\bv_\bt is identical to _\be_\bc_\bv_\bt, except that the correct digit
+ has been rounded for Fortran F-format output of the number
+ of digits specified by _\bn_\bd_\bi_\bg_\bi_\bt_\bs.
+
+ _\bG_\bc_\bv_\bt converts the _\bv_\ba_\bl_\bu_\be to a null-terminated ASCII string
+ in _\bb_\bu_\bf and returns a pointer to _\bb_\bu_\bf_\b. It attempts to pro-
+ duce _\bn_\bd_\bi_\bg_\bi_\bt significant digits in Fortran F format if pos-
+ sible, otherwise E format, ready for printing. Trailing
+ zeros may be suppressed.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ printf(3)
+
+B\bBU\bUG\bGS\bS
+ The return values point to static data whose content is
+ overwritten by each call.
+
+
+
+
+
+
+
+
+7th Edition May 28, 1992 1
+
+
+
+
+
--- /dev/null
+GETPW(3) BSD Programmer's Manual GETPW(3)
+
+N\bNA\bAM\bME\bE
+ g\bge\bet\btp\bpw\bw - get name from uid
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ g\bge\bet\btp\bpw\bw(_\bu_\bi_\bd, _\bc_\bh_\ba_\br _\b*_\bb_\bu_\bf);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhe\be g\bge\bet\btp\bpw\bw f\bfu\bun\bnc\bct\bti\bio\bon\bn i\bis\bs m\bma\bad\bde\be o\bob\bbs\bso\bol\ble\bet\bte\be b\bby\by g\bge\bet\btp\bpw\bwu\bui\bid\bd(\b(3\b3)\b).\b.
+ I\bIt\bt i\bis\bs a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ The g\bge\bet\btp\bpw\bw() function reads the file _\b/_\be_\bt_\bc_\b/_\bp_\ba_\bs_\bs_\bw_\bd, and if it finds the
+ specified _\bu_\bi_\bd, copies the password entry line into the string pointed to
+ by _\bb_\bu_\bf. the null terminated entry line from the password database, and
+ appends the NUL character.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The g\bge\bet\btp\bpw\bw() function returns the zero if successful, otherwise a non-zero
+ if the entry does not exist.
+
+F\bFI\bIL\bLE\bES\bS
+ /etc/passwd
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ getpwent(3), passwd(5)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A g\bge\bet\btp\bpw\bw() function appeared in Version 6 AT&T UNIX.
+
+4.4BSD June 4, 1993 1
--- /dev/null
+STTY(3) BSD Programmer's Manual STTY(3)
+
+N\bNA\bAM\bME\bE
+ s\bst\btt\bty\by, g\bgt\btt\bty\by - set and get terminal state (defunct)
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsg\bgt\btt\bty\by.\b.h\bh>\b>
+
+ s\bst\btt\bty\by(_\bi_\bn_\bt _\bf_\bd, _\bs_\bt_\br_\bu_\bc_\bt _\bs_\bg_\bt_\bt_\by_\bb _\b*_\bb_\bu_\bf);
+
+ g\bgt\btt\bty\by(_\bi_\bn_\bt _\bf_\bd, _\bs_\bt_\br_\bu_\bc_\bt _\bs_\bg_\bt_\bt_\by_\bb _\b*_\bb_\bu_\bf);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhe\bes\bse\be i\bin\bnt\bte\ber\brf\bfa\bac\bce\bes\bs a\bar\bre\be o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by i\bio\boc\bct\btl\bl(\b(2\b2)\b).\b. T\bTh\bhe\bey\by a\bar\bre\be a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be
+ c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ The s\bst\btt\bty\by() function sets the state of the terminal associated with _\bf_\bd.
+ The g\bgt\btt\bty\by() function retrieves the state of the terminal associated with
+ _\bf_\bd. To set the state of a terminal the call must have write permission.
+
+ The s\bst\btt\bty\by() call is actually `ioctl(fd, TIOCSETP, buf)', while the g\bgt\btt\bty\by()
+ call is `ioctl(fd, TIOCGETP, buf)'. See ioctl(2) and tty(4) for an expla-
+ nation.
+
+D\bDI\bIA\bAG\bGN\bNO\bOS\bST\bTI\bIC\bCS\bS
+ If the call is successful 0 is returned, otherwise -1 is returned and the
+ global variable _\be_\br_\br_\bn_\bo contains the reason for the failure.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ioctl(2), tty(4)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The s\bst\btt\bty\by() and g\bgt\btt\bty\by() functions appeared in 4.2BSD.
+
+4.2 Berkeley Distribution June 4, 1993 1
--- /dev/null
+HYPOT(3) BSD Programmer's Manual HYPOT(3)
+
+N\bNA\bAM\bME\bE
+ h\bhy\byp\bpo\bot\bt, c\bca\bab\bbs\bs - euclidean distance and complex absolute value functions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ h\bhy\byp\bpo\bot\bt(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ s\bst\btr\bru\buc\bct\bt {\b{d\bdo\bou\bub\bbl\ble\be x\bx,\b, y\by;\b;}\b} z\bz;\b;
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bca\bab\bbs\bs(_\bz);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The h\bhy\byp\bpo\bot\bt() and c\bca\bab\bbs\bs() functions computes the sqrt(x*x+y*y) in such a way
+ that underflow will not happen, and overflow occurs only if the final re-
+ sult deserves it.
+
+ h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bv) = h\bhy\byp\bpo\bot\bt(_\bv, _\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = +infinity for all _\bv, including
+ _\bN_\ba_\bN.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf,\b, e\bet\btc\bc.\b.)\b)
+ Below 0.97 _\bu_\bl_\bp_\bs. Consequently h\bhy\byp\bpo\bot\bt(_\b5_\b._\b0, _\b1_\b2_\b._\b0) = 13.0 exactly; in gener-
+ al, hypot and cabs return an integer whenever an integer might be expect-
+ ed.
+
+ The same cannot be said for the shorter and faster version of hypot and
+ cabs that is provided in the comments in cabs.c; its error can exceed 1.2
+ _\bu_\bl_\bp_\bs.
+
+N\bNO\bOT\bTE\bES\bS
+ As might be expected, h\bhy\byp\bpo\bot\bt(_\bv, _\bN_\ba_\bN) and h\bhy\byp\bpo\bot\bt(_\bN_\ba_\bN, _\bv) are _\bN_\ba_\bN for all
+ _\bf_\bi_\bn_\bi_\bt_\be _\bv; with "reserved operand" in place of "_\bN_\ba_\bN", the same is true on
+ a VAX. But programmers on machines other than a VAX (if has no infinity)
+ might be surprised at first to discover that h\bhy\byp\bpo\bot\bt(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bN_\ba_\bN) =
+ +infinity. This is intentional; it happens because h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bv) =
+ +infinity for _\ba_\bl_\bl _\bv, finite or infinite. Hence h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bv) is in-
+ dependent of _\bv. Unlike the reserved operand fault on a VAX, the IEEE _\bN_\ba_\bN
+ is designed to disappear when it turns out to be irrelevant, as it does
+ in h\bhy\byp\bpo\bot\bt(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\bN_\ba_\bN).
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), sqrt(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ Both a h\bhy\byp\bpo\bot\bt() function and a c\bca\bab\bbs\bs() function appeared in Version 7 AT&T
+ UNIX.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+IEEE(3) BSD Programmer's Manual IEEE(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn, d\bdr\bre\bem\bm, f\bfi\bin\bni\bit\bte\be, l\blo\bog\bgb\bb, s\bsc\bca\bal\blb\bb - IEEE 754 floating point support
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ d\bdr\bre\bem\bm(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bi_\bn_\bt
+ f\bfi\bin\bni\bit\bte\be(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bgb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsc\bca\bal\blb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bi_\bn_\bt _\bn);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions are required for, or recommended by the IEEE standard 754
+ for floating-point arithmetic.
+
+ The c\bco\bop\bpy\bys\bsi\big\bgn\bn() function returns _\bx with its sign changed to _\by's.
+
+ The d\bdr\bre\bem\bm() function returns the remainder _\br := _\bx - _\bn_\b*_\by where _\bn is the in-
+ teger nearest the exact value of _\bx/_\by; moreover if |_\bn - _\bx/_\by| = 1/2 then _\bn
+ is even. Consequently the remainder is computed exactly and |_\br| <=
+ |_\by|/2. But d\bdr\bre\bem\bm(_\bx, _\b0) is exceptional. (See below under _\bD_\bI_\bA_\bG_\bN_\bO_\bS_\bT_\bI_\bC_\bS.)
+
+ The f\bfi\bin\bni\bit\bte\be() function returns the value 1 just when -infinity < _\bx < +in-
+ finity; otherwise a zero is returned (when |_\bx| = infinity or _\bx is _\bN_\ba_\bN or
+ is the VAX's reserved operand).
+
+ The l\blo\bog\bgb\bb() function returns _\bx's exponent _\bn, a signed integer converted to
+ double-precision floating-point and so chosen that 1 (<= |_\bx|2**_\bn < 2 un-
+ less _\bx = 0 or (only on machines that conform to IEEE 754) |_\bx| = infinity
+ or _\bx lies between 0 and the Underflow Threshold. (See below under _\bB_\bU_\bG_\bS.)
+
+ The s\bsc\bca\bal\blb\bb() function returns _\bx*(2**_\bn) computed, for integer n, without
+ first computing 2*_\bn.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The IEEE standard 754 defines d\bdr\bre\bem\bm(_\bx, _\b0) and d\bdr\bre\bem\bm(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\by) to be in-
+ valid operations that produce a _\bN_\ba_\bN. On the VAX, d\bdr\bre\bem\bm(_\bx, _\b0) generates a
+ reserved operand fault. No infinity exists on a VAX.
+
+ IEEE 754 defines l\blo\bog\bgb\bb(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = infinity and l\blo\bog\bgb\bb(_\b0) = -infinity, and
+ requires the latter to signal Division-by-Zero. But on a VAX, l\blo\bog\bgb\bb(_\b0) =
+ 1.0 - 2.0**31 = -2,147,483,647.0. And if the correct value of s\bsc\bca\bal\blb\bb()
+ would overflow on a VAX, it generates a reserved operand fault and sets
+ the global variable _\be_\br_\br_\bn_\bo to ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ floor(3), math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bie\bee\bee\be functions appeared in 4.3BSD.
+
+B\bBU\bUG\bGS\bS
+ Should d\bdr\bre\bem\bm(_\bx, _\b0) and l\blo\bog\bgb\bb(_\b0) on a VAX signal invalidity by setting _\be_\br_\br_\bn_\bo
+ = EDOM ? Should l\blo\bog\bgb\bb(_\b0) return -1.7e38?
+
+ IEEE 754 currently specifies that l\blo\bog\bgb\bb(_\bd_\be_\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b.) = l\blo\bog\bgb\bb(_\bt_\bi_\bn_\bi_\be_\bs_\bt
+ _\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b. _\b> _\b0) but the consensus has changed to the specification in
+ the new proposed IEEE standard p854, namely that l\blo\bog\bgb\bb(_\bx) satisfy
+
+ 1 <= s\bsc\bca\bal\blb\bb(|_\bx|, _\b-_\bl_\bo_\bg_\bb_\b(_\bx_\b)) < Radix ... = 2 for IEEE 754
+
+ for every x except 0, infinity and _\bN_\ba_\bN. Almost every program that as-
+ sumes 754's specification will work correctly if l\blo\bog\bgb\bb() follows 854's
+ specification instead.
+
+ IEEE 754 requires c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\bN_\ba_\bN_\b)) = +-_\bx but says nothing else about the
+ sign of a _\bN_\ba_\bN. A _\bN_\ba_\bN _\b(_\bNot _\ba _\bNumber) is similar in spirit to the VAX's
+ reserved operand, but very different in important details. Since the
+ sign bit of a reserved operand makes it look negative,
+
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\br_\be_\bs_\be_\br_\bv_\be_\bd _\bo_\bp_\be_\br_\ba_\bn_\bd) = -_\bx;
+
+ should this return the reserved operand instead?
+
+4.3 Berkeley Distribution June 4, 1993 2
--- /dev/null
+INFNAN(3) BSD Programmer's Manual INFNAN(3)
+
+N\bNA\bAM\bME\bE
+ i\bin\bnf\bfn\bna\ban\bn - signals invalid floating-point operations on a VAX (temporary)
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ i\bin\bnf\bfn\bna\ban\bn(_\bi_\bn_\bt _\bi_\ba_\br_\bg);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ At some time in the future, some of the useful properties of the Infini-
+ ties and _\bN_\ba_\bNs in the IEEE standard 754 for Binary Floating-Point Arith-
+ metic will be simulated in UNIX on the DEC VAX by using its Reserved
+ Operands. Meanwhile, the Invalid, Overflow and Divide-by-Zero exceptions
+ of the IEEE standard are being approximated on a VAX by calls to a proce-
+ dure i\bin\bnf\bfn\bna\ban\bn() in appropriate places in libm(3). When better excep-
+ tion-handling is implemented in UNIX, only i\bin\bnf\bfn\bna\ban\bn() among the codes in
+ libm will have to be changed. And users of libm can design their own
+ i\bin\bnf\bfn\bna\ban\bn() now to insulate themselves from future changes.
+
+ Whenever an elementary function code in libm has to simulate one of the
+ aforementioned IEEE exceptions, it calls i\bin\bnf\bfn\bna\ban\bn(_\bi_\ba_\br_\bg) with an appropriate
+ value of _\bi_\ba_\br_\bg. Then a reserved operand fault stops computation. But
+ i\bin\bnf\bfn\bna\ban\bn() could be replaced by a function with the same name that returns
+ some plausible value, assigns an apt value to the global variable _\be_\br_\br_\bn_\bo,
+ and allows computation to resume. Alternatively, the Reserved Operand
+ Fault Handler could be changed to respond by returning that plausible
+ value, etc. instead of aborting.
+
+ In the table below, the first two columns show various exceptions sig-
+ naled by the IEEE standard, and the default result it prescribes. The
+ third column shows what value is given to _\bi_\ba_\br_\bg by functions in libm when
+ they invoke i\bin\bnf\bfn\bna\ban\bn(_\bi_\ba_\br_\bg) under analogous circumstances on a VAX. Current-
+ ly i\bin\bnf\bfn\bna\ban\bn() stops computation under all those circumstances. The last
+ two columns offer an alternative; they suggest a setting for _\be_\br_\br_\bn_\bo and a
+ value for a revised i\bin\bnf\bfn\bna\ban\bn() to return. And a C program to implement
+ that suggestion follows.
+
+
+ IEEE Signal IEEE Default _\bi_\ba_\br_\bg _\be_\br_\br_\bn_\bo
+ i\bin\bnf\bfn\bna\ban\bn()
+ Invalid _\bN_\ba_\bN EDOM EDOM 0
+ Overflow +-infinity ERANGE ERANGE HUGE
+ Div-by-0 +-Infinity +-ERANGE ERANGE or
+ EDOM +-HUGE
+ (HUGE = 1.7e38 ... nearly 2.0**127)
+
+ ALTERNATIVE i\bin\bnf\bfn\bna\ban\bn():
+
+ #include <math.h>
+ #include <errno.h>
+ extern int errno ;
+ double infnan(iarg)
+ int iarg ;
+ {
+ switch(iarg) {
+ case ERANGE: errno = ERANGE; return(HUGE);
+ case -ERANGE: errno = EDOM; return(-HUGE);
+ default: errno = EDOM; return(0);
+ }
+ }
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), intro(2), signal(3).
+
+ ERANGE and EDOM are defined in <_\be_\br_\br_\bn_\bo_\b._\bh>. (See intro(2) for explanation
+ of EDOM and ERANGE.)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bin\bnf\bfn\bna\ban\bn() function appeared in 4.3BSD.
+
+4.3 Berkeley Distribution June 4, 1993 2
--- /dev/null
+INSQUE(3) BSD Programmer's Manual INSQUE(3)
+
+N\bNA\bAM\bME\bE
+ i\bin\bns\bsq\bqu\bue\be, r\bre\bem\bmq\bqu\bue\be - insert/remove element from a queue
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ struct qelem {
+ struct qelem *q_forw;
+ struct qelem *q_back;
+ char q_data[];
+ };
+
+ i\bin\bns\bsq\bqu\bue\be(_\b(_\bc_\ba_\bd_\bd_\br_\b__\bt_\b) _\bs_\bt_\br_\bu_\bc_\bt _\bq_\be_\bl_\be_\bm _\b*_\be_\bl_\be_\bm, _\b(_\bc_\ba_\bd_\bd_\br_\b__\bt_\b) _\bs_\bt_\br_\bu_\bc_\bt _\bq_\be_\bl_\be_\bm _\b*_\bp_\br_\be_\bd);
+
+ r\bre\bem\bmq\bqu\bue\be(_\b(_\bc_\ba_\bd_\bd_\br_\b__\bt_\b) _\bs_\bt_\br_\bu_\bc_\bt _\bq_\be_\bl_\be_\bm _\b*_\be_\bl_\be_\bm);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The i\bin\bns\bsq\bqu\bue\be() and r\bre\bem\bmq\bqu\bue\be() functions manipulate queues built from doubly
+ linked lists. Each element in the queue must in the form of ``struct
+ qelem''. The function i\bin\bns\bsq\bqu\bue\be() inserts _\be_\bl_\be_\bm in a queue immediately after
+ _\bp_\br_\be_\bd; r\bre\bem\bmq\bqu\bue\be() removes an entry _\be_\bl_\be_\bm from a queue.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ _\bV_\bA_\bX _\bA_\br_\bc_\bh_\bi_\bt_\be_\bc_\bt_\bu_\br_\be _\bH_\ba_\bn_\bd_\bb_\bo_\bo_\bk, pp. 228-235.
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bin\bns\bsq\bqu\bue\be() and r\bre\bem\bmq\bqu\bue\be() functions appeared in 4.2BSD.
+
+4.2 Berkeley Distribution June 4, 1993 1
--- /dev/null
+J0(3) BSD Programmer's Manual J0(3)
+
+N\bNA\bAM\bME\bE
+ j\bj0\b0, j\bj1\b1, j\bjn\bn, y\by0\b0, y\by1\b1, y\byn\bn - bessel functions of first and second kind
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bjn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\byn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions j\bj0\b0() and j\bj1\b1() compute the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd
+ _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively, for the real value _\bx; the
+ function j\bjn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be
+ _\bi_\bn_\bt_\be_\bg_\be_\br Bessel0 _\bn for the real value _\bx.
+
+ The functions y\by0\b0() and y\by1\b1() compute the linearly independent _\bB_\be_\bs_\bs_\be_\bl
+ _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively,
+ for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double); the function
+ y\byn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bf_\bo_\br _\bt_\bh_\be _\bi_\bn_\bt_\be_\bg_\be_\br
+ Bessel0 _\bn for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ If these functions are successful, the computed value is returned. On the
+ VAX and Tahoe architectures, a negative _\bx value results in an error; the
+ global variable _\be_\br_\br_\bn_\bo is set to EDOM and a reserve operand fault is gen-
+ erated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A set of these functions function appeared in Version 7 AT&T UNIX.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+J0(3) BSD Programmer's Manual J0(3)
+
+N\bNA\bAM\bME\bE
+ j\bj0\b0, j\bj1\b1, j\bjn\bn, y\by0\b0, y\by1\b1, y\byn\bn - bessel functions of first and second kind
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bjn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\byn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions j\bj0\b0() and j\bj1\b1() compute the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd
+ _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively, for the real value _\bx; the
+ function j\bjn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be
+ _\bi_\bn_\bt_\be_\bg_\be_\br Bessel0 _\bn for the real value _\bx.
+
+ The functions y\by0\b0() and y\by1\b1() compute the linearly independent _\bB_\be_\bs_\bs_\be_\bl
+ _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively,
+ for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double); the function
+ y\byn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bf_\bo_\br _\bt_\bh_\be _\bi_\bn_\bt_\be_\bg_\be_\br
+ Bessel0 _\bn for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ If these functions are successful, the computed value is returned. On the
+ VAX and Tahoe architectures, a negative _\bx value results in an error; the
+ global variable _\be_\br_\br_\bn_\bo is set to EDOM and a reserve operand fault is gen-
+ erated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A set of these functions function appeared in Version 7 AT&T UNIX.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+J0(3) BSD Programmer's Manual J0(3)
+
+N\bNA\bAM\bME\bE
+ j\bj0\b0, j\bj1\b1, j\bjn\bn, y\by0\b0, y\by1\b1, y\byn\bn - bessel functions of first and second kind
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bjn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\byn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions j\bj0\b0() and j\bj1\b1() compute the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd
+ _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively, for the real value _\bx; the
+ function j\bjn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be
+ _\bi_\bn_\bt_\be_\bg_\be_\br Bessel0 _\bn for the real value _\bx.
+
+ The functions y\by0\b0() and y\by1\b1() compute the linearly independent _\bB_\be_\bs_\bs_\be_\bl
+ _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively,
+ for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double); the function
+ y\byn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bf_\bo_\br _\bt_\bh_\be _\bi_\bn_\bt_\be_\bg_\be_\br
+ Bessel0 _\bn for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ If these functions are successful, the computed value is returned. On the
+ VAX and Tahoe architectures, a negative _\bx value results in an error; the
+ global variable _\be_\br_\br_\bn_\bo is set to EDOM and a reserve operand fault is gen-
+ erated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A set of these functions function appeared in Version 7 AT&T UNIX.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+KVM(3) BSD Programmer's Manual KVM(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm - kernel memory interface
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The kvm(3) library provides a uniform interface for accessing kernel vir-
+ tual memory images, including live systems and crashdumps. Access to
+ live systems is via /dev/mem while crashdumps can be examined via the
+ core file generated by savecore(8). The interface behaves identically in
+ both cases. Memory can be read and written, kernel symbol addresses can
+ be looked up efficiently, and information about user processes can be
+ gathered.
+
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() is first called to obtain a descriptor for all subsequent
+ calls.
+
+C\bCO\bOM\bMP\bPA\bAT\bTI\bIB\bBI\bIL\bLI\bIT\bTY\bY
+ The kvm interface was first introduced in SunOS. A considerable number
+ of programs have been developed that use this interface, making backward
+ compatibility highly desirable. In most respects, the Sun kvm interface
+ is consistent and clean. Accordingly, the generic portion of the inter-
+ face (i.e., k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn(), k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be(), k\bkv\bvm\bm_\b_r\bre\bea\bad\bd(), k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be(), and
+ k\bkv\bvm\bm_\b_n\bnl\bli\bis\bst\bt()) has been incorporated into the BSD interface. Indeed, many
+ kvm applications (i.e., debuggers and statistical monitors) use only this
+ subset of the interface.
+
+ The process interface was not kept. This is not a portability issue
+ since any code that manipulates processes is inherently machine depen-
+ dent.
+
+ Finally, the Sun kvm error reporting semantics are poorly defined. The
+ library can be configured either to print errors to stderr automatically,
+ or to print no error messages at all. In the latter case, the nature of
+ the error cannot be determined. To overcome this, the BSD interface in-
+ cludes a routine, kvm_geterr(3), to return (not print out) the error
+ message corresponding to the most recent error condition on the given de-
+ scriptor.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm_close(3), kvm_getargv(3), kvm_getenvv(3), kvm_geterr(3),
+ kvm_getloadavg(3), kvm_getprocs(3), kvm_nlist(3), kvm_open(3),
+ kvm_openfiles(3), kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+KVM_OPEN(3) BSD Programmer's Manual KVM_OPEN(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn, k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs, k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be - initialize kernel virtual memory ac-
+ cess
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<f\bfc\bcn\bnt\btl\bl.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+
+ _\bk_\bv_\bm_\b__\bt _\b*
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\be_\bc_\bf_\bi_\bl_\be, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bc_\bo_\br_\be_\bf_\bi_\bl_\be, _\bc_\bh_\ba_\br _\b*_\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be,
+ _\bi_\bn_\bt _\bf_\bl_\ba_\bg_\bs, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\br_\br_\bs_\bt_\br);
+
+ _\bk_\bv_\bm_\b__\bt _\b*
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\be_\bc_\bf_\bi_\bl_\be, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bc_\bo_\br_\be_\bf_\bi_\bl_\be, _\bc_\bh_\ba_\br _\b*_\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be,
+ _\bi_\bn_\bt _\bf_\bl_\ba_\bg_\bs, _\bc_\bh_\ba_\br _\b*_\be_\br_\br_\bb_\bu_\bf);
+
+ _\bi_\bn_\bt
+ k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() and k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() return a descriptor used to
+ access kernel virtual memory via the kvm(3) library routines. Both ac-
+ tive kernels and crash dumps are accessible through this interface.
+
+ _\be_\bx_\be_\bc_\bf_\bi_\bl_\be is the executable image of the kernel being examined. This file
+ must contain a symbol table. If this argument is NULL, the currently
+ running system is assumed, which is indicated by _PATH_UNIX in <paths.h>.
+
+ _\bc_\bo_\br_\be_\bf_\bi_\bl_\be is the kernel memory device file. It can be either /dev/mem or
+ a crash dump core generated by savecore(8). If _\bc_\bo_\br_\be_\bf_\bi_\bl_\be is NULL, the de-
+ fault indicated by _PATH_MEM from <paths.h> is used.
+
+ _\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be should indicate the swap device. If NULL, _PATH_DRUM from
+ <paths.h> is used.
+
+ The _\bf_\bl_\ba_\bg_\bs argument indicates read/write access as in open(2) and applies
+ to only the core file. Only O_RDONLY, O_WRONLY, and O_RDWR are permit-
+ ted.
+
+ There are two open routines which differ only with respect to the error
+ mechanism. One provides backward compatibility with the SunOS kvm li-
+ brary, while the other provides an improved error reporting framework.
+
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() function is the Sun kvm compatible open call. Here, the
+ _\be_\br_\br_\bs_\bt_\br argument indicates how errors should be handled. If it is NULL,
+ no errors are reported and the application cannot know the specific na-
+ ture of the failed kvm call. If it is not NULL, errors are printed to
+ stderr with _\be_\br_\br_\bs_\bt_\br prepended to the message, as in perror(3). Normally,
+ the name of the program is used here. The string is assumed to persist
+ at least until the corresponding k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() call.
+
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() function provides BSD style error reporting. Here,
+ error messages are not printed out by the library. Instead, the applica-
+ tion obtains the error message corresponding to the most recent kvm li-
+ brary call using k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() (see kvm_geterr(3)). The results are unde-
+ fined if the most recent kvm call did not produce an error. Since
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() requires a kvm descriptor, but the open routines return NULL
+ on failure, k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() cannot be used to get the error message if open
+ fails. Thus, k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() will place any error message in the _\be_\br_\br_\bb_\bu_\bf
+ argument. This buffer should be _POSIX2_LINE_MAX characters large (from
+ <limits.h>).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() and k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() functions both return a descriptor to
+ be used in all subsequent kvm library calls. The library is fully re-
+ entrant. On failure, NULL is returned, in which case k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs()
+ writes the error message into _\be_\br_\br_\bb_\bu_\bf.
+
+ The k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() function returns 0 on sucess and -1 on failure.
+
+B\bBU\bUG\bGS\bS
+ There should not be two open calls. The ill-defined error semantics of
+ the Sun library and the desire to have a backward-compatible library for
+ BSD left little choice.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ open(2), kvm(3), kvm_getargv(3), kvm_getenvv(3), kvm_geterr(3),
+ kvm_getprocs(3), kvm_nlist(3), kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 2
--- /dev/null
+KVM_GETPROCS(3) BSD Programmer's Manual KVM_GETPROCS(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs, k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv, k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv - access user process state
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/k\bki\bin\bnf\bfo\bo.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/k\bki\bin\bnf\bfo\bo_\b_p\bpr\bro\boc\bc.\b.h\bh>\b>
+
+ _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bi_\bn_\bt _\bo_\bp, _\bi_\bn_\bt _\ba_\br_\bg, _\bi_\bn_\bt _\b*_\bc_\bn_\bt);
+
+ _\bc_\bh_\ba_\br _\b*_\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bc_\bo_\bn_\bs_\bt _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*_\bp, _\bi_\bn_\bt _\bn_\bc_\bh_\br);
+
+ _\bc_\bh_\ba_\br _\b*_\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bc_\bo_\bn_\bs_\bt _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*_\bp, _\bi_\bn_\bt _\bn_\bc_\bh_\br);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() returns a (sub-)set of active processes in the kernel in-
+ dicated by _\bk_\bd_\b. The _\bo_\bp and _\ba_\br_\bg arguments constitute a predicate which lim-
+ its the set of processes returned. The value of _\bo_\bp describes the filter-
+ ing predicate as follows:
+
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_A\bAL\bLL\bL all processes
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_P\bPI\bID\bD processes with process id _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_P\bPG\bGR\bRP\bP processes with process group _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_S\bSE\bES\bSS\bSI\bIO\bON\bN processes with session _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_T\bTT\bTY\bY processes with tty _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_U\bUI\bID\bD processes with effective user id _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_R\bRU\bUI\bID\bD processes with real user id _\ba_\br_\bg
+
+ The number of processes found is returned in the reference parameter _\bc_\bn_\bt.
+ The processes are returned as a contiguous array of kinfo_proc struc-
+ tures. This memory is locally allocated, and subsequent calls to
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() and k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() will overwrite this storage.
+
+ k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv() returns a null-terminated argument vector that corresponds
+ to the command line arguments passed to process indicated by _\bp. Most
+ likely, these arguments correspond to the values passed to exec(3) on
+ process creation. This information is, however, deliberately under con-
+ trol of the process itself. Note that the original command name can be
+ found, unaltered, in the p_comm field of the process structure returned
+ by k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs().
+
+ The _\bn_\bc_\bh_\br argument indicates the maximum number of characters, including
+ null bytes, to use in building the strings. If this amount is exceeded,
+ the string causing the overflow is truncated and the partial result is
+ returned. This is handy for programs like ps(1) and w(1) that print only
+ a one line summary of a command and should not copy out large amounts of
+ text only to ignore it. If _\bn_\bc_\bh_\br is zero, no limit is imposed and all ar-
+ gument strings are returned in their entirety.
+
+ The memory allocated to the argv pointers and string storage is owned by
+ the kvm library. Subsequent k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() and kvm_close(3) calls will
+ clobber this storage.
+
+ The k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv() function is similar to k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv() but returns the
+ vector of environment strings. This data is also alterable by the pro-
+ cess.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs(), k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv(), and k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv(), all return NULL on
+ failure.
+
+B\bBU\bUG\bGS\bS
+ These routines do not belong in the kvm interface.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_close(3), kvm_geterr(3), kvm_nlist(3), kvm_open(3),
+ kvm_openfiles(3), kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 2
--- /dev/null
+KVM_GETPROCS(3) BSD Programmer's Manual KVM_GETPROCS(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs, k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv, k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv - access user process state
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/k\bki\bin\bnf\bfo\bo.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/k\bki\bin\bnf\bfo\bo_\b_p\bpr\bro\boc\bc.\b.h\bh>\b>
+
+ _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bi_\bn_\bt _\bo_\bp, _\bi_\bn_\bt _\ba_\br_\bg, _\bi_\bn_\bt _\b*_\bc_\bn_\bt);
+
+ _\bc_\bh_\ba_\br _\b*_\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bc_\bo_\bn_\bs_\bt _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*_\bp, _\bi_\bn_\bt _\bn_\bc_\bh_\br);
+
+ _\bc_\bh_\ba_\br _\b*_\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bc_\bo_\bn_\bs_\bt _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*_\bp, _\bi_\bn_\bt _\bn_\bc_\bh_\br);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() returns a (sub-)set of active processes in the kernel in-
+ dicated by _\bk_\bd_\b. The _\bo_\bp and _\ba_\br_\bg arguments constitute a predicate which lim-
+ its the set of processes returned. The value of _\bo_\bp describes the filter-
+ ing predicate as follows:
+
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_A\bAL\bLL\bL all processes
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_P\bPI\bID\bD processes with process id _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_P\bPG\bGR\bRP\bP processes with process group _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_S\bSE\bES\bSS\bSI\bIO\bON\bN processes with session _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_T\bTT\bTY\bY processes with tty _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_U\bUI\bID\bD processes with effective user id _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_R\bRU\bUI\bID\bD processes with real user id _\ba_\br_\bg
+
+ The number of processes found is returned in the reference parameter _\bc_\bn_\bt.
+ The processes are returned as a contiguous array of kinfo_proc struc-
+ tures. This memory is locally allocated, and subsequent calls to
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() and k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() will overwrite this storage.
+
+ k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv() returns a null-terminated argument vector that corresponds
+ to the command line arguments passed to process indicated by _\bp. Most
+ likely, these arguments correspond to the values passed to exec(3) on
+ process creation. This information is, however, deliberately under con-
+ trol of the process itself. Note that the original command name can be
+ found, unaltered, in the p_comm field of the process structure returned
+ by k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs().
+
+ The _\bn_\bc_\bh_\br argument indicates the maximum number of characters, including
+ null bytes, to use in building the strings. If this amount is exceeded,
+ the string causing the overflow is truncated and the partial result is
+ returned. This is handy for programs like ps(1) and w(1) that print only
+ a one line summary of a command and should not copy out large amounts of
+ text only to ignore it. If _\bn_\bc_\bh_\br is zero, no limit is imposed and all ar-
+ gument strings are returned in their entirety.
+
+ The memory allocated to the argv pointers and string storage is owned by
+ the kvm library. Subsequent k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() and kvm_close(3) calls will
+ clobber this storage.
+
+ The k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv() function is similar to k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv() but returns the
+ vector of environment strings. This data is also alterable by the pro-
+ cess.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs(), k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv(), and k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv(), all return NULL on
+ failure.
+
+B\bBU\bUG\bGS\bS
+ These routines do not belong in the kvm interface.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_close(3), kvm_geterr(3), kvm_nlist(3), kvm_open(3),
+ kvm_openfiles(3), kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 2
--- /dev/null
+KVM_GETERR(3) BSD Programmer's Manual KVM_GETERR(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br - get error message on kvm descriptor
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+
+ _\bc_\bh_\ba_\br _\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This function returns a string describing the most recent error condition
+ on the descriptor _\bk_\bd. The results are undefined if the most recent kvm(3)
+ library call did not produce an error. The string returned is stored in
+ memory owned by kvm(3) so the message should be copied out and saved
+ elsewhere if necessary.
+
+B\bBU\bUG\bGS\bS
+ This routine cannot be used to access error conditions due to a failed
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() call, since failure is indicated by returning a NULL de-
+ scriptor. Therefore, errors on open are output to the special error
+ buffer passed to k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs(). This option is not available to
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn().
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_close(3), kvm_getargv(3), kvm_getenvv(3),
+ kvm_getprocs(3), kvm_nlist(3), kvm_open(3), kvm_openfiles(3),
+ kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+KVM_GETFILES(3) BSD Programmer's Manual KVM_GETFILES(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_g\bge\bet\btf\bfi\bil\ble\bes\bs - survey open files
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/k\bki\bin\bnf\bfo\bo.\b.h\bh>\b>
+ #\b#d\bde\bef\bfi\bin\bne\be K\bKE\bER\bRN\bNE\bEL\bL
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/f\bfi\bil\ble\be.\b.h\bh>\b>
+ #\b#u\bun\bnd\bde\bef\bf K\bKE\bER\bRN\bNE\bEL\bL
+
+ _\bc_\bh_\ba_\br _\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\btf\bfi\bil\ble\bes\bs(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bi_\bn_\bt _\bo_\bp, _\bi_\bn_\bt _\ba_\br_\bg, _\bi_\bn_\bt _\b*_\bc_\bn_\bt);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ k\bkv\bvm\bm_\b_g\bge\bet\btf\bfi\bil\ble\bes\bs() returns a (sub-)set of the open files in the kernel indi-
+ cated by _\bk_\bd_\b. The _\bo_\bp and _\ba_\br_\bg arguments constitute a predicate which limits
+ the set of files returned. No predicates are currently defined.
+
+ The number of processes found is returned in the reference parameter _\bc_\bn_\bt.
+ The files are returned as a contiguous array of file structures, preceed-
+ ed by the address of the first file entry in the kernel. This memory is
+ owned by kvm and is not guaranteed to be persistent across subsequent kvm
+ library calls. Data should be copied out if it needs to be saved.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ k\bkv\bvm\bm_\b_g\bge\bet\btf\bfi\bil\ble\bes\bs() will return NULL on failure.
+
+B\bBU\bUG\bGS\bS
+ This routine does not belong in the kvm interface.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_open(3), kvm_openfiles(3), kvm_close(3), kvm_read(3),
+ kvm_write(3), kvm_nlist(3), kvm_geterr(3)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+KVM_GETLOADAVG(3) BSD Programmer's Manual KVM_GETLOADAVG(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_g\bge\bet\btl\blo\boa\bad\bda\bav\bvg\bg - get error message on kvm descriptor
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/r\bre\bes\bso\bou\bur\brc\bce\be.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+
+ _\bi_\bn_\bt
+ k\bkv\bvm\bm_\b_g\bge\bet\btl\blo\boa\bad\bda\bav\bvg\bg(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bd_\bo_\bu_\bb_\bl_\be _\bl_\bo_\ba_\bd_\ba_\bv_\bg_\b[_\b], _\bi_\bn_\bt _\bn_\be_\bl_\be_\bm);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The k\bkv\bvm\bm_\b_g\bge\bet\btl\blo\boa\bad\bda\bav\bvg\bg() function returns the number of processes in the sys-
+ tem run queue of the kernel indicated by _\bk_\bd, averaged over various peri-
+ ods of time. Up to _\bn_\be_\bl_\be_\bm samples are retrieved and assigned to succes-
+ sive elements of _\bl_\bo_\ba_\bd_\ba_\bv_\bg[]. The system imposes a maximum of 3 samples,
+ representing averages over the last 1, 5, and 15 minutes, respectively.
+
+D\bDI\bIA\bAG\bGN\bNO\bOS\bST\bTI\bIC\bCS\bS
+ If the load average was unobtainable, -1 is returned; otherwise, the num-
+ ber of samples actually retrieved is returned.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ uptime(1), kvm(3), getloadavg(3)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+KVM_GETPROCS(3) BSD Programmer's Manual KVM_GETPROCS(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs, k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv, k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv - access user process state
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/k\bki\bin\bnf\bfo\bo.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/k\bki\bin\bnf\bfo\bo_\b_p\bpr\bro\boc\bc.\b.h\bh>\b>
+
+ _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bi_\bn_\bt _\bo_\bp, _\bi_\bn_\bt _\ba_\br_\bg, _\bi_\bn_\bt _\b*_\bc_\bn_\bt);
+
+ _\bc_\bh_\ba_\br _\b*_\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bc_\bo_\bn_\bs_\bt _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*_\bp, _\bi_\bn_\bt _\bn_\bc_\bh_\br);
+
+ _\bc_\bh_\ba_\br _\b*_\b*
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bc_\bo_\bn_\bs_\bt _\bs_\bt_\br_\bu_\bc_\bt _\bk_\bi_\bn_\bf_\bo_\b__\bp_\br_\bo_\bc _\b*_\bp, _\bi_\bn_\bt _\bn_\bc_\bh_\br);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() returns a (sub-)set of active processes in the kernel in-
+ dicated by _\bk_\bd_\b. The _\bo_\bp and _\ba_\br_\bg arguments constitute a predicate which lim-
+ its the set of processes returned. The value of _\bo_\bp describes the filter-
+ ing predicate as follows:
+
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_A\bAL\bLL\bL all processes
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_P\bPI\bID\bD processes with process id _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_P\bPG\bGR\bRP\bP processes with process group _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_S\bSE\bES\bSS\bSI\bIO\bON\bN processes with session _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_T\bTT\bTY\bY processes with tty _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_U\bUI\bID\bD processes with effective user id _\ba_\br_\bg
+ K\bKI\bIN\bNF\bFO\bO_\b_P\bPR\bRO\bOC\bC_\b_R\bRU\bUI\bID\bD processes with real user id _\ba_\br_\bg
+
+ The number of processes found is returned in the reference parameter _\bc_\bn_\bt.
+ The processes are returned as a contiguous array of kinfo_proc struc-
+ tures. This memory is locally allocated, and subsequent calls to
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() and k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() will overwrite this storage.
+
+ k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv() returns a null-terminated argument vector that corresponds
+ to the command line arguments passed to process indicated by _\bp. Most
+ likely, these arguments correspond to the values passed to exec(3) on
+ process creation. This information is, however, deliberately under con-
+ trol of the process itself. Note that the original command name can be
+ found, unaltered, in the p_comm field of the process structure returned
+ by k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs().
+
+ The _\bn_\bc_\bh_\br argument indicates the maximum number of characters, including
+ null bytes, to use in building the strings. If this amount is exceeded,
+ the string causing the overflow is truncated and the partial result is
+ returned. This is handy for programs like ps(1) and w(1) that print only
+ a one line summary of a command and should not copy out large amounts of
+ text only to ignore it. If _\bn_\bc_\bh_\br is zero, no limit is imposed and all ar-
+ gument strings are returned in their entirety.
+
+ The memory allocated to the argv pointers and string storage is owned by
+ the kvm library. Subsequent k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs() and kvm_close(3) calls will
+ clobber this storage.
+
+ The k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv() function is similar to k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv() but returns the
+ vector of environment strings. This data is also alterable by the pro-
+ cess.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ k\bkv\bvm\bm_\b_g\bge\bet\btp\bpr\bro\boc\bcs\bs(), k\bkv\bvm\bm_\b_g\bge\bet\bta\bar\brg\bgv\bv(), and k\bkv\bvm\bm_\b_g\bge\bet\bte\ben\bnv\bvv\bv(), all return NULL on
+ failure.
+
+B\bBU\bUG\bGS\bS
+ These routines do not belong in the kvm interface.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_close(3), kvm_geterr(3), kvm_nlist(3), kvm_open(3),
+ kvm_openfiles(3), kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 2
--- /dev/null
+KVM_NLIST(3) BSD Programmer's Manual KVM_NLIST(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_n\bnl\bli\bis\bst\bt - retrieve symbol table names from a kernel image
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<n\bnl\bli\bis\bst\bt.\b.h\bh>\b>
+
+ _\bi_\bn_\bt
+ k\bkv\bvm\bm_\b_n\bnl\bli\bis\bst\bt(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bs_\bt_\br_\bu_\bc_\bt _\bn_\bl_\bi_\bs_\bt _\b*_\bn_\bl);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ k\bkv\bvm\bm_\b_n\bnl\bli\bis\bst\bt() retrieves the symbol table entries indicated by the name list
+ argument _\bn_\bl. This argument points to an array of nlist structures, termi-
+ nated by an entry whose n_name field is NULL (see nlist(3)). Each symbol
+ is looked up using the n_name field, and if found, the corresponding
+ n_type and n_value fields are filled in. These fields are set to 0 if
+ the symbol is not found.
+
+ The program kvm_mkdb(8) builds a database from the running kernel's
+ namelist. If the database matches the opened kernel, k\bkv\bvm\bm_\b_n\bnl\bli\bis\bst\bt() uses it
+ to speed lookups.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The k\bkv\bvm\bm_\b_n\bnl\bli\bis\bst\bt() function returns the number of invalid entries found. If
+ the kernel symbol table was unreadable, -1 is returned.
+
+F\bFI\bIL\bLE\bES\bS
+ /var/db/kvm_vmunix.db
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_close(3), kvm_getargv(3), kvm_getenvv(3), kvm_geterr(3),
+ kvm_getprocs(3), kvm_open(3), kvm_openfiles(3), kvm_read(3),
+ kvm_write(3), kvm_mkdb(8)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+KVM_OPEN(3) BSD Programmer's Manual KVM_OPEN(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn, k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs, k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be - initialize kernel virtual memory ac-
+ cess
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<f\bfc\bcn\bnt\btl\bl.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+
+ _\bk_\bv_\bm_\b__\bt _\b*
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\be_\bc_\bf_\bi_\bl_\be, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bc_\bo_\br_\be_\bf_\bi_\bl_\be, _\bc_\bh_\ba_\br _\b*_\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be,
+ _\bi_\bn_\bt _\bf_\bl_\ba_\bg_\bs, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\br_\br_\bs_\bt_\br);
+
+ _\bk_\bv_\bm_\b__\bt _\b*
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\be_\bc_\bf_\bi_\bl_\be, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bc_\bo_\br_\be_\bf_\bi_\bl_\be, _\bc_\bh_\ba_\br _\b*_\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be,
+ _\bi_\bn_\bt _\bf_\bl_\ba_\bg_\bs, _\bc_\bh_\ba_\br _\b*_\be_\br_\br_\bb_\bu_\bf);
+
+ _\bi_\bn_\bt
+ k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() and k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() return a descriptor used to
+ access kernel virtual memory via the kvm(3) library routines. Both ac-
+ tive kernels and crash dumps are accessible through this interface.
+
+ _\be_\bx_\be_\bc_\bf_\bi_\bl_\be is the executable image of the kernel being examined. This file
+ must contain a symbol table. If this argument is NULL, the currently
+ running system is assumed, which is indicated by _PATH_UNIX in <paths.h>.
+
+ _\bc_\bo_\br_\be_\bf_\bi_\bl_\be is the kernel memory device file. It can be either /dev/mem or
+ a crash dump core generated by savecore(8). If _\bc_\bo_\br_\be_\bf_\bi_\bl_\be is NULL, the de-
+ fault indicated by _PATH_MEM from <paths.h> is used.
+
+ _\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be should indicate the swap device. If NULL, _PATH_DRUM from
+ <paths.h> is used.
+
+ The _\bf_\bl_\ba_\bg_\bs argument indicates read/write access as in open(2) and applies
+ to only the core file. Only O_RDONLY, O_WRONLY, and O_RDWR are permit-
+ ted.
+
+ There are two open routines which differ only with respect to the error
+ mechanism. One provides backward compatibility with the SunOS kvm li-
+ brary, while the other provides an improved error reporting framework.
+
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() function is the Sun kvm compatible open call. Here, the
+ _\be_\br_\br_\bs_\bt_\br argument indicates how errors should be handled. If it is NULL,
+ no errors are reported and the application cannot know the specific na-
+ ture of the failed kvm call. If it is not NULL, errors are printed to
+ stderr with _\be_\br_\br_\bs_\bt_\br prepended to the message, as in perror(3). Normally,
+ the name of the program is used here. The string is assumed to persist
+ at least until the corresponding k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() call.
+
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() function provides BSD style error reporting. Here,
+ error messages are not printed out by the library. Instead, the applica-
+ tion obtains the error message corresponding to the most recent kvm li-
+ brary call using k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() (see kvm_geterr(3)). The results are unde-
+ fined if the most recent kvm call did not produce an error. Since
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() requires a kvm descriptor, but the open routines return NULL
+ on failure, k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() cannot be used to get the error message if open
+ fails. Thus, k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() will place any error message in the _\be_\br_\br_\bb_\bu_\bf
+ argument. This buffer should be _POSIX2_LINE_MAX characters large (from
+ <limits.h>).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() and k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() functions both return a descriptor to
+ be used in all subsequent kvm library calls. The library is fully re-
+ entrant. On failure, NULL is returned, in which case k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs()
+ writes the error message into _\be_\br_\br_\bb_\bu_\bf.
+
+ The k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() function returns 0 on sucess and -1 on failure.
+
+B\bBU\bUG\bGS\bS
+ There should not be two open calls. The ill-defined error semantics of
+ the Sun library and the desire to have a backward-compatible library for
+ BSD left little choice.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ open(2), kvm(3), kvm_getargv(3), kvm_getenvv(3), kvm_geterr(3),
+ kvm_getprocs(3), kvm_nlist(3), kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 2
--- /dev/null
+KVM_OPEN(3) BSD Programmer's Manual KVM_OPEN(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn, k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs, k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be - initialize kernel virtual memory ac-
+ cess
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<f\bfc\bcn\bnt\btl\bl.\b.h\bh>\b>
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+
+ _\bk_\bv_\bm_\b__\bt _\b*
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\be_\bc_\bf_\bi_\bl_\be, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bc_\bo_\br_\be_\bf_\bi_\bl_\be, _\bc_\bh_\ba_\br _\b*_\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be,
+ _\bi_\bn_\bt _\bf_\bl_\ba_\bg_\bs, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\br_\br_\bs_\bt_\br);
+
+ _\bk_\bv_\bm_\b__\bt _\b*
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\be_\bc_\bf_\bi_\bl_\be, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bc_\bo_\br_\be_\bf_\bi_\bl_\be, _\bc_\bh_\ba_\br _\b*_\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be,
+ _\bi_\bn_\bt _\bf_\bl_\ba_\bg_\bs, _\bc_\bh_\ba_\br _\b*_\be_\br_\br_\bb_\bu_\bf);
+
+ _\bi_\bn_\bt
+ k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() and k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() return a descriptor used to
+ access kernel virtual memory via the kvm(3) library routines. Both ac-
+ tive kernels and crash dumps are accessible through this interface.
+
+ _\be_\bx_\be_\bc_\bf_\bi_\bl_\be is the executable image of the kernel being examined. This file
+ must contain a symbol table. If this argument is NULL, the currently
+ running system is assumed, which is indicated by _PATH_UNIX in <paths.h>.
+
+ _\bc_\bo_\br_\be_\bf_\bi_\bl_\be is the kernel memory device file. It can be either /dev/mem or
+ a crash dump core generated by savecore(8). If _\bc_\bo_\br_\be_\bf_\bi_\bl_\be is NULL, the de-
+ fault indicated by _PATH_MEM from <paths.h> is used.
+
+ _\bs_\bw_\ba_\bp_\bf_\bi_\bl_\be should indicate the swap device. If NULL, _PATH_DRUM from
+ <paths.h> is used.
+
+ The _\bf_\bl_\ba_\bg_\bs argument indicates read/write access as in open(2) and applies
+ to only the core file. Only O_RDONLY, O_WRONLY, and O_RDWR are permit-
+ ted.
+
+ There are two open routines which differ only with respect to the error
+ mechanism. One provides backward compatibility with the SunOS kvm li-
+ brary, while the other provides an improved error reporting framework.
+
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() function is the Sun kvm compatible open call. Here, the
+ _\be_\br_\br_\bs_\bt_\br argument indicates how errors should be handled. If it is NULL,
+ no errors are reported and the application cannot know the specific na-
+ ture of the failed kvm call. If it is not NULL, errors are printed to
+ stderr with _\be_\br_\br_\bs_\bt_\br prepended to the message, as in perror(3). Normally,
+ the name of the program is used here. The string is assumed to persist
+ at least until the corresponding k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() call.
+
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() function provides BSD style error reporting. Here,
+ error messages are not printed out by the library. Instead, the applica-
+ tion obtains the error message corresponding to the most recent kvm li-
+ brary call using k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() (see kvm_geterr(3)). The results are unde-
+ fined if the most recent kvm call did not produce an error. Since
+ k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() requires a kvm descriptor, but the open routines return NULL
+ on failure, k\bkv\bvm\bm_\b_g\bge\bet\bte\ber\brr\br() cannot be used to get the error message if open
+ fails. Thus, k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() will place any error message in the _\be_\br_\br_\bb_\bu_\bf
+ argument. This buffer should be _POSIX2_LINE_MAX characters large (from
+ <limits.h>).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn() and k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs() functions both return a descriptor to
+ be used in all subsequent kvm library calls. The library is fully re-
+ entrant. On failure, NULL is returned, in which case k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs()
+ writes the error message into _\be_\br_\br_\bb_\bu_\bf.
+
+ The k\bkv\bvm\bm_\b_c\bcl\blo\bos\bse\be() function returns 0 on sucess and -1 on failure.
+
+B\bBU\bUG\bGS\bS
+ There should not be two open calls. The ill-defined error semantics of
+ the Sun library and the desire to have a backward-compatible library for
+ BSD left little choice.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ open(2), kvm(3), kvm_getargv(3), kvm_getenvv(3), kvm_geterr(3),
+ kvm_getprocs(3), kvm_nlist(3), kvm_read(3), kvm_write(3)
+
+4.4BSD June 4, 1993 2
--- /dev/null
+KVM_READ(3) BSD Programmer's Manual KVM_READ(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_r\bre\bea\bad\bd, k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be - read or write kernel virtual memory
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+
+ _\bs_\bs_\bi_\bz_\be_\b__\bt
+ k\bkv\bvm\bm_\b_r\bre\bea\bad\bd(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bu_\b__\bl_\bo_\bn_\bg _\ba_\bd_\bd_\br, _\bv_\bo_\bi_\bd _\b*_\bb_\bu_\bf, _\bs_\bi_\bz_\be_\b__\bt _\bn_\bb_\by_\bt_\be_\bs);
+
+ _\bs_\bs_\bi_\bz_\be_\b__\bt
+ k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bu_\b__\bl_\bo_\bn_\bg _\ba_\bd_\bd_\br, _\bc_\bo_\bn_\bs_\bt _\bv_\bo_\bi_\bd _\b*_\bb_\bu_\bf, _\bs_\bi_\bz_\be_\b__\bt _\bn_\bb_\by_\bt_\be_\bs);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The k\bkv\bvm\bm_\b_r\bre\bea\bad\bd() and k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be() functions are used to read and write ker-
+ nel virtual memory (or a crash dump file). See k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn(_\b3) or
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs(_\b3) for information regarding opening kernel virtual memory
+ and crash dumps.
+
+ The k\bkv\bvm\bm_\b_r\bre\bea\bad\bd() function transfers _\bn_\bb_\by_\bt_\be_\bs bytes of data from the kernel
+ space address _\ba_\bd_\bd_\br to _\bb_\bu_\bf. Conversely, k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be() transfers data from
+ _\bb_\bu_\bf to _\ba_\bd_\bd_\br. Unlike their SunOS counterparts, these functions cannot be
+ used to read or write process address spaces.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ Upon success, the number of bytes actually transferred is returned. Oth-
+ erwise, -1 is returned.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_close(3), kvm_getargv(3), kvm_getenvv(3), kvm_geterr(3),
+ kvm_getprocs(3), kvm_nlist(3), kvm_open(3), kvm_openfiles(3)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+KVM_READ(3) BSD Programmer's Manual KVM_READ(3)
+
+N\bNA\bAM\bME\bE
+ k\bkv\bvm\bm_\b_r\bre\bea\bad\bd, k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be - read or write kernel virtual memory
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<k\bkv\bvm\bm.\b.h\bh>\b>
+
+ _\bs_\bs_\bi_\bz_\be_\b__\bt
+ k\bkv\bvm\bm_\b_r\bre\bea\bad\bd(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bu_\b__\bl_\bo_\bn_\bg _\ba_\bd_\bd_\br, _\bv_\bo_\bi_\bd _\b*_\bb_\bu_\bf, _\bs_\bi_\bz_\be_\b__\bt _\bn_\bb_\by_\bt_\be_\bs);
+
+ _\bs_\bs_\bi_\bz_\be_\b__\bt
+ k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be(_\bk_\bv_\bm_\b__\bt _\b*_\bk_\bd, _\bu_\b__\bl_\bo_\bn_\bg _\ba_\bd_\bd_\br, _\bc_\bo_\bn_\bs_\bt _\bv_\bo_\bi_\bd _\b*_\bb_\bu_\bf, _\bs_\bi_\bz_\be_\b__\bt _\bn_\bb_\by_\bt_\be_\bs);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The k\bkv\bvm\bm_\b_r\bre\bea\bad\bd() and k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be() functions are used to read and write ker-
+ nel virtual memory (or a crash dump file). See k\bkv\bvm\bm_\b_o\bop\bpe\ben\bn(_\b3) or
+ k\bkv\bvm\bm_\b_o\bop\bpe\ben\bnf\bfi\bil\ble\bes\bs(_\b3) for information regarding opening kernel virtual memory
+ and crash dumps.
+
+ The k\bkv\bvm\bm_\b_r\bre\bea\bad\bd() function transfers _\bn_\bb_\by_\bt_\be_\bs bytes of data from the kernel
+ space address _\ba_\bd_\bd_\br to _\bb_\bu_\bf. Conversely, k\bkv\bvm\bm_\b_w\bwr\bri\bit\bte\be() transfers data from
+ _\bb_\bu_\bf to _\ba_\bd_\bd_\br. Unlike their SunOS counterparts, these functions cannot be
+ used to read or write process address spaces.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ Upon success, the number of bytes actually transferred is returned. Oth-
+ erwise, -1 is returned.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ kvm(3), kvm_close(3), kvm_getargv(3), kvm_getenvv(3), kvm_geterr(3),
+ kvm_getprocs(3), kvm_nlist(3), kvm_open(3), kvm_openfiles(3)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+LGAMMA(3) BSD Programmer's Manual LGAMMA(3)
+
+N\bNA\bAM\bME\bE
+ l\blg\bga\bam\bmm\bma\ba g\bga\bam\bmm\bma\ba - log gamma function, gamma function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\be_\bx_\bt_\be_\br_\bn _\bi_\bn_\bt _\bs_\bi_\bg_\bn_\bg_\ba_\bm;
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blg\bga\bam\bmm\bma\ba(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ g\bga\bam\bmm\bma\ba(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN _
+ L\bLg\bga\bam\bmm\bma\ba(_\bx) returns ln|| (x)|.
+ _
+ The external integer _\bs_\bi_\bg_\bn_\bg_\ba_\bm returns the sign of | (x).
+ _
+ G\bGa\bam\bmm\bma\ba(_\bx) returns | (x), with no effect on _\bs_\bi_\bg_\bn_\bg_\ba_\bm.
+
+I\bID\bDI\bIO\bOS\bSY\bYN\bNC\bCR\bRA\bAS\bSI\bIE\bES\bS
+ Do\b_ not use the expression ``signgam*exp(lgamma(x))'' to compute g :=
+ | (x). Instead use a program like this (in C):
+
+ lg = lgamma(x); g = signgam*exp(lg);
+
+ Only after l\blg\bga\bam\bmm\bma\ba() has returned can signgam be correct.
+
+ For arguments in its range, g\bga\bam\bmm\bma\ba() is preferred, as for positive argu-
+ ments it is accurate to within one unit in the last place. Exponentia-
+ tion of l\blg\bga\bam\bmm\bma\ba() will lose up to 10 significant bits.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ G\bGa\bam\bmm\bma\ba() and l\blg\bga\bam\bmm\bma\ba() return appropriate values unless an arguent is out
+ of range. Overflow will occur for sufficiently large positive values,
+ and non-positive integers. On the VAX, the reserved operator is re-
+ turned, and _\be_\br_\br_\bn_\bo is set to ERANGE For large non-integer negative values,
+ g\bga\bam\bmm\bma\ba() will underflow.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The l\blg\bga\bam\bmm\bma\ba function appeared in 4.3BSD. The g\bga\bam\bmm\bma\ba function appeared in
+ 4.4BSD. The name g\bga\bam\bmm\bma\ba() was originally dedicated to the l\blg\bga\bam\bmm\bma\ba() func-
+ tion, so some old code may no longer be compatible.
+
+4.3 Berkeley Distribution June 4, 1993 1
--- /dev/null
+EXP(3) BSD Programmer's Manual EXP(3)
+
+N\bNA\bAM\bME\bE
+ e\bex\bxp\bp, e\bex\bxp\bpm\bm1\b1, l\blo\bog\bg, l\blo\bog\bg1\b10\b0, l\blo\bog\bg1\b1p\bp, p\bpo\bow\bw - exponential, logarithm, power func-
+ tions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bpm\bm1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b10\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b1p\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ p\bpo\bow\bw(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The e\bex\bxp\bp() function computes the exponential value of the given argument
+ _\bx.
+
+ The e\bex\bxp\bpm\bm1\b1() function computes the value exp(x)-1 accurately even for tiny
+ argument _\bx.
+
+ The l\blo\bog\bg() function computes the value for the natural logarithm of the
+ argument x.
+
+ The l\blo\bog\bg1\b10\b0() function computes the value for the logarithm of argument _\bx
+ to base 10.
+
+ The l\blo\bog\bg1\b1p\bp() function computes the value of log(1+x) accurately even for
+ tiny argument _\bx.
+
+ The p\bpo\bow\bw() computes the value of _\bx to the exponent _\by.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf e\bet\btc\bc.\b.)\b)
+ exp(x), log(x), expm1(x) and log1p(x) are accurate to within an _\bu_\bp, and
+ log10(x) to within about 2 _\bu_\bp_\bs; an _\bu_\bp is one _\bU_\bn_\bi_\bt in the _\bL_\ba_\bs_\bt _\bP_\bl_\ba_\bc_\be. The
+ error in p\bpo\bow\bw(_\bx, _\by) is below about 2 _\bu_\bp_\bs when its magnitude is moderate,
+ but increases as p\bpo\bow\bw(_\bx, _\by) approaches the over/underflow thresholds until
+ almost as many bits could be lost as are occupied by the floating-point
+ format's exponent field; that is 8 bits for VAX D and 11 bits for IEEE
+ 754 Double. No such drastic loss has been exposed by testing; the worst
+ errors observed have been below 20 _\bu_\bp_\bs for VAX D, 300 _\bu_\bp_\bs for IEEE 754
+ Double. Moderate values of p\bpo\bow\bw() are accurate enough that p\bpo\bow\bw(_\bi_\bn_\bt_\be_\bg_\be_\br,
+ _\bi_\bn_\bt_\be_\bg_\be_\br) is exact until it is bigger than 2**56 on a VAX, 2**53 for IEEE
+ 754.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ These functions will return the approprate computation unless an error
+ occurs or an argument is out of range. The functions e\bex\bxp\bp(), e\bex\bxp\bpm\bm1\b1() and
+ p\bpo\bow\bw() detect if the computed value will overflow, set the global variable
+ _\be_\br_\br_\bn_\bo _\bt_\bo RANGE and cause a reserved operand fault on a VAX or Tahoe. The
+ function p\bpo\bow\bw(_\bx, _\by) checks to see if _\bx < 0 and _\by is not an integer, in the
+ event this is true, the global variable _\be_\br_\br_\bn_\bo is set to EDOM and on the
+ VAX and Tahoe generate a reserved operand fault. On a VAX and Tahoe,
+ _\be_\br_\br_\bn_\bo is set to EDOM and the reserved operand is returned by log unless _\bx
+ > 0, by l\blo\bog\bg1\b1p\bp() unless _\bx > -1.
+
+N\bNO\bOT\bTE\bES\bS
+ The functions exp(x)-1 and log(1+x) are called expm1 and logp1 in BASIC
+ on the Hewlett-Packard HP-71B and APPLE Macintosh, EXP1 and LN1 in Pas-
+ cal, exp1 and log1 in C on APPLE Macintoshes, where they have been pro-
+ vided to make sure financial calculations of ((1+x)**n-1)/x, namely
+ expm1(n*log1p(x))/x, will be accurate when x is tiny. They also provide
+ accurate inverse hyperbolic functions.
+
+ The function p\bpo\bow\bw(_\bx, _\b0) returns x**0 = 1 for all x including x = 0, Infin-
+ ity (not found on a VAX), and _\bN_\ba_\bN (the reserved operand on a VAX).
+ Previous implementations of pow may have defined x**0 to be undefined in
+ some or all of these cases. Here are reasons for returning x**0 = 1 al-
+ ways:
+
+ 1. Any program that already tests whether x is zero (or infinite or
+ _\bN_\ba_\bN) before computing x**0 cannot care whether 0**0 = 1 or not.
+ Any program that depends upon 0**0 to be invalid is dubious any-
+ way since that expression's meaning and, if invalid, its conse-
+ quences vary from one computer system to another.
+
+ 2. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x, in-
+ cluding x = 0. This is compatible with the convention that ac-
+ cepts a[0] as the value of polynomial
+
+ p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
+
+ at x = 0 rather than reject a[0]*0**0 as invalid.
+
+ 3. Analysts will accept 0**0 = 1 despite that x**y can approach any-
+ thing or nothing as x and y approach 0 independently. The reason
+ for setting 0**0 = 1 anyway is this:
+
+ If x(z) and y(z) are _\ba_\bn_\by functions analytic (expandable in
+ power series) in z around z = 0, and if there x(0) = y(0) =
+ 0, then x(z)**y(z) -> 1 as z -> 0.
+
+ 4. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and then _\bN_\ba_\bN**0 =
+ 1 too because x**0 = 1 for all finite and infinite x, i.e., inde-
+ pendently of x.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A e\bex\bxp\bp(), l\blo\bog\bg() and p\bpo\bow\bw() function appeared in Version 6 AT&T UNIX. A
+ l\blo\bog\bg1\b10\b0() function appeared in Version 7 AT&T UNIX. The l\blo\bog\bg1\b1p\bp() and
+ e\bex\bxp\bpm\bm1\b1() functions appeared in 4.3BSD.
+
+4th Berkeley Distribution June 4, 1993 2
--- /dev/null
+EXP(3) BSD Programmer's Manual EXP(3)
+
+N\bNA\bAM\bME\bE
+ e\bex\bxp\bp, e\bex\bxp\bpm\bm1\b1, l\blo\bog\bg, l\blo\bog\bg1\b10\b0, l\blo\bog\bg1\b1p\bp, p\bpo\bow\bw - exponential, logarithm, power func-
+ tions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bpm\bm1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b10\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b1p\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ p\bpo\bow\bw(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The e\bex\bxp\bp() function computes the exponential value of the given argument
+ _\bx.
+
+ The e\bex\bxp\bpm\bm1\b1() function computes the value exp(x)-1 accurately even for tiny
+ argument _\bx.
+
+ The l\blo\bog\bg() function computes the value for the natural logarithm of the
+ argument x.
+
+ The l\blo\bog\bg1\b10\b0() function computes the value for the logarithm of argument _\bx
+ to base 10.
+
+ The l\blo\bog\bg1\b1p\bp() function computes the value of log(1+x) accurately even for
+ tiny argument _\bx.
+
+ The p\bpo\bow\bw() computes the value of _\bx to the exponent _\by.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf e\bet\btc\bc.\b.)\b)
+ exp(x), log(x), expm1(x) and log1p(x) are accurate to within an _\bu_\bp, and
+ log10(x) to within about 2 _\bu_\bp_\bs; an _\bu_\bp is one _\bU_\bn_\bi_\bt in the _\bL_\ba_\bs_\bt _\bP_\bl_\ba_\bc_\be. The
+ error in p\bpo\bow\bw(_\bx, _\by) is below about 2 _\bu_\bp_\bs when its magnitude is moderate,
+ but increases as p\bpo\bow\bw(_\bx, _\by) approaches the over/underflow thresholds until
+ almost as many bits could be lost as are occupied by the floating-point
+ format's exponent field; that is 8 bits for VAX D and 11 bits for IEEE
+ 754 Double. No such drastic loss has been exposed by testing; the worst
+ errors observed have been below 20 _\bu_\bp_\bs for VAX D, 300 _\bu_\bp_\bs for IEEE 754
+ Double. Moderate values of p\bpo\bow\bw() are accurate enough that p\bpo\bow\bw(_\bi_\bn_\bt_\be_\bg_\be_\br,
+ _\bi_\bn_\bt_\be_\bg_\be_\br) is exact until it is bigger than 2**56 on a VAX, 2**53 for IEEE
+ 754.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ These functions will return the approprate computation unless an error
+ occurs or an argument is out of range. The functions e\bex\bxp\bp(), e\bex\bxp\bpm\bm1\b1() and
+ p\bpo\bow\bw() detect if the computed value will overflow, set the global variable
+ _\be_\br_\br_\bn_\bo _\bt_\bo RANGE and cause a reserved operand fault on a VAX or Tahoe. The
+ function p\bpo\bow\bw(_\bx, _\by) checks to see if _\bx < 0 and _\by is not an integer, in the
+ event this is true, the global variable _\be_\br_\br_\bn_\bo is set to EDOM and on the
+ VAX and Tahoe generate a reserved operand fault. On a VAX and Tahoe,
+ _\be_\br_\br_\bn_\bo is set to EDOM and the reserved operand is returned by log unless _\bx
+ > 0, by l\blo\bog\bg1\b1p\bp() unless _\bx > -1.
+
+N\bNO\bOT\bTE\bES\bS
+ The functions exp(x)-1 and log(1+x) are called expm1 and logp1 in BASIC
+ on the Hewlett-Packard HP-71B and APPLE Macintosh, EXP1 and LN1 in Pas-
+ cal, exp1 and log1 in C on APPLE Macintoshes, where they have been pro-
+ vided to make sure financial calculations of ((1+x)**n-1)/x, namely
+ expm1(n*log1p(x))/x, will be accurate when x is tiny. They also provide
+ accurate inverse hyperbolic functions.
+
+ The function p\bpo\bow\bw(_\bx, _\b0) returns x**0 = 1 for all x including x = 0, Infin-
+ ity (not found on a VAX), and _\bN_\ba_\bN (the reserved operand on a VAX).
+ Previous implementations of pow may have defined x**0 to be undefined in
+ some or all of these cases. Here are reasons for returning x**0 = 1 al-
+ ways:
+
+ 1. Any program that already tests whether x is zero (or infinite or
+ _\bN_\ba_\bN) before computing x**0 cannot care whether 0**0 = 1 or not.
+ Any program that depends upon 0**0 to be invalid is dubious any-
+ way since that expression's meaning and, if invalid, its conse-
+ quences vary from one computer system to another.
+
+ 2. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x, in-
+ cluding x = 0. This is compatible with the convention that ac-
+ cepts a[0] as the value of polynomial
+
+ p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
+
+ at x = 0 rather than reject a[0]*0**0 as invalid.
+
+ 3. Analysts will accept 0**0 = 1 despite that x**y can approach any-
+ thing or nothing as x and y approach 0 independently. The reason
+ for setting 0**0 = 1 anyway is this:
+
+ If x(z) and y(z) are _\ba_\bn_\by functions analytic (expandable in
+ power series) in z around z = 0, and if there x(0) = y(0) =
+ 0, then x(z)**y(z) -> 1 as z -> 0.
+
+ 4. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and then _\bN_\ba_\bN**0 =
+ 1 too because x**0 = 1 for all finite and infinite x, i.e., inde-
+ pendently of x.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A e\bex\bxp\bp(), l\blo\bog\bg() and p\bpo\bow\bw() function appeared in Version 6 AT&T UNIX. A
+ l\blo\bog\bg1\b10\b0() function appeared in Version 7 AT&T UNIX. The l\blo\bog\bg1\b1p\bp() and
+ e\bex\bxp\bpm\bm1\b1() functions appeared in 4.3BSD.
+
+4th Berkeley Distribution June 4, 1993 2
--- /dev/null
+EXP(3) BSD Programmer's Manual EXP(3)
+
+N\bNA\bAM\bME\bE
+ e\bex\bxp\bp, e\bex\bxp\bpm\bm1\b1, l\blo\bog\bg, l\blo\bog\bg1\b10\b0, l\blo\bog\bg1\b1p\bp, p\bpo\bow\bw - exponential, logarithm, power func-
+ tions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bpm\bm1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b10\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b1p\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ p\bpo\bow\bw(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The e\bex\bxp\bp() function computes the exponential value of the given argument
+ _\bx.
+
+ The e\bex\bxp\bpm\bm1\b1() function computes the value exp(x)-1 accurately even for tiny
+ argument _\bx.
+
+ The l\blo\bog\bg() function computes the value for the natural logarithm of the
+ argument x.
+
+ The l\blo\bog\bg1\b10\b0() function computes the value for the logarithm of argument _\bx
+ to base 10.
+
+ The l\blo\bog\bg1\b1p\bp() function computes the value of log(1+x) accurately even for
+ tiny argument _\bx.
+
+ The p\bpo\bow\bw() computes the value of _\bx to the exponent _\by.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf e\bet\btc\bc.\b.)\b)
+ exp(x), log(x), expm1(x) and log1p(x) are accurate to within an _\bu_\bp, and
+ log10(x) to within about 2 _\bu_\bp_\bs; an _\bu_\bp is one _\bU_\bn_\bi_\bt in the _\bL_\ba_\bs_\bt _\bP_\bl_\ba_\bc_\be. The
+ error in p\bpo\bow\bw(_\bx, _\by) is below about 2 _\bu_\bp_\bs when its magnitude is moderate,
+ but increases as p\bpo\bow\bw(_\bx, _\by) approaches the over/underflow thresholds until
+ almost as many bits could be lost as are occupied by the floating-point
+ format's exponent field; that is 8 bits for VAX D and 11 bits for IEEE
+ 754 Double. No such drastic loss has been exposed by testing; the worst
+ errors observed have been below 20 _\bu_\bp_\bs for VAX D, 300 _\bu_\bp_\bs for IEEE 754
+ Double. Moderate values of p\bpo\bow\bw() are accurate enough that p\bpo\bow\bw(_\bi_\bn_\bt_\be_\bg_\be_\br,
+ _\bi_\bn_\bt_\be_\bg_\be_\br) is exact until it is bigger than 2**56 on a VAX, 2**53 for IEEE
+ 754.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ These functions will return the approprate computation unless an error
+ occurs or an argument is out of range. The functions e\bex\bxp\bp(), e\bex\bxp\bpm\bm1\b1() and
+ p\bpo\bow\bw() detect if the computed value will overflow, set the global variable
+ _\be_\br_\br_\bn_\bo _\bt_\bo RANGE and cause a reserved operand fault on a VAX or Tahoe. The
+ function p\bpo\bow\bw(_\bx, _\by) checks to see if _\bx < 0 and _\by is not an integer, in the
+ event this is true, the global variable _\be_\br_\br_\bn_\bo is set to EDOM and on the
+ VAX and Tahoe generate a reserved operand fault. On a VAX and Tahoe,
+ _\be_\br_\br_\bn_\bo is set to EDOM and the reserved operand is returned by log unless _\bx
+ > 0, by l\blo\bog\bg1\b1p\bp() unless _\bx > -1.
+
+N\bNO\bOT\bTE\bES\bS
+ The functions exp(x)-1 and log(1+x) are called expm1 and logp1 in BASIC
+ on the Hewlett-Packard HP-71B and APPLE Macintosh, EXP1 and LN1 in Pas-
+ cal, exp1 and log1 in C on APPLE Macintoshes, where they have been pro-
+ vided to make sure financial calculations of ((1+x)**n-1)/x, namely
+ expm1(n*log1p(x))/x, will be accurate when x is tiny. They also provide
+ accurate inverse hyperbolic functions.
+
+ The function p\bpo\bow\bw(_\bx, _\b0) returns x**0 = 1 for all x including x = 0, Infin-
+ ity (not found on a VAX), and _\bN_\ba_\bN (the reserved operand on a VAX).
+ Previous implementations of pow may have defined x**0 to be undefined in
+ some or all of these cases. Here are reasons for returning x**0 = 1 al-
+ ways:
+
+ 1. Any program that already tests whether x is zero (or infinite or
+ _\bN_\ba_\bN) before computing x**0 cannot care whether 0**0 = 1 or not.
+ Any program that depends upon 0**0 to be invalid is dubious any-
+ way since that expression's meaning and, if invalid, its conse-
+ quences vary from one computer system to another.
+
+ 2. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x, in-
+ cluding x = 0. This is compatible with the convention that ac-
+ cepts a[0] as the value of polynomial
+
+ p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
+
+ at x = 0 rather than reject a[0]*0**0 as invalid.
+
+ 3. Analysts will accept 0**0 = 1 despite that x**y can approach any-
+ thing or nothing as x and y approach 0 independently. The reason
+ for setting 0**0 = 1 anyway is this:
+
+ If x(z) and y(z) are _\ba_\bn_\by functions analytic (expandable in
+ power series) in z around z = 0, and if there x(0) = y(0) =
+ 0, then x(z)**y(z) -> 1 as z -> 0.
+
+ 4. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and then _\bN_\ba_\bN**0 =
+ 1 too because x**0 = 1 for all finite and infinite x, i.e., inde-
+ pendently of x.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A e\bex\bxp\bp(), l\blo\bog\bg() and p\bpo\bow\bw() function appeared in Version 6 AT&T UNIX. A
+ l\blo\bog\bg1\b10\b0() function appeared in Version 7 AT&T UNIX. The l\blo\bog\bg1\b1p\bp() and
+ e\bex\bxp\bpm\bm1\b1() functions appeared in 4.3BSD.
+
+4th Berkeley Distribution June 4, 1993 2
--- /dev/null
+IEEE(3) BSD Programmer's Manual IEEE(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn, d\bdr\bre\bem\bm, f\bfi\bin\bni\bit\bte\be, l\blo\bog\bgb\bb, s\bsc\bca\bal\blb\bb - IEEE 754 floating point support
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ d\bdr\bre\bem\bm(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bi_\bn_\bt
+ f\bfi\bin\bni\bit\bte\be(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bgb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsc\bca\bal\blb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bi_\bn_\bt _\bn);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions are required for, or recommended by the IEEE standard 754
+ for floating-point arithmetic.
+
+ The c\bco\bop\bpy\bys\bsi\big\bgn\bn() function returns _\bx with its sign changed to _\by's.
+
+ The d\bdr\bre\bem\bm() function returns the remainder _\br := _\bx - _\bn_\b*_\by where _\bn is the in-
+ teger nearest the exact value of _\bx/_\by; moreover if |_\bn - _\bx/_\by| = 1/2 then _\bn
+ is even. Consequently the remainder is computed exactly and |_\br| <=
+ |_\by|/2. But d\bdr\bre\bem\bm(_\bx, _\b0) is exceptional. (See below under _\bD_\bI_\bA_\bG_\bN_\bO_\bS_\bT_\bI_\bC_\bS.)
+
+ The f\bfi\bin\bni\bit\bte\be() function returns the value 1 just when -infinity < _\bx < +in-
+ finity; otherwise a zero is returned (when |_\bx| = infinity or _\bx is _\bN_\ba_\bN or
+ is the VAX's reserved operand).
+
+ The l\blo\bog\bgb\bb() function returns _\bx's exponent _\bn, a signed integer converted to
+ double-precision floating-point and so chosen that 1 (<= |_\bx|2**_\bn < 2 un-
+ less _\bx = 0 or (only on machines that conform to IEEE 754) |_\bx| = infinity
+ or _\bx lies between 0 and the Underflow Threshold. (See below under _\bB_\bU_\bG_\bS.)
+
+ The s\bsc\bca\bal\blb\bb() function returns _\bx*(2**_\bn) computed, for integer n, without
+ first computing 2*_\bn.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The IEEE standard 754 defines d\bdr\bre\bem\bm(_\bx, _\b0) and d\bdr\bre\bem\bm(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\by) to be in-
+ valid operations that produce a _\bN_\ba_\bN. On the VAX, d\bdr\bre\bem\bm(_\bx, _\b0) generates a
+ reserved operand fault. No infinity exists on a VAX.
+
+ IEEE 754 defines l\blo\bog\bgb\bb(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = infinity and l\blo\bog\bgb\bb(_\b0) = -infinity, and
+ requires the latter to signal Division-by-Zero. But on a VAX, l\blo\bog\bgb\bb(_\b0) =
+ 1.0 - 2.0**31 = -2,147,483,647.0. And if the correct value of s\bsc\bca\bal\blb\bb()
+ would overflow on a VAX, it generates a reserved operand fault and sets
+ the global variable _\be_\br_\br_\bn_\bo to ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ floor(3), math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bie\bee\bee\be functions appeared in 4.3BSD.
+
+B\bBU\bUG\bGS\bS
+ Should d\bdr\bre\bem\bm(_\bx, _\b0) and l\blo\bog\bgb\bb(_\b0) on a VAX signal invalidity by setting _\be_\br_\br_\bn_\bo
+ = EDOM ? Should l\blo\bog\bgb\bb(_\b0) return -1.7e38?
+
+ IEEE 754 currently specifies that l\blo\bog\bgb\bb(_\bd_\be_\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b.) = l\blo\bog\bgb\bb(_\bt_\bi_\bn_\bi_\be_\bs_\bt
+ _\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b. _\b> _\b0) but the consensus has changed to the specification in
+ the new proposed IEEE standard p854, namely that l\blo\bog\bgb\bb(_\bx) satisfy
+
+ 1 <= s\bsc\bca\bal\blb\bb(|_\bx|, _\b-_\bl_\bo_\bg_\bb_\b(_\bx_\b)) < Radix ... = 2 for IEEE 754
+
+ for every x except 0, infinity and _\bN_\ba_\bN. Almost every program that as-
+ sumes 754's specification will work correctly if l\blo\bog\bgb\bb() follows 854's
+ specification instead.
+
+ IEEE 754 requires c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\bN_\ba_\bN_\b)) = +-_\bx but says nothing else about the
+ sign of a _\bN_\ba_\bN. A _\bN_\ba_\bN _\b(_\bNot _\ba _\bNumber) is similar in spirit to the VAX's
+ reserved operand, but very different in important details. Since the
+ sign bit of a reserved operand makes it look negative,
+
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\br_\be_\bs_\be_\br_\bv_\be_\bd _\bo_\bp_\be_\br_\ba_\bn_\bd) = -_\bx;
+
+ should this return the reserved operand instead?
+
+4.3 Berkeley Distribution June 4, 1993 2
--- /dev/null
+LSEARCH(3) BSD Programmer's Manual LSEARCH(3)
+
+N\bNA\bAM\bME\bE
+ l\bls\bse\bea\bar\brc\bch\bh, l\blf\bfi\bin\bnd\bd,\b, - linear searching routines
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ _\bc_\bh_\ba_\br _\b*
+ l\bls\bse\bea\bar\brc\bch\bh(_\bc_\bo_\bn_\bs_\bt _\bv_\bo_\bi_\bd _\b*_\bk_\be_\by, _\bc_\bo_\bn_\bs_\bt _\bv_\bo_\bi_\bd _\b*_\bb_\ba_\bs_\be, _\bs_\bi_\bz_\be_\b__\bt _\b*_\bn_\be_\bl_\bp, _\bs_\bi_\bz_\be_\b__\bt _\bw_\bi_\bd_\bt_\bh,
+ _\bi_\bn_\bt _\b(_\b*_\bc_\bo_\bm_\bp_\ba_\br_\b)_\b(_\bv_\bo_\bi_\bd _\b*_\b, _\bv_\bo_\bi_\bd _\b*_\b));
+
+ _\bc_\bh_\ba_\br _\b*
+ l\blf\bfi\bin\bnd\bd(_\bc_\bo_\bn_\bs_\bt _\bv_\bo_\bi_\bd _\b*_\bk_\be_\by, _\bc_\bo_\bn_\bs_\bt _\bv_\bo_\bi_\bd _\b*_\bb_\ba_\bs_\be, _\bs_\bi_\bz_\be_\b__\bt _\b*_\bn_\be_\bl_\bp, _\bs_\bi_\bz_\be_\b__\bt _\bw_\bi_\bd_\bt_\bh,
+ _\bi_\bn_\bt _\b(_\b*_\bc_\bo_\bm_\bp_\ba_\br_\b)_\b(_\bv_\bo_\bi_\bd _\b*_\b, _\bv_\bo_\bi_\bd _\b*_\b));
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhi\bis\bs i\bin\bnt\bte\ber\brf\bfa\bac\bce\be w\bwa\bas\bs o\bob\bbs\bso\bol\ble\bet\bte\be b\bbe\bef\bfo\bor\bre\be i\bit\bt w\bwa\bas\bs w\bwr\bri\bit\btt\bte\ben\bn.\b. I\bIt\bt i\bis\bs a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm
+ t\bth\bhe\be c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ The functions l\bls\bse\bea\bar\brc\bch\bh(), and l\blf\bfi\bin\bnd\bd() provide basic linear searching func-
+ tionality.
+
+ _\bB_\ba_\bs_\be is the pointer to the beginning of an array. The argument _\bn_\be_\bl_\bp is
+ the current number of elements in the array, where each element is _\bw_\bi_\bd_\bt_\bh
+ bytes long. The _\bc_\bo_\bm_\bp_\ba_\br function is a comparison routine which is used to
+ compare two elements. It takes two arguments which point to the _\bk_\be_\by ob-
+ ject and to an array member, in that order, and must return an integer
+ less than, equivalent to, or greater than zero if the _\bk_\be_\by object is con-
+ sidered, respectively, to be less than, equal to, or greater than the ar-
+ ray member.
+
+ The l\bls\bse\bea\bar\brc\bch\bh() and l\blf\bfi\bin\bnd\bd() functions return a pointer into the array ref-
+ erenced by _\bb_\ba_\bs_\be where _\bk_\be_\by is located. If _\bk_\be_\by does not exist, l\blf\bfi\bin\bnd\bd()
+ will return a null pointer and l\bls\bse\bea\bar\brc\bch\bh() will add it to the array. When
+ an element is added to the array by l\bls\bse\bea\bar\brc\bch\bh() the location referenced by
+ the argument _\bn_\be_\bl_\bp is incremented by one.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ bsearch(3), db(3)
+
+4.4BSD June 4, 1993 1
--- /dev/null
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+N\bNA\bAM\bME\bE
+ math - introduction to mathematical library functions
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions constitute the C math library, _\bl_\bi_\bb_\bm_\b. The
+ link editor searches this library under the "-lm" option.
+ Declarations for these functions may be obtained from the
+ include file <_\bm_\ba_\bt_\bh_\b._\bh>. The Fortran math library is
+ described in ``man 3f intro''.
+
+L\bLI\bIS\bST\bT O\bOF\bF F\bFU\bUN\bNC\bCT\bTI\bIO\bON\bNS\bS
+ _\bN_\ba_\bm_\be _\bA_\bp_\bp_\be_\ba_\br_\bs _\bo_\bn _\bP_\ba_\bg_\be _\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn _\bE_\br_\br_\bo_\br _\bB_\bo_\bu_\bn_\bd _\b(_\bU_\bL_\bP_\bs_\b)
+ acos sin.3m inverse trigonometric function 3
+ acosh asinh.3m inverse hyperbolic function 3
+ asin sin.3m inverse trigonometric function 3
+ asinh asinh.3m inverse hyperbolic function 3
+ atan sin.3m inverse trigonometric function 1
+ atanh asinh.3m inverse hyperbolic function 3
+ atan2 sin.3m inverse trigonometric function 2
+ cabs hypot.3m complex absolute value 1
+ cbrt sqrt.3m cube root 1
+ ceil floor.3m integer no less than 0
+ copysign ieee.3m copy sign bit 0
+ cos sin.3m trigonometric function 1
+ cosh sinh.3m hyperbolic function 3
+ drem ieee.3m remainder 0
+ erf erf.3m error function ???
+ erfc erf.3m complementary error function ???
+ exp exp.3m exponential 1
+ expm1 exp.3m exp(x)-1 1
+ fabs floor.3m absolute value 0
+ floor floor.3m integer no greater than 0
+ hypot hypot.3m Euclidean distance 1
+ infnan infnan.3m signals exceptions
+ j0 j0.3m bessel function ???
+ j1 j0.3m bessel function ???
+ jn j0.3m bessel function ???
+ lgamma lgamma.3m log gamma function; (formerly gamma.3m)
+ log exp.3m natural logarithm 1
+ logb ieee.3m exponent extraction 0
+ log10 exp.3m logarithm to base 10 3
+ log1p exp.3m log(1+x) 1
+ pow exp.3m exponential x**y 60-500
+ rint floor.3m round to nearest integer 0
+ scalb ieee.3m exponent adjustment 0
+ sin sin.3m trigonometric function 1
+ sinh sinh.3m hyperbolic function 3
+ sqrt sqrt.3m square root 1
+ tan sin.3m trigonometric function 3
+ tanh sinh.3m hyperbolic function 3
+ y0 j0.3m bessel function ???
+
+
+
+4th Berkeley Distribution June 4, 1993 1
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ y1 j0.3m bessel function ???
+ yn j0.3m bessel function ???
+
+N\bNO\bOT\bTE\bES\bS
+ In 4.3 BSD, distributed from the University of California
+ in late 1985, most of the foregoing functions come in two
+ versions, one for the double-precision "D" format in the
+ DEC VAX-11 family of computers, another for dou-
+ ble-precision arithmetic conforming to the IEEE Standard
+ 754 for Binary Floating-Point Arithmetic. The two ver-
+ sions behave very similarly, as should be expected from
+ programs more accurate and robust than was the norm when
+ UNIX was born. For instance, the programs are accurate to
+ within the numbers of _\bu_\bl_\bps tabulated above; an _\bu_\bl_\bp is one
+ _\bUnit in the _\bLast _\bPlace. And the programs have been cured
+ of anomalies that afflicted the older math library _\bl_\bi_\bb_\bm in
+ which incidents like the following had been reported:
+ sqrt(-1.0) = 0.0 and log(-1.0) = -1.7e38.
+ cos(1.0e-11) > cos(0.0) > 1.0.
+ pow(x,1.0) != x when x = 2.0, 3.0, 4.0, ..., 9.0.
+ pow(-1.0,1.0e10) trapped on Integer Overflow.
+ sqrt(1.0e30) and sqrt(1.0e-30) were very slow.
+ However the two versions do differ in ways that have to be
+ explained, to which end the following notes are provided.
+
+ D\bDE\bEC\bC V\bVA\bAX\bX-\b-1\b11\b1 D\bD_\b_f\bfl\blo\boa\bat\bti\bin\bng\bg-\b-p\bpo\boi\bin\bnt\bt:\b:
+
+ This is the format for which the original math library
+ _\bl_\bi_\bb_\bm was developed, and to which this manual is still
+ principally dedicated. It is _\bt_\bh_\be double-precision format
+ for the PDP-11 and the earlier VAX-11 machines; VAX-11s
+ after 1983 were provided with an optional "G" format
+ closer to the IEEE double-precision format. The earlier
+ DEC MicroVAXs have no D format, only G double-precision.
+ (Why? Why not?)
+
+ Properties of D_floating-point:
+ Wordsize: 64 bits, 8 bytes. Radix: Binary.
+ Precision: 56 sig. bits, roughly like 17 sig.
+ decimals.
+ If x and x' are consecutive positive
+ D_floating-point numbers (they differ by 1
+ _\bu_\bl_\bp), then
+ 1.3e-17 < 0.5**56 < (x'-x)/x <= 0.5**55 <
+ 2.8e-17.
+ Range: Overflow threshold = 2.0**127 = 1.7e38.
+ Underflow threshold = 0.5**128 = 2.9e-39.
+ NOTE: THIS RANGE IS COMPARATIVELY NARROW.
+ Overflow customarily stops computation.
+ Underflow is customarily flushed quietly to
+ zero.
+
+
+
+4th Berkeley Distribution June 4, 1993 2
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ CAUTION:
+ It is possible to have x != y and
+ yet x-y = 0 because of underflow.
+ Similarly x > y > 0 cannot prevent
+ either x*y = 0 or y/x = 0 from hap-
+ pening without warning.
+ Zero is represented ambiguously.
+ Although 2**55 different representations of
+ zero are accepted by the hardware, only the
+ obvious representation is ever produced.
+ There is no -0 on a VAX.
+ Infinity is not part of the VAX architecture.
+ Reserved operands:
+ of the 2**55 that the hardware recognizes,
+ only one of them is ever produced. Any
+ floating-point operation upon a reserved
+ operand, even a MOVF or MOVD, customarily
+ stops computation, so they are not much
+ used.
+ Exceptions:
+ Divisions by zero and operations that over-
+ flow are invalid operations that customarily
+ stop computation or, in earlier machines,
+ produce reserved operands that will stop
+ computation.
+ Rounding:
+ Every rational operation (+, -, *, /) on a
+ VAX (but not necessarily on a PDP-11), if
+ not an over/underflow nor division by zero,
+ is rounded to within half an _\bu_\bl_\bp, and when
+ the rounding error is exactly half an _\bu_\bl_\bp
+ then rounding is away from 0.
+
+ Except for its narrow range, D_floating-point is one of
+ the better computer arithmetics designed in the 1960's.
+ Its properties are reflected fairly faithfully in the ele-
+ mentary functions for a VAX distributed in 4.3 BSD. They
+ over/underflow only if their results have to lie out of
+ range or very nearly so, and then they behave much as any
+ rational arithmetic operation that over/underflowed would
+ behave. Similarly, expressions like log(0) and atanh(1)
+ behave like 1/0; and sqrt(-3) and acos(3) behave like 0/0;
+ they all produce reserved operands and/or stop computa-
+ tion! The situation is described in more detail in manual
+ pages.
+ _\bT_\bh_\bi_\bs _\br_\be_\bs_\bp_\bo_\bn_\bs_\be _\bs_\be_\be_\bm_\bs _\be_\bx_\bc_\be_\bs_\bs_\bi_\bv_\be_\bl_\by _\bp_\bu_\bn_\bi_\bt_\bi_\bv_\be_\b, _\bs_\bo
+ _\bi_\bt _\bi_\bs _\bd_\be_\bs_\bt_\bi_\bn_\be_\bd _\bt_\bo _\bb_\be _\br_\be_\bp_\bl_\ba_\bc_\be_\bd _\ba_\bt _\bs_\bo_\bm_\be _\bt_\bi_\bm_\be _\bi_\bn
+ _\bt_\bh_\be _\bf_\bo_\br_\be_\bs_\be_\be_\ba_\bb_\bl_\be _\bf_\bu_\bt_\bu_\br_\be _\bb_\by _\ba _\bm_\bo_\br_\be _\bf_\bl_\be_\bx_\bi_\bb_\bl_\be _\bb_\bu_\bt
+ _\bs_\bt_\bi_\bl_\bl _\bu_\bn_\bi_\bf_\bo_\br_\bm _\bs_\bc_\bh_\be_\bm_\be _\bb_\be_\bi_\bn_\bg _\bd_\be_\bv_\be_\bl_\bo_\bp_\be_\bd _\bt_\bo _\bh_\ba_\bn_\bd_\bl_\be
+ _\ba_\bl_\bl _\bf_\bl_\bo_\ba_\bt_\bi_\bn_\bg_\b-_\bp_\bo_\bi_\bn_\bt _\ba_\br_\bi_\bt_\bh_\bm_\be_\bt_\bi_\bc _\be_\bx_\bc_\be_\bp_\bt_\bi_\bo_\bn_\bs
+ _\bn_\be_\ba_\bt_\bl_\by_\b. _\bS_\be_\be _\bi_\bn_\bf_\bn_\ba_\bn_\b(_\b3_\bM_\b) _\bf_\bo_\br _\bt_\bh_\be _\bp_\br_\be_\bs_\be_\bn_\bt _\bs_\bt_\ba_\bt_\be
+
+
+
+4th Berkeley Distribution June 4, 1993 3
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ _\bo_\bf _\ba_\bf_\bf_\ba_\bi_\br_\bs_\b.
+
+ How do the functions in 4.3 BSD's new _\bl_\bi_\bb_\bm for UNIX com-
+ pare with their counterparts in DEC's VAX/VMS library?
+ Some of the VMS functions are a little faster, some are a
+ little more accurate, some are more puritanical about
+ exceptions (like pow(0.0,0.0) and atan2(0.0,0.0)), and
+ most occupy much more memory than their counterparts in
+ _\bl_\bi_\bb_\bm. The VMS codes interpolate in large table to achieve
+ speed and accuracy; the _\bl_\bi_\bb_\bm codes use tricky formulas
+ compact enough that all of them may some day fit into a
+ ROM.
+
+ More important, DEC regards the VMS codes as proprietary
+ and guards them zealously against unauthorized use. But
+ the _\bl_\bi_\bb_\bm codes in 4.3 BSD are intended for the public
+ domain; they may be copied freely provided their prove-
+ nance is always acknowledged, and provided users assist
+ the authors in their researches by reporting experience
+ with the codes. Therefore no user of UNIX on a machine
+ whose arithmetic resembles VAX D_floating-point need use
+ anything worse than the new _\bl_\bi_\bb_\bm.
+
+ I\bIE\bEE\bEE\bE S\bST\bTA\bAN\bND\bDA\bAR\bRD\bD 7\b75\b54\b4 F\bFl\blo\boa\bat\bti\bin\bng\bg-\b-P\bPo\boi\bin\bnt\bt A\bAr\bri\bit\bth\bhm\bme\bet\bti\bic\bc:\b:
+
+ This standard is on its way to becoming more widely
+ adopted than any other design for computer arithmetic.
+ VLSI chips that conform to some version of that standard
+ have been produced by a host of manufacturers, among them
+ ...
+ Intel i8087, i80287 National Semiconductor 32081
+ Motorola 68881 Weitek WTL-1032, ... , -1165
+ Zilog Z8070 Western Electric (AT&T) WE32106.
+ Other implementations range from software, done thoroughly
+ in the Apple Macintosh, through VLSI in the
+ Hewlett-Packard 9000 series, to the ELXSI 6400 running ECL
+ at 3 Megaflops. Several other companies have adopted the
+ formats of IEEE 754 without, alas, adhering to the stan-
+ dard's way of handling rounding and exceptions like
+ over/underflow. The DEC VAX G_floating-point format is
+ very similar to the IEEE 754 Double format, so similar
+ that the C programs for the IEEE versions of most of the
+ elementary functions listed above could easily be con-
+ verted to run on a MicroVAX, though nobody has volunteered
+ to do that yet.
+
+ The codes in 4.3 BSD's _\bl_\bi_\bb_\bm for machines that conform to
+ IEEE 754 are intended primarily for the National Semi.
+ 32081 and WTL 1164/65. To use these codes with the Intel
+ or Zilog chips, or with the Apple Macintosh or ELXSI 6400,
+ is to forego the use of better codes provided (perhaps
+
+
+
+4th Berkeley Distribution June 4, 1993 4
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ freely) by those companies and designed by some of the
+ authors of the codes above. Except for _\ba_\bt_\ba_\bn, _\bc_\ba_\bb_\bs, _\bc_\bb_\br_\bt,
+ _\be_\br_\bf, _\be_\br_\bf_\bc, _\bh_\by_\bp_\bo_\bt, _\bj_\b0_\b-_\bj_\bn, _\bl_\bg_\ba_\bm_\bm_\ba, _\bp_\bo_\bw and _\by_\b0_\b-_\by_\bn, the
+ Motorola 68881 has all the functions in _\bl_\bi_\bb_\bm on chip, and
+ faster and more accurate; it, Apple, the i8087, Z8070 and
+ WE32106 all use 64 sig. bits. The main virtue of 4.3
+ BSD's _\bl_\bi_\bb_\bm codes is that they are intended for the public
+ domain; they may be copied freely provided their prove-
+ nance is always acknowledged, and provided users assist
+ the authors in their researches by reporting experience
+ with the codes. Therefore no user of UNIX on a machine
+ that conforms to IEEE 754 need use anything worse than the
+ new _\bl_\bi_\bb_\bm.
+
+ Properties of IEEE 754 Double-Precision:
+ Wordsize: 64 bits, 8 bytes. Radix: Binary.
+ Precision: 53 sig. bits, roughly like 16 sig.
+ decimals.
+ If x and x' are consecutive positive Dou-
+ ble-Precision numbers (they differ by 1
+ _\bu_\bl_\bp), then
+ 1.1e-16 < 0.5**53 < (x'-x)/x <= 0.5**52 <
+ 2.3e-16.
+ Range: Overflow threshold = 2.0**1024 = 1.8e308
+ Underflow threshold = 0.5**1022 = 2.2e-308
+ Overflow goes by default to a signed Infin-
+ ity.
+ Underflow is _\bG_\br_\ba_\bd_\bu_\ba_\bl_\b, rounding to the near-
+ est integer multiple of 0.5**1074 =
+ 4.9e-324.
+ Zero is represented ambiguously as +0 or -0.
+ Its sign transforms correctly through multi-
+ plication or division, and is preserved by
+ addition of zeros with like signs; but x-x
+ yields +0 for every finite x. The only
+ operations that reveal zero's sign are divi-
+ sion by zero and copysign(x,+-0). In par-
+ ticular, comparison (x > y, x >= y, etc.)
+ cannot be affected by the sign of zero; but
+ if finite x = y then Infinity = 1/(x-y) !=
+ -1/(y-x) = -Infinity.
+ Infinity is signed.
+ it persists when added to itself or to any
+ finite number. Its sign transforms cor-
+ rectly through multiplication and division,
+ and (finite)/+-Infinity = +-0 (nonzero)/0 =
+ +-Infinity. But Infinity-Infinity, Infin-
+ ity*0 and Infinity/Infinity are, like 0/0
+ and sqrt(-3), invalid operations that pro-
+ duce _\bN_\ba_\bN. ...
+ Reserved operands:
+
+
+
+4th Berkeley Distribution June 4, 1993 5
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ there are 2**53-2 of them, all called _\bN_\ba_\bN
+ (_\bNot _\ba _\bNumber). Some, called Signaling
+ _\bN_\ba_\bNs, trap any floating-point operation per-
+ formed upon them; they are used to mark
+ missing or uninitialized values, or nonexis-
+ tent elements of arrays. The rest are Quiet
+ _\bN_\ba_\bNs; they are the default results of
+ Invalid Operations, and propagate through
+ subsequent arithmetic operations. If x != x
+ then x is _\bN_\ba_\bN; every other predicate (x > y,
+ x = y, x < y, ...) is FALSE if _\bN_\ba_\bN is
+ involved.
+ NOTE: Trichotomy is violated by _\bN_\ba_\bN.
+ Besides being FALSE, predicates that
+ entail ordered comparison, rather
+ than mere (in)equality, signal
+ Invalid Operation when _\bN_\ba_\bN is
+ involved.
+ Rounding:
+ Every algebraic operation (+, -, *, /, sqrt)
+ is rounded by default to within half an _\bu_\bl_\bp,
+ and when the rounding error is exactly half
+ an _\bu_\bl_\bp then the rounded value's least sig-
+ nificant bit is zero. This kind of rounding
+ is usually the best kind, sometimes provably
+ so; for instance, for every x = 1.0, 2.0,
+ 3.0, 4.0, ..., 2.0**52, we find (x/3.0)*3.0
+ == x and (x/10.0)*10.0 == x and ... despite
+ that both the quotients and the products
+ have been rounded. Only rounding like IEEE
+ 754 can do that. But no single kind of
+ rounding can be proved best for every cir-
+ cumstance, so IEEE 754 provides rounding
+ towards zero or towards +Infinity or towards
+ -Infinity at the programmer's option. And
+ the same kinds of rounding are specified for
+ Binary-Decimal Conversions, at least for
+ magnitudes between roughly 1.0e-10 and
+ 1.0e37.
+ Exceptions:
+ IEEE 754 recognizes five kinds of float-
+ ing-point exceptions, listed below in
+ declining order of probable importance.
+ Exception Default Result
+ __________________________________________
+ Invalid Operation _\bN_\ba_\bN, or FALSE
+ Overflow +-Infinity
+ Divide by Zero +-Infinity
+ Underflow Gradual Underflow
+ Inexact Rounded value
+ NOTE: An Exception is not an Error unless
+
+
+
+4th Berkeley Distribution June 4, 1993 6
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ handled badly. What makes a class of excep-
+ tions exceptional is that no single default
+ response can be satisfactory in every
+ instance. On the other hand, if a default
+ response will serve most instances satisfac-
+ torily, the unsatisfactory instances cannot
+ justify aborting computation every time the
+ exception occurs.
+
+ For each kind of floating-point exception, IEEE 754
+ provides a Flag that is raised each time its excep-
+ tion is signaled, and stays raised until the pro-
+ gram resets it. Programs may also test, save and
+ restore a flag. Thus, IEEE 754 provides three ways
+ by which programs may cope with exceptions for
+ which the default result might be unsatisfactory:
+
+ 1) Test for a condition that might cause an excep-
+ tion later, and branch to avoid the exception.
+
+ 2) Test a flag to see whether an exception has
+ occurred since the program last reset its flag.
+
+ 3) Test a result to see whether it is a value that
+ only an exception could have produced.
+ CAUTION: The only reliable ways to discover
+ whether Underflow has occurred are to test
+ whether products or quotients lie closer to
+ zero than the underflow threshold, or to test
+ the Underflow flag. (Sums and differences can-
+ not underflow in IEEE 754; if x != y then x-y
+ is correct to full precision and certainly
+ nonzero regardless of how tiny it may be.)
+ Products and quotients that underflow gradually
+ can lose accuracy gradually without vanishing,
+ so comparing them with zero (as one might on a
+ VAX) will not reveal the loss. Fortunately, if
+ a gradually underflowed value is destined to be
+ added to something bigger than the underflow
+ threshold, as is almost always the case, digits
+ lost to gradual underflow will not be missed
+ because they would have been rounded off any-
+ way. So gradual underflows are usually _\bp_\br_\bo_\bv_\b-
+ _\ba_\bb_\bl_\by ignorable. The same cannot be said of
+ underflows flushed to 0.
+
+ At the option of an implementor conforming to IEEE
+ 754, other ways to cope with exceptions may be pro-
+ vided:
+
+ 4) ABORT. This mechanism classifies an exception
+
+
+
+4th Berkeley Distribution June 4, 1993 7
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ in advance as an incident to be handled by
+ means traditionally associated with
+ error-handling statements like "ON ERROR GO TO
+ ...". Different languages offer different
+ forms of this statement, but most share the
+ following characteristics:
+
+ -- No means is provided to substitute a value for
+ the offending operation's result and resume
+ computation from what may be the middle of an
+ expression. An exceptional result is aban-
+ doned.
+
+ -- In a subprogram that lacks an error-handling
+ statement, an exception causes the subprogram
+ to abort within whatever program called it, and
+ so on back up the chain of calling subprograms
+ until an error-handling statement is encoun-
+ tered or the whole task is aborted and memory
+ is dumped.
+
+ 5) STOP. This mechanism, requiring an interactive
+ debugging environment, is more for the program-
+ mer than the program. It classifies an excep-
+ tion in advance as a symptom of a programmer's
+ error; the exception suspends execution as near
+ as it can to the offending operation so that
+ the programmer can look around to see how it
+ happened. Quite often the first several excep-
+ tions turn out to be quite unexceptionable, so
+ the programmer ought ideally to be able to
+ resume execution after each one as if execution
+ had not been stopped.
+
+ 6) ... Other ways lie beyond the scope of this
+ document.
+
+ The crucial problem for exception handling is the problem
+ of Scope, and the problem's solution is understood, but
+ not enough manpower was available to implement it fully in
+ time to be distributed in 4.3 BSD's _\bl_\bi_\bb_\bm. Ideally, each
+ elementary function should act as if it were indivisible,
+ or atomic, in the sense that ...
+
+ i) No exception should be signaled that is not deserved
+ by the data supplied to that function.
+
+ ii) Any exception signaled should be identified with
+ that function rather than with one of its subrou-
+ tines.
+
+
+
+
+4th Berkeley Distribution June 4, 1993 8
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+ iii) The internal behavior of an atomic function should
+ not be disrupted when a calling program changes from
+ one to another of the five or so ways of handling
+ exceptions listed above, although the definition of
+ the function may be correlated intentionally with
+ exception handling.
+
+ Ideally, every programmer should be able _\bc_\bo_\bn_\bv_\be_\bn_\bi_\be_\bn_\bt_\bl_\by to
+ turn a debugged subprogram into one that appears atomic to
+ its users. But simulating all three characteristics of an
+ atomic function is still a tedious affair, entailing hosts
+ of tests and saves-restores; work is under way to amelio-
+ rate the inconvenience.
+
+ Meanwhile, the functions in _\bl_\bi_\bb_\bm are only approximately
+ atomic. They signal no inappropriate exception except
+ possibly ...
+ Over/Underflow
+ when a result, if properly computed, might
+ have lain barely within range, and
+ Inexact in _\bc_\ba_\bb_\bs, _\bc_\bb_\br_\bt, _\bh_\by_\bp_\bo_\bt, _\bl_\bo_\bg_\b1_\b0 and _\bp_\bo_\bw
+ when it happens to be exact, thanks to for-
+ tuitous cancellation of errors.
+ Otherwise, ...
+ Invalid Operation is signaled only when
+ any result but _\bN_\ba_\bN would probably be mis-
+ leading.
+ Overflow is signaled only when
+ the exact result would be finite but beyond
+ the overflow threshold.
+ Divide-by-Zero is signaled only when
+ a function takes exactly infinite values at
+ finite operands.
+ Underflow is signaled only when
+ the exact result would be nonzero but tinier
+ than the underflow threshold.
+ Inexact is signaled only when
+ greater range or precision would be needed
+ to represent the exact result.
+
+B\bBU\bUG\bGS\bS
+ When signals are appropriate, they are emitted by certain
+ operations within the codes, so a subroutine-trace may be
+ needed to identify the function with its signal in case
+ method 5) above is in use. And the codes all take the
+ IEEE 754 defaults for granted; this means that a decision
+ to trap all divisions by zero could disrupt a code that
+ would otherwise get correct results despite division by
+ zero.
+
+
+
+
+
+4th Berkeley Distribution June 4, 1993 9
+
+
+
+
+
+
+
+
+MATH(3) BSD Programmer's Manual MATH(3)
+
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ An explanation of IEEE 754 and its proposed extension p854
+ was published in the IEEE magazine MICRO in August 1984
+ under the title "A Proposed Radix- and
+ Word-length-independent Standard for Floating-point Arith-
+ metic" by W. J. Cody et al. The manuals for Pascal, C and
+ BASIC on the Apple Macintosh document the features of IEEE
+ 754 pretty well. Articles in the IEEE magazine COMPUTER
+ vol. 14 no. 3 (Mar. 1981), and in the ACM SIGNUM Newslet-
+ ter Special Issue of Oct. 1979, may be helpful although
+ they pertain to superseded drafts of the standard.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4th Berkeley Distribution June 4, 1993 10
+
+
+
+
+
--- /dev/null
+EXP(3) BSD Programmer's Manual EXP(3)
+
+N\bNA\bAM\bME\bE
+ e\bex\bxp\bp, e\bex\bxp\bpm\bm1\b1, l\blo\bog\bg, l\blo\bog\bg1\b10\b0, l\blo\bog\bg1\b1p\bp, p\bpo\bow\bw - exponential, logarithm, power func-
+ tions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ e\bex\bxp\bpm\bm1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b10\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bg1\b1p\bp(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ p\bpo\bow\bw(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The e\bex\bxp\bp() function computes the exponential value of the given argument
+ _\bx.
+
+ The e\bex\bxp\bpm\bm1\b1() function computes the value exp(x)-1 accurately even for tiny
+ argument _\bx.
+
+ The l\blo\bog\bg() function computes the value for the natural logarithm of the
+ argument x.
+
+ The l\blo\bog\bg1\b10\b0() function computes the value for the logarithm of argument _\bx
+ to base 10.
+
+ The l\blo\bog\bg1\b1p\bp() function computes the value of log(1+x) accurately even for
+ tiny argument _\bx.
+
+ The p\bpo\bow\bw() computes the value of _\bx to the exponent _\by.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf e\bet\btc\bc.\b.)\b)
+ exp(x), log(x), expm1(x) and log1p(x) are accurate to within an _\bu_\bp, and
+ log10(x) to within about 2 _\bu_\bp_\bs; an _\bu_\bp is one _\bU_\bn_\bi_\bt in the _\bL_\ba_\bs_\bt _\bP_\bl_\ba_\bc_\be. The
+ error in p\bpo\bow\bw(_\bx, _\by) is below about 2 _\bu_\bp_\bs when its magnitude is moderate,
+ but increases as p\bpo\bow\bw(_\bx, _\by) approaches the over/underflow thresholds until
+ almost as many bits could be lost as are occupied by the floating-point
+ format's exponent field; that is 8 bits for VAX D and 11 bits for IEEE
+ 754 Double. No such drastic loss has been exposed by testing; the worst
+ errors observed have been below 20 _\bu_\bp_\bs for VAX D, 300 _\bu_\bp_\bs for IEEE 754
+ Double. Moderate values of p\bpo\bow\bw() are accurate enough that p\bpo\bow\bw(_\bi_\bn_\bt_\be_\bg_\be_\br,
+ _\bi_\bn_\bt_\be_\bg_\be_\br) is exact until it is bigger than 2**56 on a VAX, 2**53 for IEEE
+ 754.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ These functions will return the approprate computation unless an error
+ occurs or an argument is out of range. The functions e\bex\bxp\bp(), e\bex\bxp\bpm\bm1\b1() and
+ p\bpo\bow\bw() detect if the computed value will overflow, set the global variable
+ _\be_\br_\br_\bn_\bo _\bt_\bo RANGE and cause a reserved operand fault on a VAX or Tahoe. The
+ function p\bpo\bow\bw(_\bx, _\by) checks to see if _\bx < 0 and _\by is not an integer, in the
+ event this is true, the global variable _\be_\br_\br_\bn_\bo is set to EDOM and on the
+ VAX and Tahoe generate a reserved operand fault. On a VAX and Tahoe,
+ _\be_\br_\br_\bn_\bo is set to EDOM and the reserved operand is returned by log unless _\bx
+ > 0, by l\blo\bog\bg1\b1p\bp() unless _\bx > -1.
+
+N\bNO\bOT\bTE\bES\bS
+ The functions exp(x)-1 and log(1+x) are called expm1 and logp1 in BASIC
+ on the Hewlett-Packard HP-71B and APPLE Macintosh, EXP1 and LN1 in Pas-
+ cal, exp1 and log1 in C on APPLE Macintoshes, where they have been pro-
+ vided to make sure financial calculations of ((1+x)**n-1)/x, namely
+ expm1(n*log1p(x))/x, will be accurate when x is tiny. They also provide
+ accurate inverse hyperbolic functions.
+
+ The function p\bpo\bow\bw(_\bx, _\b0) returns x**0 = 1 for all x including x = 0, Infin-
+ ity (not found on a VAX), and _\bN_\ba_\bN (the reserved operand on a VAX).
+ Previous implementations of pow may have defined x**0 to be undefined in
+ some or all of these cases. Here are reasons for returning x**0 = 1 al-
+ ways:
+
+ 1. Any program that already tests whether x is zero (or infinite or
+ _\bN_\ba_\bN) before computing x**0 cannot care whether 0**0 = 1 or not.
+ Any program that depends upon 0**0 to be invalid is dubious any-
+ way since that expression's meaning and, if invalid, its conse-
+ quences vary from one computer system to another.
+
+ 2. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x, in-
+ cluding x = 0. This is compatible with the convention that ac-
+ cepts a[0] as the value of polynomial
+
+ p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
+
+ at x = 0 rather than reject a[0]*0**0 as invalid.
+
+ 3. Analysts will accept 0**0 = 1 despite that x**y can approach any-
+ thing or nothing as x and y approach 0 independently. The reason
+ for setting 0**0 = 1 anyway is this:
+
+ If x(z) and y(z) are _\ba_\bn_\by functions analytic (expandable in
+ power series) in z around z = 0, and if there x(0) = y(0) =
+ 0, then x(z)**y(z) -> 1 as z -> 0.
+
+ 4. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and then _\bN_\ba_\bN**0 =
+ 1 too because x**0 = 1 for all finite and infinite x, i.e., inde-
+ pendently of x.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A e\bex\bxp\bp(), l\blo\bog\bg() and p\bpo\bow\bw() function appeared in Version 6 AT&T UNIX. A
+ l\blo\bog\bg1\b10\b0() function appeared in Version 7 AT&T UNIX. The l\blo\bog\bg1\b1p\bp() and
+ e\bex\bxp\bpm\bm1\b1() functions appeared in 4.3BSD.
+
+4th Berkeley Distribution June 4, 1993 2
--- /dev/null
+RE_COMP(3) BSD Programmer's Manual RE_COMP(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\be_\b_c\bco\bom\bmp\bp, r\bre\be_\b_e\bex\bxe\bec\bc - regular expression handler
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<u\bun\bni\bis\bst\btd\bd.\b.h\bh>\b>
+
+ _\bc_\bh_\ba_\br _\b*
+ r\bre\be_\b_c\bco\bom\bmp\bp(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs);
+
+ _\bi_\bn_\bt
+ r\bre\be_\b_e\bex\bxe\bec\bc(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This interface is made obsolete by regex(3).
+
+ The r\bre\be_\b_c\bco\bom\bmp\bp() function compiles a string into an internal form suitable
+ for pattern matching. The r\bre\be_\b_e\bex\bxe\bec\bc() function checks the argument string
+ against the last string passed to r\bre\be_\b_c\bco\bom\bmp\bp().
+
+ The r\bre\be_\b_c\bco\bom\bmp\bp() function returns 0 if the string _\bs was compiled successful-
+ ly; otherwise a string containing an error message is returned. If
+ r\bre\be_\b_c\bco\bom\bmp\bp() is passed 0 or a null string, it returns without changing the
+ currently compiled regular expression.
+
+ The r\bre\be_\b_e\bex\bxe\bec\bc() function returns 1 if the string _\bs matches the last com-
+ piled regular expression, 0 if the string _\bs failed to match the last com-
+ piled regular expression, and -1 if the compiled regular expression was
+ invalid (indicating an internal error).
+
+ The strings passed to both r\bre\be_\b_c\bco\bom\bmp\bp() and r\bre\be_\b_e\bex\bxe\bec\bc() may have trailing or
+ embedded newline characters; they are terminated by NULs. The regular ex-
+ pressions recognized are described in the manual entry for ed(1), given
+ the above difference.
+
+D\bDI\bIA\bAG\bGN\bNO\bOS\bST\bTI\bIC\bCS\bS
+ The r\bre\be_\b_e\bex\bxe\bec\bc() function returns -1 for an internal error.
+
+ The r\bre\be_\b_c\bco\bom\bmp\bp() function returns one of the following strings if an error
+ occurs:
+
+ No previous regular expression,
+ Regular expression too long,
+ unmatched \(,
+ missing ],
+ too many \(\) pairs,
+ unmatched \).
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ed(1), ex(1), egrep(1), fgrep(1), grep(1), regex(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The r\bre\be_\b_c\bco\bom\bmp\bp() and r\bre\be_\b_e\bex\bxe\bec\bc() functions appeared in 4.0BSD.
+
+4.4BSD June 4, 1993 1
--- /dev/null
+RE_COMP(3) BSD Programmer's Manual RE_COMP(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\be_\b_c\bco\bom\bmp\bp, r\bre\be_\b_e\bex\bxe\bec\bc - regular expression handler
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<u\bun\bni\bis\bst\btd\bd.\b.h\bh>\b>
+
+ _\bc_\bh_\ba_\br _\b*
+ r\bre\be_\b_c\bco\bom\bmp\bp(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs);
+
+ _\bi_\bn_\bt
+ r\bre\be_\b_e\bex\bxe\bec\bc(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This interface is made obsolete by regex(3).
+
+ The r\bre\be_\b_c\bco\bom\bmp\bp() function compiles a string into an internal form suitable
+ for pattern matching. The r\bre\be_\b_e\bex\bxe\bec\bc() function checks the argument string
+ against the last string passed to r\bre\be_\b_c\bco\bom\bmp\bp().
+
+ The r\bre\be_\b_c\bco\bom\bmp\bp() function returns 0 if the string _\bs was compiled successful-
+ ly; otherwise a string containing an error message is returned. If
+ r\bre\be_\b_c\bco\bom\bmp\bp() is passed 0 or a null string, it returns without changing the
+ currently compiled regular expression.
+
+ The r\bre\be_\b_e\bex\bxe\bec\bc() function returns 1 if the string _\bs matches the last com-
+ piled regular expression, 0 if the string _\bs failed to match the last com-
+ piled regular expression, and -1 if the compiled regular expression was
+ invalid (indicating an internal error).
+
+ The strings passed to both r\bre\be_\b_c\bco\bom\bmp\bp() and r\bre\be_\b_e\bex\bxe\bec\bc() may have trailing or
+ embedded newline characters; they are terminated by NULs. The regular ex-
+ pressions recognized are described in the manual entry for ed(1), given
+ the above difference.
+
+D\bDI\bIA\bAG\bGN\bNO\bOS\bST\bTI\bIC\bCS\bS
+ The r\bre\be_\b_e\bex\bxe\bec\bc() function returns -1 for an internal error.
+
+ The r\bre\be_\b_c\bco\bom\bmp\bp() function returns one of the following strings if an error
+ occurs:
+
+ No previous regular expression,
+ Regular expression too long,
+ unmatched \(,
+ missing ],
+ too many \(\) pairs,
+ unmatched \).
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ed(1), ex(1), egrep(1), fgrep(1), grep(1), regex(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The r\bre\be_\b_c\bco\bom\bmp\bp() and r\bre\be_\b_e\bex\bxe\bec\bc() functions appeared in 4.0BSD.
+
+4.4BSD June 4, 1993 1
--- /dev/null
+REGEXP(3) BSD Programmer's Manual REGEXP(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\beg\bgc\bco\bom\bmp\bp, r\bre\beg\bge\bex\bxe\bec\bc, r\bre\beg\bgs\bsu\bub\bb, r\bre\beg\bge\ber\brr\bro\bor\br - regular expression handlers
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<r\bre\beg\bge\bex\bxp\bp.\b.h\bh>\b>
+
+ _\br_\be_\bg_\be_\bx_\bp _\b*
+ r\bre\beg\bgc\bco\bom\bmp\bp(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\bp);
+
+ _\bi_\bn_\bt
+ r\bre\beg\bge\bex\bxe\bec\bc(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bt_\br_\bi_\bn_\bg);
+
+ _\bv_\bo_\bi_\bd
+ r\bre\beg\bgs\bsu\bub\bb(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bo_\bu_\br_\bc_\be, _\bc_\bh_\ba_\br _\b*_\bd_\be_\bs_\bt);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This interface is made obsolete by regex(3).
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and r\bre\beg\bge\ber\brr\bro\bor\br() functions implement
+ egrep(1)-style regular expressions and supporting facilities.
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function compiles a regular expression into a structure of
+ type regexp, and returns a pointer to it. The space has been allocated
+ using malloc(3) and may be released by free.
+
+ The r\bre\beg\bge\bex\bxe\bec\bc() function matches a NUL-terminated _\bs_\bt_\br_\bi_\bn_\bg against the com-
+ piled regular expression in _\bp_\br_\bo_\bg. It returns 1 for success and 0 for
+ failure, and adjusts the contents of _\bp_\br_\bo_\bg's _\bs_\bt_\ba_\br_\bt_\bp and _\be_\bn_\bd_\bp (see below)
+ accordingly.
+
+ The members of a regexp structure include at least the following (not
+ necessarily in order):
+
+ char *startp[NSUBEXP];
+ char *endp[NSUBEXP];
+
+ where NSUBEXP is defined (as 10) in the header file. Once a successful
+ r\bre\beg\bge\bex\bxe\bec\bc() has been done using the r\bre\beg\bge\bex\bxp\bp(), each _\bs_\bt_\ba_\br_\bt_\bp- _\be_\bn_\bd_\bp pair de-
+ scribes one substring within the _\bs_\bt_\br_\bi_\bn_\bg, with the _\bs_\bt_\ba_\br_\bt_\bp pointing to the
+ first character of the substring and the _\be_\bn_\bd_\bp pointing to the first char-
+ acter following the substring. The 0th substring is the substring of
+ _\bs_\bt_\br_\bi_\bn_\bg that matched the whole regular expression. The others are those
+ substrings that matched parenthesized expressions within the regular ex-
+ pression, with parenthesized expressions numbered in left-to-right order
+ of their opening parentheses.
+
+ The r\bre\beg\bgs\bsu\bub\bb() function copies _\bs_\bo_\bu_\br_\bc_\be to _\bd_\be_\bs_\bt, making substitutions accord-
+ ing to the most recent r\bre\beg\bge\bex\bxe\bec\bc() performed using _\bp_\br_\bo_\bg. Each instance of
+ `&' in _\bs_\bo_\bu_\br_\bc_\be is replaced by the substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[] and
+ _\be_\bn_\bd_\bp[]. Each instance of `\_\bn', where _\bn is a digit, is replaced by the
+ substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[_\bn] and _\be_\bn_\bd_\bp[_\bn]. To get a literal `&' or
+ `\_\bn' into _\bd_\be_\bs_\bt, prefix it with `\'; to get a literal `\' preceding `&' or
+ `\_\bn', prefix it with another `\'.
+
+ The r\bre\beg\bge\ber\brr\bro\bor\br() function is called whenever an error is detected in
+ r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), or r\bre\beg\bgs\bsu\bub\bb(). The default r\bre\beg\bge\ber\brr\bro\bor\br() writes the
+ string _\bm_\bs_\bg, with a suitable indicator of origin, on the standard error
+ output and invokes exit(2). The r\bre\beg\bge\ber\brr\bro\bor\br() function can be replaced by
+ the user if other actions are desirable.
+
+R\bRE\bEG\bGU\bUL\bLA\bAR\bR E\bEX\bXP\bPR\bRE\bES\bSS\bSI\bIO\bON\bN S\bSY\bYN\bNT\bTA\bAX\bX
+ A regular expression is zero or more _\bb_\br_\ba_\bn_\bc_\bh_\be_\bs, separated by `|'. It
+ matches anything that matches one of the branches.
+
+ A branch is zero or more _\bp_\bi_\be_\bc_\be_\bs, concatenated. It matches a match for
+ the first, followed by a match for the second, etc.
+
+ A piece is an _\ba_\bt_\bo_\bm possibly followed by `*', `+', or `?'. An atom fol-
+ lowed by `*' matches a sequence of 0 or more matches of the atom. An
+ atom followed by `+' matches a sequence of 1 or more matches of the atom.
+ An atom followed by `?' matches a match of the atom, or the null string.
+
+ An atom is a regular expression in parentheses (matching a match for the
+ regular expression), a _\br_\ba_\bn_\bg_\be (see below), `.' (matching any single char-
+ acter), `^' (matching the null string at the beginning of the input
+ string), `$' (matching the null string at the end of the input string), a
+ `\' followed by a single character (matching that character), or a single
+ character with no other significance (matching that character).
+
+ A _\br_\ba_\bn_\bg_\be is a sequence of characters enclosed in `[]'. It normally match-
+ es any single character from the sequence. If the sequence begins with
+ `^', it matches any single character _\bn_\bo_\bt from the rest of the sequence.
+ If two characters in the sequence are separated by `-', this is shorthand
+ for the full list of ASCII characters between them (e.g. `[0-9]' matches
+ any decimal digit). To include a literal `]' in the sequence, make it
+ the first character (following a possible `^'). To include a literal
+ `-', make it the first or last character.
+
+A\bAM\bMB\bBI\bIG\bGU\bUI\bIT\bTY\bY
+ If a regular expression could match two different parts of the input
+ string, it will match the one which begins earliest. If both begin in
+ the same place but match different lengths, or match the same length in
+ different ways, life gets messier, as follows.
+
+ In general, the possibilities in a list of branches are considered in
+ left-to-right order, the possibilities for `*', `+', and `?' are consid-
+ ered longest-first, nested constructs are considered from the outermost
+ in, and concatenated constructs are considered leftmost-first. The match
+ that will be chosen is the one that uses the earliest possibility in the
+ first choice that has to be made. If there is more than one choice, the
+ next will be made in the same manner (earliest possibility) subject to
+ the decision on the first choice. And so forth.
+
+ For example, `(ab|a)b*c' could match `abc' in one of two ways. The first
+ choice is between `ab' and `a'; since `ab' is earlier, and does lead to a
+ successful overall match, it is chosen. Since the `b' is already spoken
+ for, the `b*' must match its last possibility--the empty string--since it
+ must respect the earlier choice.
+
+ In the particular case where no `|'s are present and there is only one
+ `*', `+', or `?', the net effect is that the longest possible match will
+ be chosen. So `ab*', presented with `xabbbby', will match `abbbb'. Note
+ that if `ab*', is tried against `xabyabbbz', it will match `ab' just af-
+ ter `x', due to the begins-earliest rule. (In effect, the decision on
+ where to start the match is the first choice to be made, hence subsequent
+ choices must respect it even if this leads them to less-preferred alter-
+ natives.)
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function returns NULL for a failure (r\bre\beg\bge\ber\brr\bro\bor\br() permit-
+ ting), where failures are syntax errors, exceeding implementation limits,
+ or applying `+' or `*' to a possibly-null operand.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ed(1), ex(1), expr(1), egrep(1), fgrep(1), grep(1), regex(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ Both code and manual page for r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and
+ r\bre\beg\bge\ber\brr\bro\bor\br() were written at the University of Toronto and appeared in
+ 4.3BSD-Tahoe. They are intended to be compatible with the Bell V8
+ regexp(3), but are not derived from Bell code.
+
+B\bBU\bUG\bGS\bS
+ Empty branches and empty regular expressions are not portable to V8.
+
+ The restriction against applying `*' or `+' to a possibly-null operand is
+ an artifact of the simplistic implementation.
+
+ Does not support egrep's newline-separated branches; neither does the V8
+ regexp(3), though.
+
+ Due to emphasis on compactness and simplicity, it's not strikingly fast.
+ It does give special attention to handling simple cases quickly.
+
+4.4BSD June 4, 1993 3
--- /dev/null
+REGEXP(3) BSD Programmer's Manual REGEXP(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\beg\bgc\bco\bom\bmp\bp, r\bre\beg\bge\bex\bxe\bec\bc, r\bre\beg\bgs\bsu\bub\bb, r\bre\beg\bge\ber\brr\bro\bor\br - regular expression handlers
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<r\bre\beg\bge\bex\bxp\bp.\b.h\bh>\b>
+
+ _\br_\be_\bg_\be_\bx_\bp _\b*
+ r\bre\beg\bgc\bco\bom\bmp\bp(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\bp);
+
+ _\bi_\bn_\bt
+ r\bre\beg\bge\bex\bxe\bec\bc(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bt_\br_\bi_\bn_\bg);
+
+ _\bv_\bo_\bi_\bd
+ r\bre\beg\bgs\bsu\bub\bb(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bo_\bu_\br_\bc_\be, _\bc_\bh_\ba_\br _\b*_\bd_\be_\bs_\bt);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This interface is made obsolete by regex(3).
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and r\bre\beg\bge\ber\brr\bro\bor\br() functions implement
+ egrep(1)-style regular expressions and supporting facilities.
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function compiles a regular expression into a structure of
+ type regexp, and returns a pointer to it. The space has been allocated
+ using malloc(3) and may be released by free.
+
+ The r\bre\beg\bge\bex\bxe\bec\bc() function matches a NUL-terminated _\bs_\bt_\br_\bi_\bn_\bg against the com-
+ piled regular expression in _\bp_\br_\bo_\bg. It returns 1 for success and 0 for
+ failure, and adjusts the contents of _\bp_\br_\bo_\bg's _\bs_\bt_\ba_\br_\bt_\bp and _\be_\bn_\bd_\bp (see below)
+ accordingly.
+
+ The members of a regexp structure include at least the following (not
+ necessarily in order):
+
+ char *startp[NSUBEXP];
+ char *endp[NSUBEXP];
+
+ where NSUBEXP is defined (as 10) in the header file. Once a successful
+ r\bre\beg\bge\bex\bxe\bec\bc() has been done using the r\bre\beg\bge\bex\bxp\bp(), each _\bs_\bt_\ba_\br_\bt_\bp- _\be_\bn_\bd_\bp pair de-
+ scribes one substring within the _\bs_\bt_\br_\bi_\bn_\bg, with the _\bs_\bt_\ba_\br_\bt_\bp pointing to the
+ first character of the substring and the _\be_\bn_\bd_\bp pointing to the first char-
+ acter following the substring. The 0th substring is the substring of
+ _\bs_\bt_\br_\bi_\bn_\bg that matched the whole regular expression. The others are those
+ substrings that matched parenthesized expressions within the regular ex-
+ pression, with parenthesized expressions numbered in left-to-right order
+ of their opening parentheses.
+
+ The r\bre\beg\bgs\bsu\bub\bb() function copies _\bs_\bo_\bu_\br_\bc_\be to _\bd_\be_\bs_\bt, making substitutions accord-
+ ing to the most recent r\bre\beg\bge\bex\bxe\bec\bc() performed using _\bp_\br_\bo_\bg. Each instance of
+ `&' in _\bs_\bo_\bu_\br_\bc_\be is replaced by the substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[] and
+ _\be_\bn_\bd_\bp[]. Each instance of `\_\bn', where _\bn is a digit, is replaced by the
+ substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[_\bn] and _\be_\bn_\bd_\bp[_\bn]. To get a literal `&' or
+ `\_\bn' into _\bd_\be_\bs_\bt, prefix it with `\'; to get a literal `\' preceding `&' or
+ `\_\bn', prefix it with another `\'.
+
+ The r\bre\beg\bge\ber\brr\bro\bor\br() function is called whenever an error is detected in
+ r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), or r\bre\beg\bgs\bsu\bub\bb(). The default r\bre\beg\bge\ber\brr\bro\bor\br() writes the
+ string _\bm_\bs_\bg, with a suitable indicator of origin, on the standard error
+ output and invokes exit(2). The r\bre\beg\bge\ber\brr\bro\bor\br() function can be replaced by
+ the user if other actions are desirable.
+
+R\bRE\bEG\bGU\bUL\bLA\bAR\bR E\bEX\bXP\bPR\bRE\bES\bSS\bSI\bIO\bON\bN S\bSY\bYN\bNT\bTA\bAX\bX
+ A regular expression is zero or more _\bb_\br_\ba_\bn_\bc_\bh_\be_\bs, separated by `|'. It
+ matches anything that matches one of the branches.
+
+ A branch is zero or more _\bp_\bi_\be_\bc_\be_\bs, concatenated. It matches a match for
+ the first, followed by a match for the second, etc.
+
+ A piece is an _\ba_\bt_\bo_\bm possibly followed by `*', `+', or `?'. An atom fol-
+ lowed by `*' matches a sequence of 0 or more matches of the atom. An
+ atom followed by `+' matches a sequence of 1 or more matches of the atom.
+ An atom followed by `?' matches a match of the atom, or the null string.
+
+ An atom is a regular expression in parentheses (matching a match for the
+ regular expression), a _\br_\ba_\bn_\bg_\be (see below), `.' (matching any single char-
+ acter), `^' (matching the null string at the beginning of the input
+ string), `$' (matching the null string at the end of the input string), a
+ `\' followed by a single character (matching that character), or a single
+ character with no other significance (matching that character).
+
+ A _\br_\ba_\bn_\bg_\be is a sequence of characters enclosed in `[]'. It normally match-
+ es any single character from the sequence. If the sequence begins with
+ `^', it matches any single character _\bn_\bo_\bt from the rest of the sequence.
+ If two characters in the sequence are separated by `-', this is shorthand
+ for the full list of ASCII characters between them (e.g. `[0-9]' matches
+ any decimal digit). To include a literal `]' in the sequence, make it
+ the first character (following a possible `^'). To include a literal
+ `-', make it the first or last character.
+
+A\bAM\bMB\bBI\bIG\bGU\bUI\bIT\bTY\bY
+ If a regular expression could match two different parts of the input
+ string, it will match the one which begins earliest. If both begin in
+ the same place but match different lengths, or match the same length in
+ different ways, life gets messier, as follows.
+
+ In general, the possibilities in a list of branches are considered in
+ left-to-right order, the possibilities for `*', `+', and `?' are consid-
+ ered longest-first, nested constructs are considered from the outermost
+ in, and concatenated constructs are considered leftmost-first. The match
+ that will be chosen is the one that uses the earliest possibility in the
+ first choice that has to be made. If there is more than one choice, the
+ next will be made in the same manner (earliest possibility) subject to
+ the decision on the first choice. And so forth.
+
+ For example, `(ab|a)b*c' could match `abc' in one of two ways. The first
+ choice is between `ab' and `a'; since `ab' is earlier, and does lead to a
+ successful overall match, it is chosen. Since the `b' is already spoken
+ for, the `b*' must match its last possibility--the empty string--since it
+ must respect the earlier choice.
+
+ In the particular case where no `|'s are present and there is only one
+ `*', `+', or `?', the net effect is that the longest possible match will
+ be chosen. So `ab*', presented with `xabbbby', will match `abbbb'. Note
+ that if `ab*', is tried against `xabyabbbz', it will match `ab' just af-
+ ter `x', due to the begins-earliest rule. (In effect, the decision on
+ where to start the match is the first choice to be made, hence subsequent
+ choices must respect it even if this leads them to less-preferred alter-
+ natives.)
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function returns NULL for a failure (r\bre\beg\bge\ber\brr\bro\bor\br() permit-
+ ting), where failures are syntax errors, exceeding implementation limits,
+ or applying `+' or `*' to a possibly-null operand.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ed(1), ex(1), expr(1), egrep(1), fgrep(1), grep(1), regex(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ Both code and manual page for r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and
+ r\bre\beg\bge\ber\brr\bro\bor\br() were written at the University of Toronto and appeared in
+ 4.3BSD-Tahoe. They are intended to be compatible with the Bell V8
+ regexp(3), but are not derived from Bell code.
+
+B\bBU\bUG\bGS\bS
+ Empty branches and empty regular expressions are not portable to V8.
+
+ The restriction against applying `*' or `+' to a possibly-null operand is
+ an artifact of the simplistic implementation.
+
+ Does not support egrep's newline-separated branches; neither does the V8
+ regexp(3), though.
+
+ Due to emphasis on compactness and simplicity, it's not strikingly fast.
+ It does give special attention to handling simple cases quickly.
+
+4.4BSD June 4, 1993 3
--- /dev/null
+REGEXP(3) BSD Programmer's Manual REGEXP(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\beg\bgc\bco\bom\bmp\bp, r\bre\beg\bge\bex\bxe\bec\bc, r\bre\beg\bgs\bsu\bub\bb, r\bre\beg\bge\ber\brr\bro\bor\br - regular expression handlers
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<r\bre\beg\bge\bex\bxp\bp.\b.h\bh>\b>
+
+ _\br_\be_\bg_\be_\bx_\bp _\b*
+ r\bre\beg\bgc\bco\bom\bmp\bp(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\bp);
+
+ _\bi_\bn_\bt
+ r\bre\beg\bge\bex\bxe\bec\bc(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bt_\br_\bi_\bn_\bg);
+
+ _\bv_\bo_\bi_\bd
+ r\bre\beg\bgs\bsu\bub\bb(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bo_\bu_\br_\bc_\be, _\bc_\bh_\ba_\br _\b*_\bd_\be_\bs_\bt);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This interface is made obsolete by regex(3).
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and r\bre\beg\bge\ber\brr\bro\bor\br() functions implement
+ egrep(1)-style regular expressions and supporting facilities.
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function compiles a regular expression into a structure of
+ type regexp, and returns a pointer to it. The space has been allocated
+ using malloc(3) and may be released by free.
+
+ The r\bre\beg\bge\bex\bxe\bec\bc() function matches a NUL-terminated _\bs_\bt_\br_\bi_\bn_\bg against the com-
+ piled regular expression in _\bp_\br_\bo_\bg. It returns 1 for success and 0 for
+ failure, and adjusts the contents of _\bp_\br_\bo_\bg's _\bs_\bt_\ba_\br_\bt_\bp and _\be_\bn_\bd_\bp (see below)
+ accordingly.
+
+ The members of a regexp structure include at least the following (not
+ necessarily in order):
+
+ char *startp[NSUBEXP];
+ char *endp[NSUBEXP];
+
+ where NSUBEXP is defined (as 10) in the header file. Once a successful
+ r\bre\beg\bge\bex\bxe\bec\bc() has been done using the r\bre\beg\bge\bex\bxp\bp(), each _\bs_\bt_\ba_\br_\bt_\bp- _\be_\bn_\bd_\bp pair de-
+ scribes one substring within the _\bs_\bt_\br_\bi_\bn_\bg, with the _\bs_\bt_\ba_\br_\bt_\bp pointing to the
+ first character of the substring and the _\be_\bn_\bd_\bp pointing to the first char-
+ acter following the substring. The 0th substring is the substring of
+ _\bs_\bt_\br_\bi_\bn_\bg that matched the whole regular expression. The others are those
+ substrings that matched parenthesized expressions within the regular ex-
+ pression, with parenthesized expressions numbered in left-to-right order
+ of their opening parentheses.
+
+ The r\bre\beg\bgs\bsu\bub\bb() function copies _\bs_\bo_\bu_\br_\bc_\be to _\bd_\be_\bs_\bt, making substitutions accord-
+ ing to the most recent r\bre\beg\bge\bex\bxe\bec\bc() performed using _\bp_\br_\bo_\bg. Each instance of
+ `&' in _\bs_\bo_\bu_\br_\bc_\be is replaced by the substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[] and
+ _\be_\bn_\bd_\bp[]. Each instance of `\_\bn', where _\bn is a digit, is replaced by the
+ substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[_\bn] and _\be_\bn_\bd_\bp[_\bn]. To get a literal `&' or
+ `\_\bn' into _\bd_\be_\bs_\bt, prefix it with `\'; to get a literal `\' preceding `&' or
+ `\_\bn', prefix it with another `\'.
+
+ The r\bre\beg\bge\ber\brr\bro\bor\br() function is called whenever an error is detected in
+ r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), or r\bre\beg\bgs\bsu\bub\bb(). The default r\bre\beg\bge\ber\brr\bro\bor\br() writes the
+ string _\bm_\bs_\bg, with a suitable indicator of origin, on the standard error
+ output and invokes exit(2). The r\bre\beg\bge\ber\brr\bro\bor\br() function can be replaced by
+ the user if other actions are desirable.
+
+R\bRE\bEG\bGU\bUL\bLA\bAR\bR E\bEX\bXP\bPR\bRE\bES\bSS\bSI\bIO\bON\bN S\bSY\bYN\bNT\bTA\bAX\bX
+ A regular expression is zero or more _\bb_\br_\ba_\bn_\bc_\bh_\be_\bs, separated by `|'. It
+ matches anything that matches one of the branches.
+
+ A branch is zero or more _\bp_\bi_\be_\bc_\be_\bs, concatenated. It matches a match for
+ the first, followed by a match for the second, etc.
+
+ A piece is an _\ba_\bt_\bo_\bm possibly followed by `*', `+', or `?'. An atom fol-
+ lowed by `*' matches a sequence of 0 or more matches of the atom. An
+ atom followed by `+' matches a sequence of 1 or more matches of the atom.
+ An atom followed by `?' matches a match of the atom, or the null string.
+
+ An atom is a regular expression in parentheses (matching a match for the
+ regular expression), a _\br_\ba_\bn_\bg_\be (see below), `.' (matching any single char-
+ acter), `^' (matching the null string at the beginning of the input
+ string), `$' (matching the null string at the end of the input string), a
+ `\' followed by a single character (matching that character), or a single
+ character with no other significance (matching that character).
+
+ A _\br_\ba_\bn_\bg_\be is a sequence of characters enclosed in `[]'. It normally match-
+ es any single character from the sequence. If the sequence begins with
+ `^', it matches any single character _\bn_\bo_\bt from the rest of the sequence.
+ If two characters in the sequence are separated by `-', this is shorthand
+ for the full list of ASCII characters between them (e.g. `[0-9]' matches
+ any decimal digit). To include a literal `]' in the sequence, make it
+ the first character (following a possible `^'). To include a literal
+ `-', make it the first or last character.
+
+A\bAM\bMB\bBI\bIG\bGU\bUI\bIT\bTY\bY
+ If a regular expression could match two different parts of the input
+ string, it will match the one which begins earliest. If both begin in
+ the same place but match different lengths, or match the same length in
+ different ways, life gets messier, as follows.
+
+ In general, the possibilities in a list of branches are considered in
+ left-to-right order, the possibilities for `*', `+', and `?' are consid-
+ ered longest-first, nested constructs are considered from the outermost
+ in, and concatenated constructs are considered leftmost-first. The match
+ that will be chosen is the one that uses the earliest possibility in the
+ first choice that has to be made. If there is more than one choice, the
+ next will be made in the same manner (earliest possibility) subject to
+ the decision on the first choice. And so forth.
+
+ For example, `(ab|a)b*c' could match `abc' in one of two ways. The first
+ choice is between `ab' and `a'; since `ab' is earlier, and does lead to a
+ successful overall match, it is chosen. Since the `b' is already spoken
+ for, the `b*' must match its last possibility--the empty string--since it
+ must respect the earlier choice.
+
+ In the particular case where no `|'s are present and there is only one
+ `*', `+', or `?', the net effect is that the longest possible match will
+ be chosen. So `ab*', presented with `xabbbby', will match `abbbb'. Note
+ that if `ab*', is tried against `xabyabbbz', it will match `ab' just af-
+ ter `x', due to the begins-earliest rule. (In effect, the decision on
+ where to start the match is the first choice to be made, hence subsequent
+ choices must respect it even if this leads them to less-preferred alter-
+ natives.)
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function returns NULL for a failure (r\bre\beg\bge\ber\brr\bro\bor\br() permit-
+ ting), where failures are syntax errors, exceeding implementation limits,
+ or applying `+' or `*' to a possibly-null operand.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ed(1), ex(1), expr(1), egrep(1), fgrep(1), grep(1), regex(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ Both code and manual page for r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and
+ r\bre\beg\bge\ber\brr\bro\bor\br() were written at the University of Toronto and appeared in
+ 4.3BSD-Tahoe. They are intended to be compatible with the Bell V8
+ regexp(3), but are not derived from Bell code.
+
+B\bBU\bUG\bGS\bS
+ Empty branches and empty regular expressions are not portable to V8.
+
+ The restriction against applying `*' or `+' to a possibly-null operand is
+ an artifact of the simplistic implementation.
+
+ Does not support egrep's newline-separated branches; neither does the V8
+ regexp(3), though.
+
+ Due to emphasis on compactness and simplicity, it's not strikingly fast.
+ It does give special attention to handling simple cases quickly.
+
+4.4BSD June 4, 1993 3
--- /dev/null
+REGEXP(3) BSD Programmer's Manual REGEXP(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\beg\bgc\bco\bom\bmp\bp, r\bre\beg\bge\bex\bxe\bec\bc, r\bre\beg\bgs\bsu\bub\bb, r\bre\beg\bge\ber\brr\bro\bor\br - regular expression handlers
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<r\bre\beg\bge\bex\bxp\bp.\b.h\bh>\b>
+
+ _\br_\be_\bg_\be_\bx_\bp _\b*
+ r\bre\beg\bgc\bco\bom\bmp\bp(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\bp);
+
+ _\bi_\bn_\bt
+ r\bre\beg\bge\bex\bxe\bec\bc(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bt_\br_\bi_\bn_\bg);
+
+ _\bv_\bo_\bi_\bd
+ r\bre\beg\bgs\bsu\bub\bb(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bo_\bu_\br_\bc_\be, _\bc_\bh_\ba_\br _\b*_\bd_\be_\bs_\bt);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This interface is made obsolete by regex(3).
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and r\bre\beg\bge\ber\brr\bro\bor\br() functions implement
+ egrep(1)-style regular expressions and supporting facilities.
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function compiles a regular expression into a structure of
+ type regexp, and returns a pointer to it. The space has been allocated
+ using malloc(3) and may be released by free.
+
+ The r\bre\beg\bge\bex\bxe\bec\bc() function matches a NUL-terminated _\bs_\bt_\br_\bi_\bn_\bg against the com-
+ piled regular expression in _\bp_\br_\bo_\bg. It returns 1 for success and 0 for
+ failure, and adjusts the contents of _\bp_\br_\bo_\bg's _\bs_\bt_\ba_\br_\bt_\bp and _\be_\bn_\bd_\bp (see below)
+ accordingly.
+
+ The members of a regexp structure include at least the following (not
+ necessarily in order):
+
+ char *startp[NSUBEXP];
+ char *endp[NSUBEXP];
+
+ where NSUBEXP is defined (as 10) in the header file. Once a successful
+ r\bre\beg\bge\bex\bxe\bec\bc() has been done using the r\bre\beg\bge\bex\bxp\bp(), each _\bs_\bt_\ba_\br_\bt_\bp- _\be_\bn_\bd_\bp pair de-
+ scribes one substring within the _\bs_\bt_\br_\bi_\bn_\bg, with the _\bs_\bt_\ba_\br_\bt_\bp pointing to the
+ first character of the substring and the _\be_\bn_\bd_\bp pointing to the first char-
+ acter following the substring. The 0th substring is the substring of
+ _\bs_\bt_\br_\bi_\bn_\bg that matched the whole regular expression. The others are those
+ substrings that matched parenthesized expressions within the regular ex-
+ pression, with parenthesized expressions numbered in left-to-right order
+ of their opening parentheses.
+
+ The r\bre\beg\bgs\bsu\bub\bb() function copies _\bs_\bo_\bu_\br_\bc_\be to _\bd_\be_\bs_\bt, making substitutions accord-
+ ing to the most recent r\bre\beg\bge\bex\bxe\bec\bc() performed using _\bp_\br_\bo_\bg. Each instance of
+ `&' in _\bs_\bo_\bu_\br_\bc_\be is replaced by the substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[] and
+ _\be_\bn_\bd_\bp[]. Each instance of `\_\bn', where _\bn is a digit, is replaced by the
+ substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[_\bn] and _\be_\bn_\bd_\bp[_\bn]. To get a literal `&' or
+ `\_\bn' into _\bd_\be_\bs_\bt, prefix it with `\'; to get a literal `\' preceding `&' or
+ `\_\bn', prefix it with another `\'.
+
+ The r\bre\beg\bge\ber\brr\bro\bor\br() function is called whenever an error is detected in
+ r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), or r\bre\beg\bgs\bsu\bub\bb(). The default r\bre\beg\bge\ber\brr\bro\bor\br() writes the
+ string _\bm_\bs_\bg, with a suitable indicator of origin, on the standard error
+ output and invokes exit(2). The r\bre\beg\bge\ber\brr\bro\bor\br() function can be replaced by
+ the user if other actions are desirable.
+
+R\bRE\bEG\bGU\bUL\bLA\bAR\bR E\bEX\bXP\bPR\bRE\bES\bSS\bSI\bIO\bON\bN S\bSY\bYN\bNT\bTA\bAX\bX
+ A regular expression is zero or more _\bb_\br_\ba_\bn_\bc_\bh_\be_\bs, separated by `|'. It
+ matches anything that matches one of the branches.
+
+ A branch is zero or more _\bp_\bi_\be_\bc_\be_\bs, concatenated. It matches a match for
+ the first, followed by a match for the second, etc.
+
+ A piece is an _\ba_\bt_\bo_\bm possibly followed by `*', `+', or `?'. An atom fol-
+ lowed by `*' matches a sequence of 0 or more matches of the atom. An
+ atom followed by `+' matches a sequence of 1 or more matches of the atom.
+ An atom followed by `?' matches a match of the atom, or the null string.
+
+ An atom is a regular expression in parentheses (matching a match for the
+ regular expression), a _\br_\ba_\bn_\bg_\be (see below), `.' (matching any single char-
+ acter), `^' (matching the null string at the beginning of the input
+ string), `$' (matching the null string at the end of the input string), a
+ `\' followed by a single character (matching that character), or a single
+ character with no other significance (matching that character).
+
+ A _\br_\ba_\bn_\bg_\be is a sequence of characters enclosed in `[]'. It normally match-
+ es any single character from the sequence. If the sequence begins with
+ `^', it matches any single character _\bn_\bo_\bt from the rest of the sequence.
+ If two characters in the sequence are separated by `-', this is shorthand
+ for the full list of ASCII characters between them (e.g. `[0-9]' matches
+ any decimal digit). To include a literal `]' in the sequence, make it
+ the first character (following a possible `^'). To include a literal
+ `-', make it the first or last character.
+
+A\bAM\bMB\bBI\bIG\bGU\bUI\bIT\bTY\bY
+ If a regular expression could match two different parts of the input
+ string, it will match the one which begins earliest. If both begin in
+ the same place but match different lengths, or match the same length in
+ different ways, life gets messier, as follows.
+
+ In general, the possibilities in a list of branches are considered in
+ left-to-right order, the possibilities for `*', `+', and `?' are consid-
+ ered longest-first, nested constructs are considered from the outermost
+ in, and concatenated constructs are considered leftmost-first. The match
+ that will be chosen is the one that uses the earliest possibility in the
+ first choice that has to be made. If there is more than one choice, the
+ next will be made in the same manner (earliest possibility) subject to
+ the decision on the first choice. And so forth.
+
+ For example, `(ab|a)b*c' could match `abc' in one of two ways. The first
+ choice is between `ab' and `a'; since `ab' is earlier, and does lead to a
+ successful overall match, it is chosen. Since the `b' is already spoken
+ for, the `b*' must match its last possibility--the empty string--since it
+ must respect the earlier choice.
+
+ In the particular case where no `|'s are present and there is only one
+ `*', `+', or `?', the net effect is that the longest possible match will
+ be chosen. So `ab*', presented with `xabbbby', will match `abbbb'. Note
+ that if `ab*', is tried against `xabyabbbz', it will match `ab' just af-
+ ter `x', due to the begins-earliest rule. (In effect, the decision on
+ where to start the match is the first choice to be made, hence subsequent
+ choices must respect it even if this leads them to less-preferred alter-
+ natives.)
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function returns NULL for a failure (r\bre\beg\bge\ber\brr\bro\bor\br() permit-
+ ting), where failures are syntax errors, exceeding implementation limits,
+ or applying `+' or `*' to a possibly-null operand.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ed(1), ex(1), expr(1), egrep(1), fgrep(1), grep(1), regex(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ Both code and manual page for r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and
+ r\bre\beg\bge\ber\brr\bro\bor\br() were written at the University of Toronto and appeared in
+ 4.3BSD-Tahoe. They are intended to be compatible with the Bell V8
+ regexp(3), but are not derived from Bell code.
+
+B\bBU\bUG\bGS\bS
+ Empty branches and empty regular expressions are not portable to V8.
+
+ The restriction against applying `*' or `+' to a possibly-null operand is
+ an artifact of the simplistic implementation.
+
+ Does not support egrep's newline-separated branches; neither does the V8
+ regexp(3), though.
+
+ Due to emphasis on compactness and simplicity, it's not strikingly fast.
+ It does give special attention to handling simple cases quickly.
+
+4.4BSD June 4, 1993 3
--- /dev/null
+REGEXP(3) BSD Programmer's Manual REGEXP(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\beg\bgc\bco\bom\bmp\bp, r\bre\beg\bge\bex\bxe\bec\bc, r\bre\beg\bgs\bsu\bub\bb, r\bre\beg\bge\ber\brr\bro\bor\br - regular expression handlers
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<r\bre\beg\bge\bex\bxp\bp.\b.h\bh>\b>
+
+ _\br_\be_\bg_\be_\bx_\bp _\b*
+ r\bre\beg\bgc\bco\bom\bmp\bp(_\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\be_\bx_\bp);
+
+ _\bi_\bn_\bt
+ r\bre\beg\bge\bex\bxe\bec\bc(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bt_\br_\bi_\bn_\bg);
+
+ _\bv_\bo_\bi_\bd
+ r\bre\beg\bgs\bsu\bub\bb(_\bc_\bo_\bn_\bs_\bt _\br_\be_\bg_\be_\bx_\bp _\b*_\bp_\br_\bo_\bg, _\bc_\bo_\bn_\bs_\bt _\bc_\bh_\ba_\br _\b*_\bs_\bo_\bu_\br_\bc_\be, _\bc_\bh_\ba_\br _\b*_\bd_\be_\bs_\bt);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ This interface is made obsolete by regex(3).
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and r\bre\beg\bge\ber\brr\bro\bor\br() functions implement
+ egrep(1)-style regular expressions and supporting facilities.
+
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function compiles a regular expression into a structure of
+ type regexp, and returns a pointer to it. The space has been allocated
+ using malloc(3) and may be released by free.
+
+ The r\bre\beg\bge\bex\bxe\bec\bc() function matches a NUL-terminated _\bs_\bt_\br_\bi_\bn_\bg against the com-
+ piled regular expression in _\bp_\br_\bo_\bg. It returns 1 for success and 0 for
+ failure, and adjusts the contents of _\bp_\br_\bo_\bg's _\bs_\bt_\ba_\br_\bt_\bp and _\be_\bn_\bd_\bp (see below)
+ accordingly.
+
+ The members of a regexp structure include at least the following (not
+ necessarily in order):
+
+ char *startp[NSUBEXP];
+ char *endp[NSUBEXP];
+
+ where NSUBEXP is defined (as 10) in the header file. Once a successful
+ r\bre\beg\bge\bex\bxe\bec\bc() has been done using the r\bre\beg\bge\bex\bxp\bp(), each _\bs_\bt_\ba_\br_\bt_\bp- _\be_\bn_\bd_\bp pair de-
+ scribes one substring within the _\bs_\bt_\br_\bi_\bn_\bg, with the _\bs_\bt_\ba_\br_\bt_\bp pointing to the
+ first character of the substring and the _\be_\bn_\bd_\bp pointing to the first char-
+ acter following the substring. The 0th substring is the substring of
+ _\bs_\bt_\br_\bi_\bn_\bg that matched the whole regular expression. The others are those
+ substrings that matched parenthesized expressions within the regular ex-
+ pression, with parenthesized expressions numbered in left-to-right order
+ of their opening parentheses.
+
+ The r\bre\beg\bgs\bsu\bub\bb() function copies _\bs_\bo_\bu_\br_\bc_\be to _\bd_\be_\bs_\bt, making substitutions accord-
+ ing to the most recent r\bre\beg\bge\bex\bxe\bec\bc() performed using _\bp_\br_\bo_\bg. Each instance of
+ `&' in _\bs_\bo_\bu_\br_\bc_\be is replaced by the substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[] and
+ _\be_\bn_\bd_\bp[]. Each instance of `\_\bn', where _\bn is a digit, is replaced by the
+ substring indicated by _\bs_\bt_\ba_\br_\bt_\bp[_\bn] and _\be_\bn_\bd_\bp[_\bn]. To get a literal `&' or
+ `\_\bn' into _\bd_\be_\bs_\bt, prefix it with `\'; to get a literal `\' preceding `&' or
+ `\_\bn', prefix it with another `\'.
+
+ The r\bre\beg\bge\ber\brr\bro\bor\br() function is called whenever an error is detected in
+ r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), or r\bre\beg\bgs\bsu\bub\bb(). The default r\bre\beg\bge\ber\brr\bro\bor\br() writes the
+ string _\bm_\bs_\bg, with a suitable indicator of origin, on the standard error
+ output and invokes exit(2). The r\bre\beg\bge\ber\brr\bro\bor\br() function can be replaced by
+ the user if other actions are desirable.
+
+R\bRE\bEG\bGU\bUL\bLA\bAR\bR E\bEX\bXP\bPR\bRE\bES\bSS\bSI\bIO\bON\bN S\bSY\bYN\bNT\bTA\bAX\bX
+ A regular expression is zero or more _\bb_\br_\ba_\bn_\bc_\bh_\be_\bs, separated by `|'. It
+ matches anything that matches one of the branches.
+
+ A branch is zero or more _\bp_\bi_\be_\bc_\be_\bs, concatenated. It matches a match for
+ the first, followed by a match for the second, etc.
+
+ A piece is an _\ba_\bt_\bo_\bm possibly followed by `*', `+', or `?'. An atom fol-
+ lowed by `*' matches a sequence of 0 or more matches of the atom. An
+ atom followed by `+' matches a sequence of 1 or more matches of the atom.
+ An atom followed by `?' matches a match of the atom, or the null string.
+
+ An atom is a regular expression in parentheses (matching a match for the
+ regular expression), a _\br_\ba_\bn_\bg_\be (see below), `.' (matching any single char-
+ acter), `^' (matching the null string at the beginning of the input
+ string), `$' (matching the null string at the end of the input string), a
+ `\' followed by a single character (matching that character), or a single
+ character with no other significance (matching that character).
+
+ A _\br_\ba_\bn_\bg_\be is a sequence of characters enclosed in `[]'. It normally match-
+ es any single character from the sequence. If the sequence begins with
+ `^', it matches any single character _\bn_\bo_\bt from the rest of the sequence.
+ If two characters in the sequence are separated by `-', this is shorthand
+ for the full list of ASCII characters between them (e.g. `[0-9]' matches
+ any decimal digit). To include a literal `]' in the sequence, make it
+ the first character (following a possible `^'). To include a literal
+ `-', make it the first or last character.
+
+A\bAM\bMB\bBI\bIG\bGU\bUI\bIT\bTY\bY
+ If a regular expression could match two different parts of the input
+ string, it will match the one which begins earliest. If both begin in
+ the same place but match different lengths, or match the same length in
+ different ways, life gets messier, as follows.
+
+ In general, the possibilities in a list of branches are considered in
+ left-to-right order, the possibilities for `*', `+', and `?' are consid-
+ ered longest-first, nested constructs are considered from the outermost
+ in, and concatenated constructs are considered leftmost-first. The match
+ that will be chosen is the one that uses the earliest possibility in the
+ first choice that has to be made. If there is more than one choice, the
+ next will be made in the same manner (earliest possibility) subject to
+ the decision on the first choice. And so forth.
+
+ For example, `(ab|a)b*c' could match `abc' in one of two ways. The first
+ choice is between `ab' and `a'; since `ab' is earlier, and does lead to a
+ successful overall match, it is chosen. Since the `b' is already spoken
+ for, the `b*' must match its last possibility--the empty string--since it
+ must respect the earlier choice.
+
+ In the particular case where no `|'s are present and there is only one
+ `*', `+', or `?', the net effect is that the longest possible match will
+ be chosen. So `ab*', presented with `xabbbby', will match `abbbb'. Note
+ that if `ab*', is tried against `xabyabbbz', it will match `ab' just af-
+ ter `x', due to the begins-earliest rule. (In effect, the decision on
+ where to start the match is the first choice to be made, hence subsequent
+ choices must respect it even if this leads them to less-preferred alter-
+ natives.)
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The r\bre\beg\bgc\bco\bom\bmp\bp() function returns NULL for a failure (r\bre\beg\bge\ber\brr\bro\bor\br() permit-
+ ting), where failures are syntax errors, exceeding implementation limits,
+ or applying `+' or `*' to a possibly-null operand.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ed(1), ex(1), expr(1), egrep(1), fgrep(1), grep(1), regex(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ Both code and manual page for r\bre\beg\bgc\bco\bom\bmp\bp(), r\bre\beg\bge\bex\bxe\bec\bc(), r\bre\beg\bgs\bsu\bub\bb(), and
+ r\bre\beg\bge\ber\brr\bro\bor\br() were written at the University of Toronto and appeared in
+ 4.3BSD-Tahoe. They are intended to be compatible with the Bell V8
+ regexp(3), but are not derived from Bell code.
+
+B\bBU\bUG\bGS\bS
+ Empty branches and empty regular expressions are not portable to V8.
+
+ The restriction against applying `*' or `+' to a possibly-null operand is
+ an artifact of the simplistic implementation.
+
+ Does not support egrep's newline-separated branches; neither does the V8
+ regexp(3), though.
+
+ Due to emphasis on compactness and simplicity, it's not strikingly fast.
+ It does give special attention to handling simple cases quickly.
+
+4.4BSD June 4, 1993 3
--- /dev/null
+INSQUE(3) BSD Programmer's Manual INSQUE(3)
+
+N\bNA\bAM\bME\bE
+ i\bin\bns\bsq\bqu\bue\be, r\bre\bem\bmq\bqu\bue\be - insert/remove element from a queue
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ struct qelem {
+ struct qelem *q_forw;
+ struct qelem *q_back;
+ char q_data[];
+ };
+
+ i\bin\bns\bsq\bqu\bue\be(_\b(_\bc_\ba_\bd_\bd_\br_\b__\bt_\b) _\bs_\bt_\br_\bu_\bc_\bt _\bq_\be_\bl_\be_\bm _\b*_\be_\bl_\be_\bm, _\b(_\bc_\ba_\bd_\bd_\br_\b__\bt_\b) _\bs_\bt_\br_\bu_\bc_\bt _\bq_\be_\bl_\be_\bm _\b*_\bp_\br_\be_\bd);
+
+ r\bre\bem\bmq\bqu\bue\be(_\b(_\bc_\ba_\bd_\bd_\br_\b__\bt_\b) _\bs_\bt_\br_\bu_\bc_\bt _\bq_\be_\bl_\be_\bm _\b*_\be_\bl_\be_\bm);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The i\bin\bns\bsq\bqu\bue\be() and r\bre\bem\bmq\bqu\bue\be() functions manipulate queues built from doubly
+ linked lists. Each element in the queue must in the form of ``struct
+ qelem''. The function i\bin\bns\bsq\bqu\bue\be() inserts _\be_\bl_\be_\bm in a queue immediately after
+ _\bp_\br_\be_\bd; r\bre\bem\bmq\bqu\bue\be() removes an entry _\be_\bl_\be_\bm from a queue.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ _\bV_\bA_\bX _\bA_\br_\bc_\bh_\bi_\bt_\be_\bc_\bt_\bu_\br_\be _\bH_\ba_\bn_\bd_\bb_\bo_\bo_\bk, pp. 228-235.
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bin\bns\bsq\bqu\bue\be() and r\bre\bem\bmq\bqu\bue\be() functions appeared in 4.2BSD.
+
+4.2 Berkeley Distribution June 4, 1993 1
--- /dev/null
+REXEC(3) BSD Programmer's Manual REXEC(3)
+
+N\bNA\bAM\bME\bE
+ r\bre\bex\bxe\bec\bc - return stream to a remote command
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ _\bi_\bn_\bt
+ r\bre\bex\bxe\bec\bc(_\ba_\bh_\bo_\bs_\bt, _\bi_\bn_\bt _\bi_\bn_\bp_\bo_\br_\bt, _\bc_\bh_\ba_\br _\b*_\bu_\bs_\be_\br, _\bc_\bh_\ba_\br _\b*_\bp_\ba_\bs_\bs_\bw_\bd, _\bc_\bh_\ba_\br _\b*_\bc_\bm_\bd, _\bi_\bn_\bt _\b*_\bf_\bd_\b2_\bp);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhi\bis\bs i\bin\bnt\bte\ber\brf\bfa\bac\bce\be i\bis\bs o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by k\bkr\brc\bcm\bmd\bd(\b(3\b3)\b).\b. I\bIt\bt i\bis\bs a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be c\bco\bom\bm-\b-
+ p\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ The r\bre\bex\bxe\bec\bc() function looks up the host _\b*_\ba_\bh_\bo_\bs_\bt using gethostbyname(3),
+ returning -1 if the host does not exist. Otherwise _\b*_\ba_\bh_\bo_\bs_\bt is set to the
+ standard name of the host. If a username and password are both speci-
+ fied, then these are used to authenticate to the foreign host; otherwise
+ the environment and then the user's _\b._\bn_\be_\bt_\br_\bc file in his home directory are
+ searched for appropriate information. If all this fails, the user is
+ prompted for the information.
+
+ The port _\bi_\bn_\bp_\bo_\br_\bt specifies which well-known DARPA Internet port to use for
+ the connection; the call `getservbyname("exec", "tcp")' (see
+ getservent(3)) will return a pointer to a structure, which contains the
+ necessary port. The protocol for connection is described in detail in
+ rexecd(8).
+
+ If the connection succeeds, a socket in the Internet domain of type
+ SOCK_STREAM is returned to the caller, and given to the remote command as
+ _\bs_\bt_\bd_\bi_\bn and _\bs_\bt_\bd_\bo_\bu_\bt. If _\bf_\bd_\b2_\bp is non-zero, then an auxiliary channel to a
+ control process will be setup, and a descriptor for it will be placed in
+ _\b*_\bf_\bd_\b2_\bp. The control process will return diagnostic output from the command
+ (unit 2) on this channel, and will also accept bytes on this channel as
+ being UNIX signal numbers, to be forwarded to the process group of the
+ command. The diagnostic information returned does not include remote au-
+ thorization failure, as the secondary connection is set up after autho-
+ rization has been verified. If _\bf_\bd_\b2_\bp is 0, then the _\bs_\bt_\bd_\be_\br_\br (unit 2 of the
+ remote command) will be made the same as the _\bs_\bt_\bd_\bo_\bu_\bt and no provision is
+ made for sending arbitrary signals to the remote process, although you
+ may be able to get its attention by using out-of-band data.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ rcmd(3), rexecd(8)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The r\bre\bex\bxe\bec\bc() function appeared in 4.2BSD.
+
+4.2 Berkeley Distribution June 4, 1993 1
--- /dev/null
+RINT(3) BSD Programmer's Manual RINT(3)
+
+N\bNA\bAM\bME\bE
+ r\bri\bin\bnt\bt - and round-to-closest integer functions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ r\bri\bin\bnt\bt(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The r\bri\bin\bnt\bt() function finds the integer (represented as a double precision
+ number) nearest to _\bx in the direction of the prevailing rounding mode.
+
+N\bNO\bOT\bTE\bES\bS
+ On a VAX, r\bri\bin\bnt\bt(_\bx) is equivalent to adding half to the magnitude and then
+ rounding towards zero.
+
+ In the default rounding mode, to nearest, on a machine that conforms to
+ IEEE 754, r\bri\bin\bnt\bt(_\bx) is the integer nearest _\bx with the additional stipula-
+ tion that if |rint(x)-x|=1/2 then r\bri\bin\bnt\bt(_\bx) is even. Other rounding modes
+ can make r\bri\bin\bnt\bt() act like f\bfl\blo\boo\bor\br(), or like c\bce\bei\bil\bl(), or round towards zero.
+
+ Another way to obtain an integer near _\bx is to declare (in C)
+
+ double x; int k; k = x;
+
+ Most C compilers round _\bx towards 0 to get the integer _\bk, but some do oth-
+ erwise. If in doubt, use f\bfl\blo\boo\bor\br(), c\bce\bei\bil\bl(), or r\bri\bin\bnt\bt() first, whichever you
+ intend. Also note that, if x is larger than _\bk can accommodate, the value
+ of _\bk and the presence or absence of an integer overflow are hard to pre-
+ dict.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ abs(3), fabs(3), ceil(3), floor(3), ieee(3), math(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A r\bri\bin\bnt\bt() function appeared in Version 6 AT&T UNIX.
+
+4.4BSD June 4, 1993 1
--- /dev/null
+IEEE(3) BSD Programmer's Manual IEEE(3)
+
+N\bNA\bAM\bME\bE
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn, d\bdr\bre\bem\bm, f\bfi\bin\bni\bit\bte\be, l\blo\bog\bgb\bb, s\bsc\bca\bal\blb\bb - IEEE 754 floating point support
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ d\bdr\bre\bem\bm(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bd_\bo_\bu_\bb_\bl_\be _\by);
+
+ _\bi_\bn_\bt
+ f\bfi\bin\bni\bit\bte\be(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ l\blo\bog\bgb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsc\bca\bal\blb\bb(_\bd_\bo_\bu_\bb_\bl_\be _\bx, _\bi_\bn_\bt _\bn);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ These functions are required for, or recommended by the IEEE standard 754
+ for floating-point arithmetic.
+
+ The c\bco\bop\bpy\bys\bsi\big\bgn\bn() function returns _\bx with its sign changed to _\by's.
+
+ The d\bdr\bre\bem\bm() function returns the remainder _\br := _\bx - _\bn_\b*_\by where _\bn is the in-
+ teger nearest the exact value of _\bx/_\by; moreover if |_\bn - _\bx/_\by| = 1/2 then _\bn
+ is even. Consequently the remainder is computed exactly and |_\br| <=
+ |_\by|/2. But d\bdr\bre\bem\bm(_\bx, _\b0) is exceptional. (See below under _\bD_\bI_\bA_\bG_\bN_\bO_\bS_\bT_\bI_\bC_\bS.)
+
+ The f\bfi\bin\bni\bit\bte\be() function returns the value 1 just when -infinity < _\bx < +in-
+ finity; otherwise a zero is returned (when |_\bx| = infinity or _\bx is _\bN_\ba_\bN or
+ is the VAX's reserved operand).
+
+ The l\blo\bog\bgb\bb() function returns _\bx's exponent _\bn, a signed integer converted to
+ double-precision floating-point and so chosen that 1 (<= |_\bx|2**_\bn < 2 un-
+ less _\bx = 0 or (only on machines that conform to IEEE 754) |_\bx| = infinity
+ or _\bx lies between 0 and the Underflow Threshold. (See below under _\bB_\bU_\bG_\bS.)
+
+ The s\bsc\bca\bal\blb\bb() function returns _\bx*(2**_\bn) computed, for integer n, without
+ first computing 2*_\bn.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The IEEE standard 754 defines d\bdr\bre\bem\bm(_\bx, _\b0) and d\bdr\bre\bem\bm(_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by, _\by) to be in-
+ valid operations that produce a _\bN_\ba_\bN. On the VAX, d\bdr\bre\bem\bm(_\bx, _\b0) generates a
+ reserved operand fault. No infinity exists on a VAX.
+
+ IEEE 754 defines l\blo\bog\bgb\bb(_\b+_\b-_\bi_\bn_\bf_\bi_\bn_\bi_\bt_\by) = infinity and l\blo\bog\bgb\bb(_\b0) = -infinity, and
+ requires the latter to signal Division-by-Zero. But on a VAX, l\blo\bog\bgb\bb(_\b0) =
+ 1.0 - 2.0**31 = -2,147,483,647.0. And if the correct value of s\bsc\bca\bal\blb\bb()
+ would overflow on a VAX, it generates a reserved operand fault and sets
+ the global variable _\be_\br_\br_\bn_\bo to ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ floor(3), math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The i\bie\bee\bee\be functions appeared in 4.3BSD.
+
+B\bBU\bUG\bGS\bS
+ Should d\bdr\bre\bem\bm(_\bx, _\b0) and l\blo\bog\bgb\bb(_\b0) on a VAX signal invalidity by setting _\be_\br_\br_\bn_\bo
+ = EDOM ? Should l\blo\bog\bgb\bb(_\b0) return -1.7e38?
+
+ IEEE 754 currently specifies that l\blo\bog\bgb\bb(_\bd_\be_\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b.) = l\blo\bog\bgb\bb(_\bt_\bi_\bn_\bi_\be_\bs_\bt
+ _\bn_\bo_\br_\bm_\ba_\bl_\bi_\bz_\be_\bd _\bn_\bo_\b. _\b> _\b0) but the consensus has changed to the specification in
+ the new proposed IEEE standard p854, namely that l\blo\bog\bgb\bb(_\bx) satisfy
+
+ 1 <= s\bsc\bca\bal\blb\bb(|_\bx|, _\b-_\bl_\bo_\bg_\bb_\b(_\bx_\b)) < Radix ... = 2 for IEEE 754
+
+ for every x except 0, infinity and _\bN_\ba_\bN. Almost every program that as-
+ sumes 754's specification will work correctly if l\blo\bog\bgb\bb() follows 854's
+ specification instead.
+
+ IEEE 754 requires c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\bN_\ba_\bN_\b)) = +-_\bx but says nothing else about the
+ sign of a _\bN_\ba_\bN. A _\bN_\ba_\bN _\b(_\bNot _\ba _\bNumber) is similar in spirit to the VAX's
+ reserved operand, but very different in important details. Since the
+ sign bit of a reserved operand makes it look negative,
+
+ c\bco\bop\bpy\bys\bsi\big\bgn\bn(_\bx, _\br_\be_\bs_\be_\br_\bv_\be_\bd _\bo_\bp_\be_\br_\ba_\bn_\bd) = -_\bx;
+
+ should this return the reserved operand instead?
+
+4.3 Berkeley Distribution June 4, 1993 2
--- /dev/null
+SIN(3) BSD Programmer's Manual SIN(3)
+
+N\bNA\bAM\bME\bE
+ s\bsi\bin\bn - sine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsi\bin\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The s\bsi\bin\bn() function computes the sine of _\bx (measured in radians). A large
+ magnitude argument may yield a result with little or no significance.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The s\bsi\bin\bn() function returns the sine value.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), asin(3), atan(3), atan2(3), cos(3), cosh(3), sinh(3),
+ tan(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The s\bsi\bin\bn() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+SINH(3) BSD Programmer's Manual SINH(3)
+
+N\bNA\bAM\bME\bE
+ s\bsi\bin\bnh\bh - hyperbolic sine function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsi\bin\bnh\bh(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The s\bsi\bin\bnh\bh() function computes the hyperbolic sine of _\bx.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The s\bsi\bin\bnh\bh() function returns the hyperbolic sine value unless the magni-
+ tude of _\bx is too large; in this event, the global variable _\be_\br_\br_\bn_\bo is set
+ to ERANGE.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), asin(3), atan(3), atan2(3), cos(3), cosh(3), sin(3),
+ tan(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The s\bsi\bin\bnh\bh() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+SQRT(3) BSD Programmer's Manual SQRT(3)
+
+N\bNA\bAM\bME\bE
+ c\bcb\bbr\brt\bt, s\bsq\bqr\brt\bt - cube root and square root functions
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ c\bcb\bbr\brt\bt(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ s\bsq\bqr\brt\bt(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The c\bcb\bbr\brt\bt() function computes the cube root of _\bx.
+
+ The s\bsq\bqr\brt\bt() computes the non-negative square root of x.
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The c\bcb\bbr\brt\bt() function returns the requested cube root. The s\bsq\bqr\brt\bt() function
+ returns the requested square root unless an error occurs. On the VAX or
+ Tahoe processor an attempt to take the s\bsq\bqr\brt\bt() of negative _\bx causes an er-
+ ror; in this event, the global variable _\be_\br_\br_\bn_\bo is set to EDOM and a re-
+ served operand fault is generated.
+
+E\bER\bRR\bRO\bOR\bR (\b(d\bdu\bue\be t\bto\bo R\bRo\bou\bun\bnd\bdo\bof\bff\bf e\bet\btc\bc.\b.)\b)
+ The c\bcb\bbr\brt\bt() function is accurate to within 0.7 _\bu_\bl_\bp_\bs.
+
+ The s\bsq\bqr\brt\bt() function on a VAX is accurate to within 0.501 _\bu_\bl_\bp_\bs. Sqrt on a
+ machine that conforms to IEEE 754 is correctly rounded in accordance with
+ the rounding mode in force; the error is less than half an _\bu_\bl_\bp in the de-
+ fault mode (round-to-nearest). An _\bu_\bl_\bp is one _\bUnit in the _\bLast _\bPlace car-
+ ried.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The s\bsq\bqr\brt\bt function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The c\bcb\bbr\brt\bt function appeared in 4.3BSD.
+
+4.4BSD June 4, 1993 1
--- /dev/null
+STTY(3) BSD Programmer's Manual STTY(3)
+
+N\bNA\bAM\bME\bE
+ s\bst\btt\bty\by, g\bgt\btt\bty\by - set and get terminal state (defunct)
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsg\bgt\btt\bty\by.\b.h\bh>\b>
+
+ s\bst\btt\bty\by(_\bi_\bn_\bt _\bf_\bd, _\bs_\bt_\br_\bu_\bc_\bt _\bs_\bg_\bt_\bt_\by_\bb _\b*_\bb_\bu_\bf);
+
+ g\bgt\btt\bty\by(_\bi_\bn_\bt _\bf_\bd, _\bs_\bt_\br_\bu_\bc_\bt _\bs_\bg_\bt_\bt_\by_\bb _\b*_\bb_\bu_\bf);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhe\bes\bse\be i\bin\bnt\bte\ber\brf\bfa\bac\bce\bes\bs a\bar\bre\be o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by i\bio\boc\bct\btl\bl(\b(2\b2)\b).\b. T\bTh\bhe\bey\by a\bar\bre\be a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be
+ c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ The s\bst\btt\bty\by() function sets the state of the terminal associated with _\bf_\bd.
+ The g\bgt\btt\bty\by() function retrieves the state of the terminal associated with
+ _\bf_\bd. To set the state of a terminal the call must have write permission.
+
+ The s\bst\btt\bty\by() call is actually `ioctl(fd, TIOCSETP, buf)', while the g\bgt\btt\bty\by()
+ call is `ioctl(fd, TIOCGETP, buf)'. See ioctl(2) and tty(4) for an expla-
+ nation.
+
+D\bDI\bIA\bAG\bGN\bNO\bOS\bST\bTI\bIC\bCS\bS
+ If the call is successful 0 is returned, otherwise -1 is returned and the
+ global variable _\be_\br_\br_\bn_\bo contains the reason for the failure.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ ioctl(2), tty(4)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The s\bst\btt\bty\by() and g\bgt\btt\bty\by() functions appeared in 4.2BSD.
+
+4.2 Berkeley Distribution June 4, 1993 1
--- /dev/null
+TAN(3) BSD Programmer's Manual TAN(3)
+
+N\bNA\bAM\bME\bE
+ t\bta\ban\bn - tangent function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ t\bta\ban\bn(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The t\bta\ban\bn() function computes the tangent of _\bx (measured in radians). A
+ large magnitude argument may yield a result with little or no signifi-
+ cance. For a discussion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The t\bta\ban\bn() function returns the tangent value.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), asin(3), atan(3), atan2(3), cos(3), cosh(3), sin(3),
+ sinh(3), tanh(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The t\bta\ban\bn() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+TANH(3) BSD Programmer's Manual TANH(3)
+
+N\bNA\bAM\bME\bE
+ t\bta\ban\bnh\bh - hyperbolic tangent function
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ t\bta\ban\bnh\bh(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The t\bta\ban\bnh\bh() function computes the hyperbolic tangent of _\bx. For a discus-
+ sion of error due to roundoff, see math(3).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ The t\bta\ban\bnh\bh() function returns the hyperbolic tangent value.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ acos(3), asin(3), atan(3), atan2(3), cos(3), cosh(3), sin(3),
+ sinh(3), tan(3), math(3),
+
+S\bST\bTA\bAN\bND\bDA\bAR\bRD\bDS\bS
+ The t\bta\ban\bnh\bh() function conforms to ANSI C X3.159-1989 (``ANSI C '').
+
+4.4BSD June 4, 1993 1
--- /dev/null
+VLIMIT(3) BSD Programmer's Manual VLIMIT(3)
+
+N\bNA\bAM\bME\bE
+ v\bvl\bli\bim\bmi\bit\bt - control maximum system resource consumption
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/v\bvl\bli\bim\bmi\bit\bt.\b.h\bh>\b>
+
+ v\bvl\bli\bim\bmi\bit\bt(_\br_\be_\bs_\bo_\bu_\br_\bc_\be, _\bv_\ba_\bl_\bu_\be);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhi\bis\bs i\bin\bnt\bte\ber\brf\bfa\bac\bce\be i\bis\bs o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by g\bge\bet\btr\brl\bli\bim\bmi\bit\bt(\b(2\b2)\b).\b. I\bIt\bt i\bis\bs a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be
+ c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ Limits the consumption by the current process and each process it creates
+ to not individually exceed _\bv_\ba_\bl_\bu_\be on the specified _\br_\be_\bs_\bo_\bu_\br_\bc_\be. If _\bv_\ba_\bl_\bu_\be is
+ specified as -1, then the current limit is returned and the limit is un-
+ changed. The resources which are currently controllable are:
+
+ LIM_NORAISE A pseudo-limit; if set non-zero then the limits may not be
+ raised. Only the super-user may remove the _\bn_\bo_\br_\ba_\bi_\bs_\be restric-
+ tion.
+
+ LIM_CPU the maximum number of cpu-seconds to be used by each process
+
+ LIM_FSIZE the largest single file which can be created
+
+ LIM_DATA the maximum growth of the data+stack region via sbrk(2) be-
+ yond the end of the program text
+
+ LIM_STACK the maximum size of the automatically-extended stack region
+
+ LIM_CORE the size of the largest core dump that will be created.
+
+ LIM_MAXRSS a soft limit for the amount of physical memory (in bytes) to
+ be given to the program. If memory is tight, the system
+ will prefer to take memory from processes which are exceed-
+ ing their declared LIM_MAXRSS.
+
+ Because this information is stored in the per-process information this
+ system call must be executed directly by the shell if it is to affect all
+ future processes created by the shell; limit is thus a built-in command
+ to csh(1).
+
+ The system refuses to extend the data or stack space when the limits
+ would be exceeded in the normal way; a break(2) call fails if the data
+ space limit is reached, or the process is killed when the stack limit is
+ reached (since the stack cannot be extended, there is no way to send a
+ signal!).
+
+ A file I/O operation which would create a file which is too large will
+ cause a signal SIGXFSZ to be generated, this normally terminates the pro-
+ cess, but may be caught. When the cpu time limit is exceeded, a signal
+ SIGXCPU is sent to the offending process; to allow it time to process the
+ signal it is given 5 seconds grace by raising the CPU time limit.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ csh(1)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The v\bvl\bli\bim\bmi\bit\bt() function appeared in 4.2BSD.
+
+B\bBU\bUG\bGS\bS
+ LIM_NORAISE no longer exists.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+VTIMES(3) BSD Programmer's Manual VTIMES(3)
+
+N\bNA\bAM\bME\bE
+ v\bvt\bti\bim\bme\bes\bs - get information about resource utilization
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<s\bsy\bys\bs/\b/v\bvt\bti\bim\bme\bes\bs.\b.h\bh>\b>
+
+ v\bvt\bti\bim\bme\bes\bs(_\bs_\bt_\br_\bu_\bc_\bt _\bv_\bt_\bi_\bm_\be_\bs _\b*_\bp_\ba_\br_\b__\bv_\bm, _\bs_\bt_\br_\bu_\bc_\bt _\bv_\bt_\bi_\bm_\be_\bs _\b*_\bc_\bh_\b__\bv_\bm);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ T\bTh\bhi\bis\bs i\bin\bnt\bte\ber\brf\bfa\bac\bce\be i\bis\bs o\bob\bbs\bso\bol\ble\bet\bte\bed\bd b\bby\by g\bge\bet\btr\bru\bus\bsa\bag\bge\be(\b(2\b2)\b).\b. I\bIt\bt i\bis\bs a\bav\bva\bai\bil\bla\bab\bbl\ble\be f\bfr\bro\bom\bm t\bth\bhe\be
+ c\bco\bom\bmp\bpa\bat\bti\bib\bbi\bil\bli\bit\bty\by l\bli\bib\bbr\bra\bar\bry\by,\b, l\bli\bib\bbc\bco\bom\bmp\bpa\bat\bt.\b.
+
+ The v\bvt\bti\bim\bme\bes\bs() function returns accounting information for the current pro-
+ cess and for the terminated child processes of the current process. Ei-
+ ther _\bp_\ba_\br_\b__\bv_\bm or _\bc_\bh_\b__\bv_\bm or both may be 0, in which case only the information
+ for the pointers which are non-zero is returned.
+
+ After the call, each buffer contains information as defined by the con-
+ tents of the include file _\b/_\bu_\bs_\br_\b/_\bi_\bn_\bc_\bl_\bu_\bd_\be_\b/_\bs_\by_\bs_\b/_\bv_\bt_\bi_\bm_\be_\bs_\b._\bh:
+
+ struct vtimes {
+ int vm_utime; /* user time (*HZ) */
+ int vm_stime; /* system time (*HZ) */
+ /* divide next two by utime+stime to get averages */
+ unsigned vm_idsrss; /* integral of d+s rss */
+ unsigned vm_ixrss; /* integral of text rss */
+ int vm_maxrss; /* maximum rss */
+ int vm_majflt; /* major page faults */
+ int vm_minflt; /* minor page faults */
+ int vm_nswap; /* number of swaps */
+ int vm_inblk; /* block reads */
+ int vm_oublk; /* block writes */
+ };
+
+ The _\bv_\bm_\b__\bu_\bt_\bi_\bm_\be and _\bv_\bm_\b__\bs_\bt_\bi_\bm_\be fields give the user and system time respec-
+ tively in 60ths of a second (or 50ths if that is the frequency of wall
+ current in your locality.) The _\bv_\bm_\b__\bi_\bd_\br_\bs_\bs and _\bv_\bm_\b__\bi_\bx_\br_\bs_\bs measure memory us-
+ age. They are computed by integrating the number of memory pages in use
+ each over CPU time. They are reported as though computed discretely,
+ adding the current memory usage (in 512 byte pages) each time the clock
+ ticks. If a process used 5 core pages over 1 cpu-second for its data and
+ stack, then _\bv_\bm_\b__\bi_\bd_\bs_\br_\bs_\bs would have the value 5*60, where _\bv_\bm_\b__\bu_\bt_\bi_\bm_\be_\b+_\bv_\bm_\b__\bs_\bt_\bi_\bm_\be
+ would be the 60. The _\bV_\bm_\b__\bi_\bd_\bs_\br_\bs_\bs argument integrates data and stack seg-
+ ment usage, while _\bv_\bm_\b__\bi_\bx_\br_\bs_\bs integrates text segment usage. The _\bV_\bm_\b__\bm_\ba_\bx_\br_\bs_\bs
+ function reports the maximum instantaneous sum of the text+data+stack
+ core-resident page count.
+
+ The _\bv_\bm_\b__\bm_\ba_\bj_\bf_\bl_\bt field gives the number of page faults which resulted in
+ disk activity; the _\bv_\bm_\b__\bm_\bi_\bn_\bf_\bl_\bt field gives the number of page faults in-
+ curred in simulation of reference bits; _\bv_\bm_\b__\bn_\bs_\bw_\ba_\bp is the number of swaps
+ which occurred. The number of file system input/output events are re-
+ ported in _\bv_\bm_\b__\bi_\bn_\bb_\bl_\bk and _\bv_\bm_\b__\bo_\bu_\bb_\bl_\bk These numbers account only for real I/O;
+ data supplied by the caching mechanism is charged only to the first pro-
+ cess to read or write the data.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ time(2), wait3(2), getrusage(2)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ The v\bvl\bli\bim\bmi\bit\bt() function appeared in 4.2BSD.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+J0(3) BSD Programmer's Manual J0(3)
+
+N\bNA\bAM\bME\bE
+ j\bj0\b0, j\bj1\b1, j\bjn\bn, y\by0\b0, y\by1\b1, y\byn\bn - bessel functions of first and second kind
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bjn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\byn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions j\bj0\b0() and j\bj1\b1() compute the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd
+ _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively, for the real value _\bx; the
+ function j\bjn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be
+ _\bi_\bn_\bt_\be_\bg_\be_\br Bessel0 _\bn for the real value _\bx.
+
+ The functions y\by0\b0() and y\by1\b1() compute the linearly independent _\bB_\be_\bs_\bs_\be_\bl
+ _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively,
+ for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double); the function
+ y\byn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bf_\bo_\br _\bt_\bh_\be _\bi_\bn_\bt_\be_\bg_\be_\br
+ Bessel0 _\bn for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ If these functions are successful, the computed value is returned. On the
+ VAX and Tahoe architectures, a negative _\bx value results in an error; the
+ global variable _\be_\br_\br_\bn_\bo is set to EDOM and a reserve operand fault is gen-
+ erated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A set of these functions function appeared in Version 7 AT&T UNIX.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+J0(3) BSD Programmer's Manual J0(3)
+
+N\bNA\bAM\bME\bE
+ j\bj0\b0, j\bj1\b1, j\bjn\bn, y\by0\b0, y\by1\b1, y\byn\bn - bessel functions of first and second kind
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bjn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\byn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions j\bj0\b0() and j\bj1\b1() compute the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd
+ _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively, for the real value _\bx; the
+ function j\bjn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be
+ _\bi_\bn_\bt_\be_\bg_\be_\br Bessel0 _\bn for the real value _\bx.
+
+ The functions y\by0\b0() and y\by1\b1() compute the linearly independent _\bB_\be_\bs_\bs_\be_\bl
+ _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively,
+ for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double); the function
+ y\byn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bf_\bo_\br _\bt_\bh_\be _\bi_\bn_\bt_\be_\bg_\be_\br
+ Bessel0 _\bn for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ If these functions are successful, the computed value is returned. On the
+ VAX and Tahoe architectures, a negative _\bx value results in an error; the
+ global variable _\be_\br_\br_\bn_\bo is set to EDOM and a reserve operand fault is gen-
+ erated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A set of these functions function appeared in Version 7 AT&T UNIX.
+
+4th Berkeley Distribution June 4, 1993 1
--- /dev/null
+J0(3) BSD Programmer's Manual J0(3)
+
+N\bNA\bAM\bME\bE
+ j\bj0\b0, j\bj1\b1, j\bjn\bn, y\by0\b0, y\by1\b1, y\byn\bn - bessel functions of first and second kind
+
+S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
+ #\b#i\bin\bnc\bcl\blu\bud\bde\be <\b<m\bma\bat\bth\bh.\b.h\bh>\b>
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bj1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ j\bjn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by0\b0(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\by1\b1(_\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+ _\bd_\bo_\bu_\bb_\bl_\be
+ y\byn\bn(_\bi_\bn_\bt _\bn, _\bd_\bo_\bu_\bb_\bl_\be _\bx);
+
+D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
+ The functions j\bj0\b0() and j\bj1\b1() compute the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd
+ _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively, for the real value _\bx; the
+ function j\bjn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bf_\bi_\br_\bs_\bt _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be
+ _\bi_\bn_\bt_\be_\bg_\be_\br Bessel0 _\bn for the real value _\bx.
+
+ The functions y\by0\b0() and y\by1\b1() compute the linearly independent _\bB_\be_\bs_\bs_\be_\bl
+ _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bo_\bf _\bt_\bh_\be _\bo_\br_\bd_\be_\br 0 and the _\bo_\br_\bd_\be_\br 1, respectively,
+ for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double); the function
+ y\byn\bn() computes the _\bB_\be_\bs_\bs_\be_\bl _\bf_\bu_\bn_\bc_\bt_\bi_\bo_\bn _\bo_\bf _\bt_\bh_\be _\bs_\be_\bc_\bo_\bn_\bd _\bk_\bi_\bn_\bd _\bf_\bo_\br _\bt_\bh_\be _\bi_\bn_\bt_\be_\bg_\be_\br
+ Bessel0 _\bn for the postive _\bi_\bn_\bt_\be_\bg_\be_\br value _\bx (expressed as a double).
+
+R\bRE\bET\bTU\bUR\bRN\bN V\bVA\bAL\bLU\bUE\bES\bS
+ If these functions are successful, the computed value is returned. On the
+ VAX and Tahoe architectures, a negative _\bx value results in an error; the
+ global variable _\be_\br_\br_\bn_\bo is set to EDOM and a reserve operand fault is gen-
+ erated.
+
+S\bSE\bEE\bE A\bAL\bLS\bSO\bO
+ math(3), infnan(3)
+
+H\bHI\bIS\bST\bTO\bOR\bRY\bY
+ A set of these functions function appeared in Version 7 AT&T UNIX.
+
+4th Berkeley Distribution June 4, 1993 1