github.com/afumu/libc@v0.0.6/musl/src/math/sqrt.c (about)

     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  
    79  #include "libm.h"
    80  
    81  static const double tiny = 1.0e-300;
    82  
    83  double sqrt(double x)
    84  {
    85  	double z;
    86  	int32_t sign = (int)0x80000000;
    87  	int32_t ix0,s0,q,m,t,i;
    88  	uint32_t r,t1,s1,ix1,q1;
    89  
    90  	EXTRACT_WORDS(ix0, ix1, x);
    91  
    92  	/* take care of Inf and NaN */
    93  	if ((ix0&0x7ff00000) == 0x7ff00000) {
    94  		return x*x + x;  /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */
    95  	}
    96  	/* take care of zero */
    97  	if (ix0 <= 0) {
    98  		if (((ix0&~sign)|ix1) == 0)
    99  			return x;  /* sqrt(+-0) = +-0 */
   100  		if (ix0 < 0)
   101  			return (x-x)/(x-x);  /* sqrt(-ve) = sNaN */
   102  	}
   103  	/* normalize x */
   104  	m = ix0>>20;
   105  	if (m == 0) {  /* subnormal x */
   106  		while (ix0 == 0) {
   107  			m -= 21;
   108  			ix0 |= (ix1>>11);
   109  			ix1 <<= 21;
   110  		}
   111  		for (i=0; (ix0&0x00100000) == 0; i++)
   112  			ix0<<=1;
   113  		m -= i - 1;
   114  		ix0 |= ix1>>(32-i);
   115  		ix1 <<= i;
   116  	}
   117  	m -= 1023;    /* unbias exponent */
   118  	ix0 = (ix0&0x000fffff)|0x00100000;
   119  	if (m & 1) {  /* odd m, double x to make it even */
   120  		ix0 += ix0 + ((ix1&sign)>>31);
   121  		ix1 += ix1;
   122  	}
   123  	m >>= 1;      /* m = [m/2] */
   124  
   125  	/* generate sqrt(x) bit by bit */
   126  	ix0 += ix0 + ((ix1&sign)>>31);
   127  	ix1 += ix1;
   128  	q = q1 = s0 = s1 = 0;  /* [q,q1] = sqrt(x) */
   129  	r = 0x00200000;        /* r = moving bit from right to left */
   130  
   131  	while (r != 0) {
   132  		t = s0 + r;
   133  		if (t <= ix0) {
   134  			s0   = t + r;
   135  			ix0 -= t;
   136  			q   += r;
   137  		}
   138  		ix0 += ix0 + ((ix1&sign)>>31);
   139  		ix1 += ix1;
   140  		r >>= 1;
   141  	}
   142  
   143  	r = sign;
   144  	while (r != 0) {
   145  		t1 = s1 + r;
   146  		t  = s0;
   147  		if (t < ix0 || (t == ix0 && t1 <= ix1)) {
   148  			s1 = t1 + r;
   149  			if ((t1&sign) == sign && (s1&sign) == 0)
   150  				s0++;
   151  			ix0 -= t;
   152  			if (ix1 < t1)
   153  				ix0--;
   154  			ix1 -= t1;
   155  			q1 += r;
   156  		}
   157  		ix0 += ix0 + ((ix1&sign)>>31);
   158  		ix1 += ix1;
   159  		r >>= 1;
   160  	}
   161  
   162  	/* use floating add to find out rounding direction */
   163  	if ((ix0|ix1) != 0) {
   164  		z = 1.0 - tiny; /* raise inexact flag */
   165  		if (z >= 1.0) {
   166  			z = 1.0 + tiny;
   167  			if (q1 == (uint32_t)0xffffffff) {
   168  				q1 = 0;
   169  				q++;
   170  			} else if (z > 1.0) {
   171  				if (q1 == (uint32_t)0xfffffffe)
   172  					q++;
   173  				q1 += 2;
   174  			} else
   175  				q1 += q1 & 1;
   176  		}
   177  	}
   178  	ix0 = (q>>1) + 0x3fe00000;
   179  	ix1 = q1>>1;
   180  	if (q&1)
   181  		ix1 |= sign;
   182  	INSERT_WORDS(z, ix0 + ((uint32_t)m << 20), ix1);
   183  	return z;
   184  }