intervals 0.3.56

data/ext/crlibm/atan-pentium.c

@@ -0,0 +1,261 @@
+/* 
+ *this function computes atan correctly rounded to the nearest, 
+ using experimental techniques based on  double-extended arithmetic
+
+ THIS IS EXPERIMENTAL SOFTWARE
+
+In particular it changes rounding modes all the time without warning
+nor restoring.
+ 
+ *
+ * Author : Nicolas Gast, Florent de Dinechin
+ * nicolas.gast@ens.fr
+ *
+
+ To have it replace the crlibm atan, do:
+ gcc -DHAVE_CONFIG_H -I.  -fPIC  -O2 -c atan-pentium.c;   mv atan-pentium.o atan_fast.o; make 
+ 
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <crlibm.h>
+#include <crlibm_private.h>
+#include "double-extended.h"
+
+#define debug 1 /*Warning : turning debugging on seems to change the final result */
+#define DEBUG 0
+#define NICOLASTEST 0
+
+#ifdef HAVE_FENV_H
+#include <fenv.h>
+#endif
+
+
+/* The following seems perfectly harmless */
+
+#ifdef FENV_H
+#pragma STDC FENV_ACCESS ON
+#endif
+
+#include "atan-pentium.h"
+#include <fpu_control.h>
+
+
+
+/* Dummy functions to compile OK */
+extern double atan_rd(double x) {return 0;}
+extern double atan_ru(double x) {return 0;}
+extern double atan_rz(double x) {return 0;}
+
+
+extern double atan_rn(double x) {
+  db_number x_db;
+  unsigned int hx;
+  double sign;
+  double u;
+  double comp;
+  double atanhi, atanlo, atanlo_u;
+
+  long double Xred;
+  long double Xred2;
+  long double q;
+  long double atan;
+  long double eps;
+  int i;
+  
+  if(x>=0)
+    sign = 1;
+  else
+    {sign = -1;
+    x=-x;}
+  
+  x_db.d = x;
+  hx = x_db.i[HI] & 0x7FFFFFFF; 
+  
+  /* Filter cases */
+  if ( hx >= 0x43500000)           /* x >= 2^54 */
+    {
+      if ( (x_db.i[LO] == 0) && (hx & 0x000fffff) == 0x00080000)
+        return x+x;                /* NaN */
+      else
+        return sign*HALFPI.d;           /* atan(x) = Pi/2 */
+    }
+  else
+    if ( hx < 0x3E400000 )
+      {return sign*x;}                   /* x<2^-27 then atan(x) =~ x */
+
+   DOUBLE_EXTENDED_MODE;
+
+
+  if (x > MIN_REDUCTION_NEEDED) /* test if reduction is necessary : */
+    {
+      /* 1) Argument reduction :  */
+      
+      /* compute i so that a[i] < x < a[i+1] */
+      if (x>arctan_table[61][A])
+        i=61;
+      else {
+        i=31;
+        if (x < arctan_table[i][A]) i-= 16;
+        else i+=16;
+        if (x < arctan_table[i][A]) i-= 8;
+        else i+= 8;
+        if (x < arctan_table[i][A]) i-= 4;
+        else i+= 4;
+        if (x < arctan_table[i][A]) i-= 2;
+        else i+= 2;
+        if (x < arctan_table[i][A]) i-= 1;
+        else i+= 1;
+        if (x < arctan_table[i][A]) i-= 1;
+      }
+      Xred = (x - arctan_table[i][B] )/(1.0L +  x * arctan_table[i][B] );
+      
+      Xred2 = Xred*Xred;
+      /* Polynomial evaluation */
+      q = Xred2*(coef_poly[0][0]+Xred2*
+           (coef_poly[1][0]+Xred2*
+            (coef_poly[2][0]+Xred2*
+             (coef_poly[3][0]))));
+      
+      /* reconstruction : atan(x) = atan(b[i]) + atan(x) */
+      atan = arctan_table[i][ATAN_BHI] + (Xred + q*Xred);
+      
+
+      atanhi = (double) atan;
+      atanlo = atan-atanhi;
+      
+      
+    }
+  else
+    
+    // no reduction needed
+    {
+      
+      Xred2 = x*x;
+      
+      /* Polynomial evaluation */
+      q = Xred2*(coef_poly[0][0]+Xred2*
+           (coef_poly[1][0]+Xred2*
+            (coef_poly[2][0]+Xred2*
+             (coef_poly[3][0]))));
+      
+      atan = q*x + x;
+    
+    }
+  
+  TEST_AND_RETURN_RN2(atan, sign*atan, 0x7fe);
+  /* or : 
+  TEST_AND_RETURN_RN_ZIV(sign*atan, 1.003);
+  */
+   {
+
+    /*Second step, double-double  */
+    long double tmphi, tmplo;
+    long double x0hi, x0lo;
+    long double xmBihi, xmBilo;
+    long double Xredhi, Xredlo;
+    long double Xred2;
+    long double qhi,qlo; /* q = polynomial */
+    long double q;
+    long double Xred2hi,Xred2lo;
+    long double atanhi,atanlo;
+    int j;
+  
+#if EVAL_PERF
+  crlibm_second_step_taken++;
+#endif
+  
+  if (x > MIN_REDUCTION_NEEDED) /* test if reduction is necessary : */
+    {
+      /* 1) Argument reduction :  */
+      
+      if (i==61) 
+        {
+          Add12_ext( xmBihi , xmBilo , x , -arctan_table[61][B]);
+        }
+      else 
+        {
+          xmBihi = x-arctan_table[i][B];
+          xmBilo = 0.0;
+        }
+      
+      Mul12_ext(&tmphi,&tmplo, x, arctan_table[i][B]);
+      
+      if (x > 1)
+        Add22_ext(&x0hi,&x0lo,tmphi,tmplo, 1.0,0.0);
+      else {Add22_ext( &x0hi , &x0lo , 1.0,0.0,tmphi,tmplo);}
+      
+      Div22_ext( Xredhi, Xredlo, xmBihi , xmBilo , x0hi,x0lo);
+      
+      Xred2 = Xredhi*Xredhi;
+      Mul22_ext( &Xred2hi,&Xred2lo,Xredhi,Xredlo,Xredhi, Xredlo);
+      
+      /*poly eval */
+      
+      q = (coef_poly[4][0]+Xred2*
+           (coef_poly[5][0]+Xred2*
+            (coef_poly[6][0]+Xred2*
+             (coef_poly[7][0]+
+              (Xred2*coef_poly[8][0])))));
+      
+      Mul12_ext( &qhi, &qlo, q, Xred2);
+      
+      for(j=3;j>=0;j--)
+        {
+          Add22_ext(&qhi,&qlo, coef_poly[j][0], coef_poly[j][1], qhi,qlo);
+          Mul22_ext(&qhi,&qlo, qhi,qlo, Xred2hi,Xred2lo);
+        }
+      
+      Mul22_ext(&qhi,&qlo, Xredhi,Xredlo, qhi,qlo);
+      Add22_ext(&qhi,&qlo, Xredhi,Xredlo, qhi,qlo);
+      
+      /* reconstruction : atan(x) = atan(b[i]) + atan(x) */
+      Add22_ext(&atanhi,&atanlo, arctan_table[i][ATAN_BHI], arctan_table[i][ATAN_BLO], qhi,qlo);
+    }
+  else
+    
+    // no reduction needed
+    {
+      /* Polynomial evaluation */
+      Mul12_ext( &Xred2hi,&Xred2lo,x,x);
+      
+      /*poly eval */
+      q = Xred2hi*(coef_poly[5][0]+Xred2hi*
+		   (coef_poly[6][0]+Xred2hi*
+		    (coef_poly[7][0]+Xred2hi*
+		     (coef_poly[8][0]))));
+      
+      Add12_ext(qhi,qlo, coef_poly[4][0],q);
+#if debug
+  printf(" xred2   =   %1.50Le + %1.50Le\n", Xred2hi, Xred2lo);
+  printf(" qhi+qlo0=   %1.50Le + %1.50Le\n",qhi, qlo);
+#endif
+      Mul22_ext(&qhi,&qlo, qhi,qlo, Xred2hi,Xred2lo);
+      
+      for(j=3;j>=0;j--)
+        {
+          Add22_ext(&qhi,&qlo, coef_poly[j][0], coef_poly[j][1], qhi,qlo);
+          Mul22_ext(&qhi,&qlo, qhi,qlo, Xred2hi,Xred2lo);
+        }
+      
+      Mul22_ext (&qhi,&qlo, x,0, qhi,qlo);
+
+#if debug
+  printf(" qhi+qlo =   %1.50Le + %1.50Le\n",qhi, qlo);
+#endif
+
+      /* The sequence in the TOMS paper */
+      Add12_ext (atanhi,atanlo,x,qhi);
+      atanlo += qlo;
+    }
+#if debug
+  printf("             %1.50Le + %1.50Le\n",atanhi, atanlo);
+  printf("             %1.50Le\n",atanhi + atanlo);
+#endif
+  
+   BACK_TO_DOUBLE_MODE;
+  return sign*((double) (atanhi+atanlo));
+    }
+}

