nsz Git - libm/blob - src/math/sqrt.c

   1 /* origin: FreeBSD /usr/src/lib/msun/src/e_sqrt.c */
   2 /*
   3  * ====================================================
   4  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
   5  *
   6  * Developed at SunSoft, a Sun Microsystems, Inc. business.
   7  * Permission to use, copy, modify, and distribute this
   8  * software is freely granted, provided that this notice
   9  * is preserved.
  10  * ====================================================
  11  */
  12 /* sqrt(x)
  13  * Return correctly rounded sqrt.
  14  *           ------------------------------------------
  15  *           |  Use the hardware sqrt if you have one |
  16  *           ------------------------------------------
  17  * Method:
  18  *   Bit by bit method using integer arithmetic. (Slow, but portable)
  19  *   1. Normalization
  20  *      Scale x to y in [1,4) with even powers of 2:
  21  *      find an integer k such that  1 <= (y=x*2^(2k)) < 4, then
  22  *              sqrt(x) = 2^k * sqrt(y)
  23  *   2. Bit by bit computation
  24  *      Let q  = sqrt(y) truncated to i bit after binary point (q = 1),
  25  *           i                                                   0
  26  *                                     i+1         2
  27  *          s  = 2*q , and      y  =  2   * ( y - q  ).         (1)
  28  *           i      i            i                 i
  29  *
  30  *      To compute q    from q , one checks whether
  31  *                  i+1       i
  32  *
  33  *                            -(i+1) 2
  34  *                      (q + 2      ) <= y.                     (2)
  35  *                        i
  36  *                                                            -(i+1)
  37  *      If (2) is false, then q   = q ; otherwise q   = q  + 2      .
  38  *                             i+1   i             i+1   i
  39  *
  40  *      With some algebric manipulation, it is not difficult to see
  41  *      that (2) is equivalent to
  42  *                             -(i+1)
  43  *                      s  +  2       <= y                      (3)
  44  *                       i                i
  45  *
  46  *      The advantage of (3) is that s  and y  can be computed by
  47  *                                    i      i
  48  *      the following recurrence formula:
  49  *          if (3) is false
  50  *
  51  *          s     =  s  ,       y    = y   ;                    (4)
  52  *           i+1      i          i+1    i
  53  *
  54  *          otherwise,
  55  *                         -i                     -(i+1)
  56  *          s     =  s  + 2  ,  y    = y  -  s  - 2             (5)
  57  *           i+1      i          i+1    i     i
  58  *
  59  *      One may easily use induction to prove (4) and (5).
  60  *      Note. Since the left hand side of (3) contain only i+2 bits,
  61  *            it does not necessary to do a full (53-bit) comparison
  62  *            in (3).
  63  *   3. Final rounding
  64  *      After generating the 53 bits result, we compute one more bit.
  65  *      Together with the remainder, we can decide whether the
  66  *      result is exact, bigger than 1/2ulp, or less than 1/2ulp
  67  *      (it will never equal to 1/2ulp).
  68  *      The rounding mode can be detected by checking whether
  69  *      huge + tiny is equal to huge, and whether huge - tiny is
  70  *      equal to huge for some floating point number "huge" and "tiny".
  71  *
  72  * Special cases:
  73  *      sqrt(+-0) = +-0         ... exact
  74  *      sqrt(inf) = inf
  75  *      sqrt(-ve) = NaN         ... with invalid signal
  76  *      sqrt(NaN) = NaN         ... with invalid signal for signaling NaN
  77  *
  78  * Other methods : see the appended file at the end of the program below.
  79  *---------------
  80  */
  81
  82 #include "libm.h"
  83
  84 static const double one = 1.0, tiny = 1.0e-300;
  85
  86 double sqrt(double x)
  87 {
  88         double z;
  89         int32_t sign = (int)0x80000000;
  90         int32_t ix0,s0,q,m,t,i;
  91         uint32_t r,t1,s1,ix1,q1;
  92
  93         EXTRACT_WORDS(ix0, ix1, x);
  94
  95         /* take care of Inf and NaN */
  96         if ((ix0&0x7ff00000) == 0x7ff00000) {
  97                 return x*x + x;  /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */
  98         }
  99         /* take care of zero */
 100         if (ix0 <= 0) {
 101                 if (((ix0&(~sign))|ix1) == 0)
 102                         return x;  /* sqrt(+-0) = +-0 */
 103                 if (ix0 < 0)
 104                         return (x-x)/(x-x);  /* sqrt(-ve) = sNaN */
 105         }
 106         /* normalize x */
 107         m = ix0>>20;
 108         if (m == 0) {  /* subnormal x */
 109                 while (ix0 == 0) {
 110                         m -= 21;
 111                         ix0 |= (ix1>>11);
 112                         ix1 <<= 21;
 113                 }
 114                 for (i=0; (ix0&0x00100000) == 0; i++)
 115                         ix0<<=1;
 116                 m -= i - 1;
 117                 ix0 |= ix1>>(32-i);
 118                 ix1 <<= i;
 119         }
 120         m -= 1023;    /* unbias exponent */
 121         ix0 = (ix0&0x000fffff)|0x00100000;
 122         if (m & 1) {  /* odd m, double x to make it even */
 123                 ix0 += ix0 + ((ix1&sign)>>31);
 124                 ix1 += ix1;
 125         }
 126         m >>= 1;      /* m = [m/2] */
 127
 128         /* generate sqrt(x) bit by bit */
 129         ix0 += ix0 + ((ix1&sign)>>31);
 130         ix1 += ix1;
 131         q = q1 = s0 = s1 = 0;  /* [q,q1] = sqrt(x) */
 132         r = 0x00200000;        /* r = moving bit from right to left */
 133
 134         while (r != 0) {
 135                 t = s0 + r;
 136                 if (t <= ix0) {
 137                         s0   = t + r;
 138                         ix0 -= t;
 139                         q   += r;
 140                 }
 141                 ix0 += ix0 + ((ix1&sign)>>31);
 142                 ix1 += ix1;
 143                 r >>= 1;
 144         }
 145
 146         r = sign;
 147         while (r != 0) {
 148                 t1 = s1 + r;
 149                 t  = s0;
 150                 if (t < ix0 || (t == ix0 && t1 <= ix1)) {
 151                         s1 = t1 + r;
 152                         if ((t1&sign) == sign && (s1&sign) == 0)
 153                                 s0++;
 154                         ix0 -= t;
 155                         if (ix1 < t1)
 156                                 ix0--;
 157                         ix1 -= t1;
 158                         q1 += r;
 159                 }
 160                 ix0 += ix0 + ((ix1&sign)>>31);
 161                 ix1 += ix1;
 162                 r >>= 1;
 163         }
 164
 165         /* use floating add to find out rounding direction */
 166         if ((ix0|ix1) != 0) {
 167                 z = one - tiny; /* raise inexact flag */
 168                 if (z >= one) {
 169                         z = one + tiny;
 170                         if (q1 == (uint32_t)0xffffffff) {
 171                                 q1 = 0;
 172                                 q++;
 173                         } else if (z > one) {
 174                                 if (q1 == (uint32_t)0xfffffffe)
 175                                         q++;
 176                                 q1 += 2;
 177                         } else
 178                                 q1 += q1 & 1;
 179                 }
 180         }
 181         ix0 = (q>>1) + 0x3fe00000;
 182         ix1 = q1>>1;
 183         if (q&1)
 184                 ix1 |= sign;
 185         ix0 += m << 20;
 186         INSERT_WORDS(z, ix0, ix1);
 187         return z;
 188 }