lib/libm/noieee_src/n_asincos.c

   1 /*      $NetBSD: n_asincos.c,v 1.8 2013/11/24 14:41:53 martin Exp $     */
   2 /*
   3  * Copyright (c) 1985, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. Neither the name of the University nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #ifndef lint
  32 #if 0
  33 static char sccsid[] = "@(#)asincos.c   8.1 (Berkeley) 6/4/93";
  34 #endif
  35 #endif /* not lint */
  36
  37 /* ASIN(X)
  38  * RETURNS ARC SINE OF X
  39  * DOUBLE PRECISION (IEEE DOUBLE 53 bits, VAX D FORMAT 56 bits)
  40  * CODED IN C BY K.C. NG, 4/16/85, REVISED ON 6/10/85.
  41  *
  42  * Required system supported functions:
  43  *      copysign(x,y)
  44  *      sqrt(x)
  45  *
  46  * Required kernel function:
  47  *      atan2(y,x)
  48  *
  49  * Method :
  50  *      asin(x) = atan2(x,sqrt(1-x*x)); for better accuracy, 1-x*x is
  51  *                computed as follows
  52  *                      1-x*x                     if x <  0.5,
  53  *                      2*(1-|x|)-(1-|x|)*(1-|x|) if x >= 0.5.
  54  *
  55  * Special cases:
  56  *      if x is NaN, return x itself;
  57  *      if |x|>1, return NaN.
  58  *
  59  * Accuracy:
  60  * 1)  If atan2() uses machine PI, then
  61  *
  62  *      asin(x) returns (PI/pi) * (the exact arc sine of x) nearly rounded;
  63  *      and PI is the exact pi rounded to machine precision (see atan2 for
  64  *      details):
  65  *
  66  *      in decimal:
  67  *              pi = 3.141592653589793 23846264338327 .....
  68  *    53 bits   PI = 3.141592653589793 115997963 ..... ,
  69  *    56 bits   PI = 3.141592653589793 227020265 ..... ,
  70  *
  71  *      in hexadecimal:
  72  *              pi = 3.243F6A8885A308D313198A2E....
  73  *    53 bits   PI = 3.243F6A8885A30  =  2 * 1.921FB54442D18    error=.276ulps
  74  *    56 bits   PI = 3.243F6A8885A308 =  4 * .C90FDAA22168C2    error=.206ulps
  75  *
  76  *      In a test run with more than 200,000 random arguments on a VAX, the
  77  *      maximum observed error in ulps (units in the last place) was
  78  *      2.06 ulps.      (comparing against (PI/pi)*(exact asin(x)));
  79  *
  80  * 2)  If atan2() uses true pi, then
  81  *
  82  *      asin(x) returns the exact asin(x) with error below about 2 ulps.
  83  *
  84  *      In a test run with more than 1,024,000 random arguments on a VAX, the
  85  *      maximum observed error in ulps (units in the last place) was
  86  *      1.99 ulps.
  87  */
  88
  89 #include "mathimpl.h"
  90
  91 double
  92 asin(double x)
  93 {
  94         double s,t,one=1.0;
  95 #if !defined(__vax__)&&!defined(tahoe)
  96         if(x!=x) return(x);     /* x is NaN */
  97 #endif  /* !defined(__vax__)&&!defined(tahoe) */
  98         s=copysign(x,one);
  99         if(s <= 0.5)
 100             return(atan2(x,sqrt(one-x*x)));
 101         else
 102             { t=one-s; s=t+t; return(atan2(x,sqrt(s-t*t))); }
 103
 104 }
 105
 106 float
 107 asinf(float x)
 108 {
 109         return (float)asin(x);
 110 }
 111
 112 /* ACOS(X)
 113  * RETURNS ARC COS OF X
 114  * DOUBLE PRECISION (IEEE DOUBLE 53 bits, VAX D FORMAT 56 bits)
 115  * CODED IN C BY K.C. NG, 4/16/85, REVISED ON 6/10/85.
 116  *
 117  * Required system supported functions:
 118  *      copysign(x,y)
 119  *      sqrt(x)
 120  *
 121  * Required kernel function:
 122  *      atan2(y,x)
 123  *
 124  * Method :
 125  *                            ________
 126  *                           / 1 - x
 127  *      acos(x) = 2*atan2(  / -------- , 1 ) .
 128  *                        \/   1 + x
 129  *
 130  * Special cases:
 131  *      if x is NaN, return x itself;
 132  *      if |x|>1, return NaN.
 133  *
 134  * Accuracy:
 135  * 1)  If atan2() uses machine PI, then
 136  *
 137  *      acos(x) returns (PI/pi) * (the exact arc cosine of x) nearly rounded;
 138  *      and PI is the exact pi rounded to machine precision (see atan2 for
 139  *      details):
 140  *
 141  *      in decimal:
 142  *              pi = 3.141592653589793 23846264338327 .....
 143  *    53 bits   PI = 3.141592653589793 115997963 ..... ,
 144  *    56 bits   PI = 3.141592653589793 227020265 ..... ,
 145  *
 146  *      in hexadecimal:
 147  *              pi = 3.243F6A8885A308D313198A2E....
 148  *    53 bits   PI = 3.243F6A8885A30  =  2 * 1.921FB54442D18    error=.276ulps
 149  *    56 bits   PI = 3.243F6A8885A308 =  4 * .C90FDAA22168C2    error=.206ulps
 150  *
 151  *      In a test run with more than 200,000 random arguments on a VAX, the
 152  *      maximum observed error in ulps (units in the last place) was
 153  *      2.07 ulps.      (comparing against (PI/pi)*(exact acos(x)));
 154  *
 155  * 2)  If atan2() uses true pi, then
 156  *
 157  *      acos(x) returns the exact acos(x) with error below about 2 ulps.
 158  *
 159  *      In a test run with more than 1,024,000 random arguments on a VAX, the
 160  *      maximum observed error in ulps (units in the last place) was
 161  *      2.15 ulps.
 162  */
 163
 164 double
 165 acos(double x)
 166 {
 167         double t,one=1.0;
 168 #if !defined(__vax__)&&!defined(tahoe)
 169         if(x!=x) return(x);
 170 #endif  /* !defined(__vax__)&&!defined(tahoe) */
 171         if( x != -1.0)
 172             t=atan2(sqrt((one-x)/(one+x)),one);
 173         else
 174             t=atan2(one,0.0);   /* t = PI/2 */
 175         return(t+t);
 176 }
 177
 178 float
 179 acosf(float x)
 180 {
 181         return (float)acos(x);
 182 }