data/ext/crlibm/atan_accurate.c

@@ -0,0 +1,244 @@
+/*
+ * Correctly rounded arctangent
+ *
+ * Author : Nicolas Gast (Ecole Normale Superieure), Florent de Dinechin
+ *
+ * This file is part of the crlibm library developed by the Arenaire
+ * project at Ecole Normale Superieure de Lyon
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include "crlibm_private.h"
+#include "atan_accurate.h"
+#include "atan_fast.h"
+
+
+/*
+ *  WHAT WE CAN DO :
+ *
+ * 1) Range reduction 
+ *
+ *	x > 0  because atan(-x) = - atan(x)
+ *	
+ *	we have built 50 intervals I(i), associated to a b(i) so that :
+ *	
+ *	For every x :
+ *	
+ *	we find the interval I(i) , as atan(x) = atan(b(i)) + atan( (x - b(i)) / (1 + x * b(i)) ) 
+ *	
+ *		so that X = (x - b(i)) / (1 + x * b(i))  be in interval [ -2^(-6) , 2^(-6) ] 
+ *		There is no cancellation because :
+ *		for every x in [ -2^(-6) , 2^(-6) ],
+ *		
+ *					     atan(x) <= 0.01562372862     in binary 0.000001111111111
+ *		AND for the smallest b(i)    atan(b(i)) = 0.04687118592   in binary 0.00001011111111 	   
+ *
+ *
+ * 2) Polynomial evaluation of atan(X), atan(b(i)) is tabulated.
+ *                  
+ *                                  (-???)  
+ *   Approximation error: |err| < 2^ 
+ *
+ *
+ * 3) Reconstruction:
+ *
+ *    atan(x) = atan(b(i)) + atan(X) 
+ *
+ *
+ * 4) Rounding:
+ *
+ *    when |x| is too big, the result is always sign(x) * Pi/2,
+ *    because Pi/2 is appromated by the biggest value smallest than Pi/2, 
+ *    in order not to have an atan > Pi/2.
+ */
+
+
+ 
+ 
+void scs_atan(scs_ptr res_scs, scs_ptr x){
+  scs_t X_scs, denom1_scs, denom2_scs, poly_scs, X2;
+  scs_t atanbhihi,atanbhilo, atanblo, atanbhi, atanb;
+  scs_t bsc_ptr;
+  db_number db;
+  double test;
+  int k, i=31;
+
+  
+  scs_get_d(&db.d, x);  
+  
+#if EVAL_PERF
+  crlibm_second_step_taken++;
+#endif
+  
+  /* test if x as to be reduced */
+  if (db.d > MIN_REDUCTION_NEEDED) {
+    /* Compute i so that  x E [a[i],a[i+1]] */
+    if (db.d < arctan_table[i][A].d) i-= 16;
+    else i+=16;
+    if (db.d < arctan_table[i][A].d) i-= 8;
+    else i+= 8;
+    if (db.d < arctan_table[i][A].d) i-= 4;
+    else i+= 4;
+    if (db.d < arctan_table[i][A].d) i-= 2;
+    else i+= 2;
+    if (db.d < arctan_table[i][A].d) i-= 1;
+    else if (i<61) i+= 1;
+    if (db.d < arctan_table[i][A].d) i-= 1;
+    
+    /* evaluate X = (x - b(i)) / (1 + x*b(i)) */
+    scs_set_d(bsc_ptr, arctan_table[i][B].d);
+    
+    scs_mul(denom1_scs,bsc_ptr,x);
+    scs_add(denom2_scs,denom1_scs,SCS_ONE);
+    scs_sub(X_scs,x,bsc_ptr);
+    scs_div(X_scs,X_scs,denom2_scs);
+    
+    scs_get_d(&test,X_scs);
+    
+    /* Polynomial evaluation of atan(X) , X = (x-b(i)) / (1+ x*b(i)) */
+    scs_square(X2, X_scs);
+    scs_set(res_scs, constant_poly_ptr[0]);
+    for(k=1; k < 10; k++) {
+      /* we use Horner expression */
+      scs_mul(res_scs, res_scs, X2);
+      scs_add(res_scs, constant_poly_ptr[k], res_scs);
+    }
+    scs_mul(poly_scs, res_scs, X_scs);
+    
+    /* reconstruction : */
+    
+    /* 1st we load atan ( b[i] ) in a scs*/ 
+    scs_set_d( atanbhihi , arctan_table[i][ATAN_BHI].d);
+    scs_set_d( atanbhilo , arctan_table[i][ATAN_BLO].d);
+    scs_set_d( atanblo , atan_blolo[i].d);
+    scs_add(atanbhi,atanbhihi,atanbhilo);
+    scs_add(atanb,atanbhi,atanblo);
+    scs_add(res_scs,atanb, poly_scs); 
+    return;
+  }
+  
+  else 
+    { /* no reduction needed */
+      
+      /* Polynomial evaluation of atan(x) */
+      scs_square(X2, x);
+      scs_set(res_scs, constant_poly_ptr[0]);
+      for(k=1; k < 10; k++) {
+        /* we use Horner expression */
+        scs_mul(res_scs, res_scs, X2);
+        scs_add(res_scs, constant_poly_ptr[k], res_scs);
+      }
+      scs_mul(res_scs, res_scs, x);
+      return;
+    }
+}
+       
+/*************************************************************
+ *************************************************************
+ *               ROUNDED  TO NEAREST
+ *************************************************************
+ *************************************************************/
+
+double scs_atan_rn(double x){ 
+  /* This function does NOT compute atan(x) correctly if it isn't 
+   * called in atan_rn() 
+   */
+  scs_t sc1;
+  scs_t res_scs;
+  db_number res;
+  int sign =1;
+  
+  res.d = x;
+
+  if (x < 0){
+    sign = -1;
+    x *= -1;
+  }
+  scs_set_d(sc1, x);
+  scs_atan(res_scs, sc1);
+  scs_get_d(&res.d, res_scs);
+  
+  res.d *= sign;
+  
+  return res.d;
+}
+
+/*************************************************************
+ *************************************************************
+ *               ROUNDED  TOWARD  -INFINITY
+ *************************************************************
+ *************************************************************/
+
+double scs_atan_rd(double x){ 
+  scs_t sc1;
+  scs_t res_scs;
+  db_number res;
+  int sign = 1;
+   
+  res.d = x;
+
+  /* Filter cases */
+  if (x < 0){
+    sign = -1;
+    x *= -1;
+  }
+  scs_set_d(sc1, x);
+  scs_atan(res_scs, sc1);
+  if (sign == -1){
+    scs_get_d_pinf(&res.d, res_scs);
+    res.d *= -1;
+    return res.d;
+  }
+  else{
+    scs_get_d_minf(&res.d, res_scs);		
+    return res.d;
+  }
+}
+
+/*************************************************************
+ *************************************************************
+ *               ROUNDED  TOWARD  +INFINITY
+ *************************************************************
+ *************************************************************/
+
+double scs_atan_ru(double x){ 
+  scs_t sc1;
+  scs_t res_scs;
+  db_number res;
+  int sign = 1;
+  
+  res.d = x;
+
+  /* Filter cases */
+  if (x < 0){
+    sign = -1;
+    x *= -1;
+  }
+ 
+  scs_set_d(sc1, x);
+  scs_atan(res_scs, sc1);
+  if (sign == -1){
+    scs_get_d_minf(&res.d, res_scs);
+    res.d *= -1;
+    return res.d;
+  }
+  else{
+    scs_get_d_pinf(&res.d, res_scs);		
+    return res.d;
+  }
+}
+

data/ext/crlibm/atan_accurate.h

@@ -0,0 +1,191 @@
+#include "crlibm.h"
+#include "crlibm_private.h" 
+#include "atan_fast.h"
+
+/*File generated by maple/coef_atan.mw */
+static const scs constant_poly [10]=
+/* ~-5.26315789473684210526315789473684210526315789473684e-02 */ 
+{{{0x035e50d7, 0x250d7943, 0x179435e5, 0x035e50d7, 
+0x250d7943, 0x179435e5, 0x035e50d7, 0x250d7943},
+DB_ONE,  -1,  -1 } 
+,
+/* ~5.88235294117647058823529411764705882352941176470588e-02 */ 
+{{0x03c3c3c3, 0x30f0f0f0, 0x3c3c3c3c, 0x0f0f0f0f, 
+0x03c3c3c3, 0x30f0f0f0, 0x3c3c3c3c, 0x0f0f0f0f},
+DB_ONE,  -1,   1 } 
+,
+/* ~-6.66666666666666666666666666666666666666666666666667e-02 */ 
+{{0x04444444, 0x11111111, 0x04444444, 0x11111111, 
+0x04444444, 0x11111111, 0x04444444, 0x11111111},
+DB_ONE,  -1,  -1 } 
+,
+/* ~7.69230769230769230769230769230769230769230769230769e-02 */ 
+{{0x04ec4ec4, 0x3b13b13b, 0x04ec4ec4, 0x3b13b13b, 
+0x04ec4ec4, 0x3b13b13b, 0x04ec4ec4, 0x3b13b13b},
+DB_ONE,  -1,   1 } 
+,
+/* ~-9.09090909090909090909090909090909090909090909090909e-02 */ 
+{{0x05d1745d, 0x05d1745d, 0x05d1745d, 0x05d1745d, 
+0x05d1745d, 0x05d1745d, 0x05d1745d, 0x05d1745d},
+DB_ONE,  -1,  -1 } 
+,
+/* ~1.11111111111111111111111111111111111111111111111111e-01 */ 
+{{0x071c71c7, 0x071c71c7, 0x071c71c7, 0x071c71c7, 
+0x071c71c7, 0x071c71c7, 0x071c71c7, 0x071c71c7},
+DB_ONE,  -1,   1 } 
+,
+/* ~-1.42857142857142857142857142857142857142857142857143e-01 */ 
+{{0x09249249, 0x09249249, 0x09249249, 0x09249249, 
+0x09249249, 0x09249249, 0x09249249, 0x09249249},
+DB_ONE,  -1,  -1 } 
+,
+/* ~2.00000000000000000000000000000000000000000000000000e-01 */ 
+{{0x0ccccccc, 0x33333333, 0x0ccccccc, 0x33333333, 
+0x0ccccccc, 0x33333333, 0x0ccccccc, 0x33333333},
+DB_ONE,  -1,   1 } 
+,
+/* ~-3.33333333333333333333333333333333333333333333333333e-01 */ 
+{{0x15555555, 0x15555555, 0x15555555, 0x15555555, 
+0x15555555, 0x15555555, 0x15555555, 0x15555555},
+DB_ONE,  -1,  -1 } 
+,
+/* ~1.00000000000000000000000000000000000000000000000000e+00 */ 
+{{0x00000001, 0x00000000, 0x00000000, 0x00000000, 
+0x00000000, 0x00000000, 0x00000000, 0x00000000},
+DB_ONE,   0,   1 } 
+};
+#define constant_poly_ptr (scs_ptr)&constant_poly
+#ifdef WORDS_BIGENDIAN
+
+static const db_number atan_blolo[62] = {
+/* 0 */  {{0xB8D1C5F3,0xA947CCE9}} /* -5.3484426395e-35 */, 
+/* 1 */  {{0xB8B05943,0x3C749846}} /* -1.2299381479e-35 */, 
+/* 2 */  {{0x38FC2F2A,0x267751FB}} /* +3.3925541143e-34 */, 
+/* 3 */  {{0x38D44E61,0xDDA4249D}} /* +6.1106690132e-35 */, 
+/* 4 */  {{0xB906FBFA,0xA5B245C8}} /* -5.5332673453e-34 */, 
+/* 5 */  {{0xB8DE1E98,0x67CABE65}} /* -9.0637612563e-35 */, 
+/* 6 */  {{0x38BD7B8F,0x45D13048}} /* +2.2180284354e-35 */, 
+/* 7 */  {{0xB9049436,0x23AD369B}} /* -4.9542022687e-34 */, 
+/* 8 */  {{0xB8F98586,0xF6BB1DB7}} /* -3.0720497269e-34 */, 
+/* 9 */  {{0xB89BC985,0xCB4D6219}} /* -5.2261910438e-36 */, 
+/* 10 */  {{0xB8C4002C,0x9C3884F4}} /* -3.0093679582e-35 */, 
+/* 11 */  {{0x3910CBC4,0x893058D9}} /* +8.0869642604e-34 */, 
+/* 12 */  {{0xB8F5408B,0xFF010BB5}} /* -2.5581328396e-34 */, 
+/* 13 */  {{0xB908570F,0xB5813578}} /* -5.8596619457e-34 */, 
+/* 14 */  {{0x39155B89,0x7E967248}} /* +1.0283294335e-33 */, 
+/* 15 */  {{0xB8CD159A,0x2031F115}} /* -4.3761315763e-35 */, 
+/* 16 */  {{0xB8E8D9C6,0x0FC3C81C}} /* -1.4956458040e-34 */, 
+/* 17 */  {{0x38C0AC30,0x8219F20D}} /* +2.5086163140e-35 */, 
+/* 18 */  {{0x38B36506,0x32EDCB95}} /* +1.4590894790e-35 */, 
+/* 19 */  {{0xB8FD57B0,0x5932E7C2}} /* -3.5319791285e-34 */, 
+/* 20 */  {{0x38C73827,0x91A2D916}} /* +3.4936600564e-35 */, 
+/* 21 */  {{0xB92FE60D,0x9EC5116C}} /* -3.0717278111e-33 */, 
+/* 22 */  {{0x3903AADF,0x6A3B8AE2}} /* +4.7347715466e-34 */, 
+/* 23 */  {{0xB88D6A01,0x71B87C3C}} /* -2.7660872166e-36 */, 
+/* 24 */  {{0xB8E17427,0xEA5AC8E8}} /* -1.0504584084e-34 */, 
+/* 25 */  {{0x38F4ED52,0xF776B005}} /* +2.5190016806e-34 */, 
+/* 26 */  {{0xB9265B23,0x75D2B05C}} /* -2.1528054385e-33 */, 
+/* 27 */  {{0xB8DA45DA,0xAFEAB282}} /* -7.9062036715e-35 */, 
+/* 28 */  {{0x3912EF75,0xBD16D3D4}} /* +9.1170587963e-34 */, 
+/* 29 */  {{0x390AB3D7,0xE904B022}} /* +6.4283962392e-34 */, 
+/* 30 */  {{0xB8EE688B,0x3F9F468B}} /* -1.8301374849e-34 */, 
+/* 31 */  {{0xB9225DF6,0x71A98823}} /* -1.7686817787e-33 */, 
+/* 32 */  {{0xB8CC82B0,0x522BE0F8}} /* -4.2897836993e-35 */, 
+/* 33 */  {{0xB912AFE0,0x88BB6A0B}} /* -8.9974727841e-34 */, 
+/* 34 */  {{0x38D4DC99,0x8640FAE5}} /* +6.2778447830e-35 */, 
+/* 35 */  {{0xB9016FC6,0x406A343B}} /* -4.1977132916e-34 */, 
+/* 36 */  {{0x3909804C,0x126FC74C}} /* +6.1391811422e-34 */, 
+/* 37 */  {{0x39051033,0xE5B0956F}} /* +5.0708030720e-34 */, 
+/* 38 */  {{0xB910CADC,0x203B114C}} /* -8.0852567814e-34 */, 
+/* 39 */  {{0x38EFCAC7,0xF97ED36B}} /* +1.9134182531e-34 */, 
+/* 40 */  {{0xB92464C0,0xB51D77B4}} /* -1.9638289218e-33 */, 
+/* 41 */  {{0x391157F3,0x2D4A03DE}} /* +8.3506176591e-34 */, 
+/* 42 */  {{0xB92BD929,0x136A8DDE}} /* -2.6816921082e-33 */, 
+/* 43 */  {{0x390F1514,0x035DF6B3}} /* +7.4828003563e-34 */, 
+/* 44 */  {{0xB92606EC,0x19DB7E3B}} /* -2.1211268072e-33 */, 
+/* 45 */  {{0x393B104B,0xCDA1B51D}} /* +5.2122706777e-33 */, 
+/* 46 */  {{0x3935FB01,0xF88A520C}} /* +4.2332900876e-33 */, 
+/* 47 */  {{0xB9189ED1,0x1940944D}} /* -1.1854280852e-33 */, 
+/* 48 */  {{0xB914E8F2,0x38D4794B}} /* -1.0067772791e-33 */, 
+/* 49 */  {{0xB93DF07A,0x73581CF5}} /* -5.7661126209e-33 */, 
+/* 50 */  {{0xB939C22F,0x727CE10C}} /* -4.9609136744e-33 */, 
+/* 51 */  {{0xB8EF37D2,0x26E1A810}} /* -1.8788680655e-34 */, 
+/* 52 */  {{0x391A4251,0x45155DAA}} /* +1.2643273919e-33 */, 
+/* 53 */  {{0xB9126D2F,0xA42D0A9A}} /* -8.8720409776e-34 */, 
+/* 54 */  {{0xB93CAF8B,0x3DFAFFA5}} /* -5.5246684074e-33 */, 
+/* 55 */  {{0x3919C170,0xA9A35831}} /* +1.2400882522e-33 */, 
+/* 56 */  {{0xB924C2B3,0xAE51E4B3}} /* -1.9991686511e-33 */, 
+/* 57 */  {{0xB8DEFB7D,0x0DE98917}} /* -9.3234199178e-35 */, 
+/* 58 */  {{0xB916EC39,0x1ABE373B}} /* -1.1036900898e-33 */, 
+/* 59 */  {{0x391C5BA4,0x4135ADBE}} /* +1.3653868341e-33 */, 
+/* 60 */  {{0xB9112692,0xD7179E60}} /* -8.2577511316e-34 */, 
+/* 61 */  {{0x392F96B5,0xBCC93753}} /* +3.0418821818e-33 */, 
+};
+
+#else
+static const db_number atan_blolo[62] = {
+/* 0 */  {{0xA947CCE9,0xB8D1C5F3}} /* -5.3484426395e-35 */, 
+/* 1 */  {{0x3C749846,0xB8B05943}} /* -1.2299381479e-35 */, 
+/* 2 */  {{0x267751FB,0x38FC2F2A}} /* +3.3925541143e-34 */, 
+/* 3 */  {{0xDDA4249D,0x38D44E61}} /* +6.1106690132e-35 */, 
+/* 4 */  {{0xA5B245C8,0xB906FBFA}} /* -5.5332673453e-34 */, 
+/* 5 */  {{0x67CABE65,0xB8DE1E98}} /* -9.0637612563e-35 */, 
+/* 6 */  {{0x45D13048,0x38BD7B8F}} /* +2.2180284354e-35 */, 
+/* 7 */  {{0x23AD369B,0xB9049436}} /* -4.9542022687e-34 */, 
+/* 8 */  {{0xF6BB1DB7,0xB8F98586}} /* -3.0720497269e-34 */, 
+/* 9 */  {{0xCB4D6219,0xB89BC985}} /* -5.2261910438e-36 */, 
+/* 10 */  {{0x9C3884F4,0xB8C4002C}} /* -3.0093679582e-35 */, 
+/* 11 */  {{0x893058D9,0x3910CBC4}} /* +8.0869642604e-34 */, 
+/* 12 */  {{0xFF010BB5,0xB8F5408B}} /* -2.5581328396e-34 */, 
+/* 13 */  {{0xB5813578,0xB908570F}} /* -5.8596619457e-34 */, 
+/* 14 */  {{0x7E967248,0x39155B89}} /* +1.0283294335e-33 */, 
+/* 15 */  {{0x2031F115,0xB8CD159A}} /* -4.3761315763e-35 */, 
+/* 16 */  {{0x0FC3C81C,0xB8E8D9C6}} /* -1.4956458040e-34 */, 
+/* 17 */  {{0x8219F20D,0x38C0AC30}} /* +2.5086163140e-35 */, 
+/* 18 */  {{0x32EDCB95,0x38B36506}} /* +1.4590894790e-35 */, 
+/* 19 */  {{0x5932E7C2,0xB8FD57B0}} /* -3.5319791285e-34 */, 
+/* 20 */  {{0x91A2D916,0x38C73827}} /* +3.4936600564e-35 */, 
+/* 21 */  {{0x9EC5116C,0xB92FE60D}} /* -3.0717278111e-33 */, 
+/* 22 */  {{0x6A3B8AE2,0x3903AADF}} /* +4.7347715466e-34 */, 
+/* 23 */  {{0x71B87C3C,0xB88D6A01}} /* -2.7660872166e-36 */, 
+/* 24 */  {{0xEA5AC8E8,0xB8E17427}} /* -1.0504584084e-34 */, 
+/* 25 */  {{0xF776B005,0x38F4ED52}} /* +2.5190016806e-34 */, 
+/* 26 */  {{0x75D2B05C,0xB9265B23}} /* -2.1528054385e-33 */, 
+/* 27 */  {{0xAFEAB282,0xB8DA45DA}} /* -7.9062036715e-35 */, 
+/* 28 */  {{0xBD16D3D4,0x3912EF75}} /* +9.1170587963e-34 */, 
+/* 29 */  {{0xE904B022,0x390AB3D7}} /* +6.4283962392e-34 */, 
+/* 30 */  {{0x3F9F468B,0xB8EE688B}} /* -1.8301374849e-34 */, 
+/* 31 */  {{0x71A98823,0xB9225DF6}} /* -1.7686817787e-33 */, 
+/* 32 */  {{0x522BE0F8,0xB8CC82B0}} /* -4.2897836993e-35 */, 
+/* 33 */  {{0x88BB6A0B,0xB912AFE0}} /* -8.9974727841e-34 */, 
+/* 34 */  {{0x8640FAE5,0x38D4DC99}} /* +6.2778447830e-35 */, 
+/* 35 */  {{0x406A343B,0xB9016FC6}} /* -4.1977132916e-34 */, 
+/* 36 */  {{0x126FC74C,0x3909804C}} /* +6.1391811422e-34 */, 
+/* 37 */  {{0xE5B0956F,0x39051033}} /* +5.0708030720e-34 */, 
+/* 38 */  {{0x203B114C,0xB910CADC}} /* -8.0852567814e-34 */, 
+/* 39 */  {{0xF97ED36B,0x38EFCAC7}} /* +1.9134182531e-34 */, 
+/* 40 */  {{0xB51D77B4,0xB92464C0}} /* -1.9638289218e-33 */, 
+/* 41 */  {{0x2D4A03DE,0x391157F3}} /* +8.3506176591e-34 */, 
+/* 42 */  {{0x136A8DDE,0xB92BD929}} /* -2.6816921082e-33 */, 
+/* 43 */  {{0x035DF6B3,0x390F1514}} /* +7.4828003563e-34 */, 
+/* 44 */  {{0x19DB7E3B,0xB92606EC}} /* -2.1211268072e-33 */, 
+/* 45 */  {{0xCDA1B51D,0x393B104B}} /* +5.2122706777e-33 */, 
+/* 46 */  {{0xF88A520C,0x3935FB01}} /* +4.2332900876e-33 */, 
+/* 47 */  {{0x1940944D,0xB9189ED1}} /* -1.1854280852e-33 */, 
+/* 48 */  {{0x38D4794B,0xB914E8F2}} /* -1.0067772791e-33 */, 
+/* 49 */  {{0x73581CF5,0xB93DF07A}} /* -5.7661126209e-33 */, 
+/* 50 */  {{0x727CE10C,0xB939C22F}} /* -4.9609136744e-33 */, 
+/* 51 */  {{0x26E1A810,0xB8EF37D2}} /* -1.8788680655e-34 */, 
+/* 52 */  {{0x45155DAA,0x391A4251}} /* +1.2643273919e-33 */, 
+/* 53 */  {{0xA42D0A9A,0xB9126D2F}} /* -8.8720409776e-34 */, 
+/* 54 */  {{0x3DFAFFA5,0xB93CAF8B}} /* -5.5246684074e-33 */, 
+/* 55 */  {{0xA9A35831,0x3919C170}} /* +1.2400882522e-33 */, 
+/* 56 */  {{0xAE51E4B3,0xB924C2B3}} /* -1.9991686511e-33 */, 
+/* 57 */  {{0x0DE98917,0xB8DEFB7D}} /* -9.3234199178e-35 */, 
+/* 58 */  {{0x1ABE373B,0xB916EC39}} /* -1.1036900898e-33 */, 
+/* 59 */  {{0x4135ADBE,0x391C5BA4}} /* +1.3653868341e-33 */, 
+/* 60 */  {{0xD7179E60,0xB9112692}} /* -8.2577511316e-34 */, 
+/* 61 */  {{0xBCC93753,0x392F96B5}} /* +3.0418821818e-33 */, 
+};
+
+#endif  /* WORDS_BIGENDIAN */