crmf 0.1.1 → 0.1.2

data/ext/crlibm-1.0beta5/log2_accurate.c

@@ -0,0 +1,330 @@
+/*
+ * Correctly rounded base 2 logarithm
+ *
+ * Author : David Defour
+ *
+ * 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 "log2_accurate.h"
+
+/*
+ *  1) First reduction: exponent extraction      
+ *         E  
+ *  x = 2^   .(1+f)    with  0 <= f < 1
+ *
+ *  log2(x) = E + log2(1+f) where:
+ *     - log2(1+f) need to be evalute 
+ *  
+ *
+ *  2) Avoiding accuracy problem when E=-1 by testing
+ *   
+ *    if (1+f >= sqrt(2)) then 
+ *        1+f = (1+f)/2;  E = E+1; 
+ *    and,
+ *        log2(x) = (E+1) + log2((1+f)/2)
+ *
+ *    so now:      sqrt(2)/2 <= (1+f) < sqrt(2)
+ *
+ *
+ *  3) Second reduction: tabular reduction
+ *                   -4  
+ *   wi = 1 + i. 2^
+ *                                      1  
+ *   log2(1+f) = log2(wi) + log2 ( 1 + --- . (1 + f - wi) ) 
+ *                                     wi 
+ *
+ *   then |(1+f-wi)/wi| <= 2^-5 if we use rounded to nearest.
+ *
+ *  4) Computation:
+ *   a) Table lookup of: 
+ *        - ti    = log2(wi)
+ *        - inv_wi = 1/(wi)
+ *   b) Polynomial evaluation of:
+ *        - P(R) ~ log2(1 + R), where R = (1+f-wi) * inv_wi 
+ *
+ *                 -5 
+ *   with  |R| < 2^
+ *
+ *
+ *  5) Reconstruction:
+ *   log2(x) = E + t_i + P(R)
+ *
+ *
+ *   Note 1:
+ *	To guarantee log2(2^n)=n, where 2^n is normal, the rounding 
+ *	mode must set to Round-to-Nearest.
+ *
+ *   Special cases:
+ *	log2(x) is NaN with signal if x < 0; 
+ *	log2(+INF) is +INF with no signal; log2(0) is -INF with signal;
+ *	log2(NaN) is that NaN with no signal;
+ *	log2(2^N) = N 
+ *
+ */
+#define SQRT_2 1.4142135623730950489e0 
+
+
+/*************************************************************
+ *************************************************************
+ *               ROUNDED  TO NEAREST
+ *************************************************************
+ *************************************************************/
+double log2_rn(double x) {
+  scs_t R, res1, sc_exp;
+  scs_ptr inv_wi, ti;
+
+  db_number nb, nb2, wi, resd;
+  int i, E=0;
+
+  nb.d = x;
+  /* Filter cases */
+  if (nb.i[HI] < 0x00100000){        /* x < 2^(-1022)    */
+    if (((nb.i[HI] & 0x7fffffff)|nb.i[LO])==0)
+      return 1.0/0.0;                       /* log(+/-0) = -Inf */
+    if (nb.i[HI] < 0) 
+      return (x-x)/0;                       /* log(-x) = Nan    */
+
+    /* Subnormal number */
+    E    -= (SCS_NB_BITS*2); /* keep in mind that x is a subnormal number */ 
+    nb.d *=SCS_RADIX_TWO_DOUBLE;  /* make x as normal number     */         
+    /* We may just want add 2 to the scs number.index */
+    /* may be .... we will see */
+  }
+  if (nb.i[HI] >= 0x7ff00000)
+    return x+x;                             /* Inf or Nan       */
+
+  /* find n, nb.d such that sqrt(2)/2 < nb.d < sqrt(2) */
+  E += (nb.i[HI]>>20)-1023;
+  nb.i[HI] =  (nb.i[HI] & 0x000fffff) | 0x3ff00000;
+  if (nb.d > SQRT_2){
+    nb.d *= 0.5;
+    E++;
+  }
+
+  scs_set_si(sc_exp, E);
+
+  /* to normalize nb.d and round to nearest      */
+  /* +((2^4 - trunc(sqrt(2)/2) *2^4 )*2 + 1)/2^5 */ 
+  nb2.d = nb.d + norm_number.d; 
+  i = (nb2.i[HI] & 0x000fffff);
+  i = i >> 16; /* 0<= i <=11 */
+  
+  wi.d = (11+i)*(double)0.6250e-1;
+
+  /* (1+f-w_i) */
+  nb.d -= wi.d; 
+  
+  /* Table reduction */
+  ti     = table_ti_ptr[i]; 
+  inv_wi = table_inv_wi_ptr[i];
+
+ 
+  /* R = (1+f-w_i)/w_i */
+  scs_set_d(R, nb.d);
+  scs_mul(R, R, inv_wi);
+
+
+  /*
+   * Polynomial evaluation of log2(1 + R) with an error less than 2^(-130)
+   */
+  scs_mul(res1, constant_poly_ptr[0], R);
+  for(i=1; i<20; i++){
+    scs_add(res1, constant_poly_ptr[i], res1);
+    scs_mul(res1, res1, R);
+  }
+  scs_add(res1, res1, ti);
+  scs_add(res1, res1, sc_exp);
+  
+  scs_get_d(&resd.d, res1);  
+    
+  return resd.d;
+}
+
+
+
+
+
+/*************************************************************
+ *************************************************************
+ *               ROUNDED  TOWARD  -INFINITY
+ *************************************************************
+ *************************************************************/
+double log2_rd(double x) {
+  scs_t R, res1, sc_exp;
+  scs_ptr inv_wi, ti;
+
+  db_number nb, nb2, wi, resd;
+  int i, E=0;
+
+  nb.d = x;
+  /* Filter cases */
+  if (nb.i[HI] < 0x00100000){        /* x < 2^(-1022)    */
+    if (((nb.i[HI] & 0x7fffffff)|nb.i[LO])==0)
+      return 1.0/0.0;                       /* log(+/-0) = -Inf */
+    if (nb.i[HI] < 0) 
+      return (x-x)/0;                       /* log(-x) = Nan    */
+
+    /* Subnormal number */
+    E    -= (SCS_NB_BITS*2); /* keep in mind that x is a subnormal number */ 
+    nb.d *=SCS_RADIX_TWO_DOUBLE;  /* make x as normal number     */         
+    /* We may just want add 2 to the scs number.index */
+    /* may be .... we will see */
+  }
+  if (nb.i[HI] >= 0x7ff00000)
+    return x+x;                             /* Inf or Nan       */
+
+  /* find n, nb.d such that sqrt(2)/2 < nb.d < sqrt(2) */
+  E += (nb.i[HI]>>20)-1023;
+  nb.i[HI] =  (nb.i[HI] & 0x000fffff) | 0x3ff00000;
+  if (nb.d > SQRT_2){
+    nb.d *= 0.5;
+    E++;
+  }
+
+  scs_set_si(sc_exp, E);
+
+  /* to normalize nb.d and round to nearest      */
+  /* +((2^4 - trunc(sqrt(2)/2) *2^4 )*2 + 1)/2^5 */ 
+  nb2.d = nb.d + norm_number.d; 
+  i = (nb2.i[HI] & 0x000fffff);
+  i = i >> 16; /* 0<= i <=11 */
+  
+  wi.d = (11+i)*(double)0.6250e-1;
+
+  /* (1+f-w_i) */
+  nb.d -= wi.d; 
+  
+  /* Table reduction */
+  ti     = table_ti_ptr[i]; 
+  inv_wi = table_inv_wi_ptr[i];
+
+ 
+  /* R = (1+f-w_i)/w_i */
+  scs_set_d(R, nb.d);
+  scs_mul(R, R, inv_wi);
+
+
+  /*
+   * Polynomial evaluation of log2(1 + R) with an error less than 2^(-130)
+   */
+  scs_mul(res1, constant_poly_ptr[0], R);
+  for(i=1; i<20; i++){
+    scs_add(res1, constant_poly_ptr[i], res1);
+    scs_mul(res1, res1, R);
+  }
+  scs_add(res1, res1, ti);
+  scs_add(res1, res1, sc_exp);
+  
+  scs_get_d_minf(&resd.d, res1);  
+    
+  return resd.d;
+}
+
+
+
+
+
+
+/*************************************************************
+ *************************************************************
+ *               ROUNDED  TOWARD  +INFINITY
+ *************************************************************
+ *************************************************************/
+double log2_ru(double x) {
+  scs_t R, res1, sc_exp;
+  scs_ptr inv_wi, ti;
+
+  db_number nb, nb2, wi, resd;
+  int i, E=0;
+
+  nb.d = x;
+  /* Filter cases */
+  if (nb.i[HI] < 0x00100000){        /* x < 2^(-1022)    */
+    if (((nb.i[HI] & 0x7fffffff)|nb.i[LO])==0)
+      return 1.0/0.0;                       /* log(+/-0) = -Inf */
+    if (nb.i[HI] < 0) 
+      return (x-x)/0;                       /* log(-x) = Nan    */
+
+    /* Subnormal number */
+    E    -= (SCS_NB_BITS*2); /* keep in mind that x is a subnormal number */ 
+    nb.d *=SCS_RADIX_TWO_DOUBLE;  /* make x as normal number     */         
+    /* We may just want add 2 to the scs number.index */
+    /* may be .... we will see */
+  }
+  if (nb.i[HI] >= 0x7ff00000)
+    return x+x;                             /* Inf or Nan       */
+
+  /* find n, nb.d such that sqrt(2)/2 < nb.d < sqrt(2) */
+  E += (nb.i[HI]>>20)-1023;
+  nb.i[HI] =  (nb.i[HI] & 0x000fffff) | 0x3ff00000;
+  if (nb.d > SQRT_2){
+    nb.d *= 0.5;
+    E++;
+  }
+
+  scs_set_si(sc_exp, E);
+
+  /* to normalize nb.d and round to nearest      */
+  /* +((2^4 - trunc(sqrt(2)/2) *2^4 )*2 + 1)/2^5 */ 
+  nb2.d = nb.d + norm_number.d; 
+  i = (nb2.i[HI] & 0x000fffff);
+  i = i >> 16; /* 0<= i <=11 */
+  
+  wi.d = (11+i)*(double)0.6250e-1;
+
+  /* (1+f-w_i) */
+  nb.d -= wi.d; 
+  
+  /* Table reduction */
+  ti     = table_ti_ptr[i]; 
+  inv_wi = table_inv_wi_ptr[i];
+
+ 
+  /* R = (1+f-w_i)/w_i */
+  scs_set_d(R, nb.d);
+  scs_mul(R, R, inv_wi);
+
+
+  /*
+   * Polynomial evaluation of log2(1 + R) with an error less than 2^(-130)
+   */
+  scs_mul(res1, constant_poly_ptr[0], R);
+  for(i=1; i<20; i++){
+    scs_add(res1, constant_poly_ptr[i], res1);
+    scs_mul(res1, res1, R);
+  }
+  scs_add(res1, res1, ti);
+  scs_add(res1, res1, sc_exp);
+  
+  scs_get_d_pinf(&resd.d, res1);  
+    
+  return resd.d;
+}
+
+/*************************************************************
+ *************************************************************
+ *               ROUNDED  TOWARDS ZERO
+ *************************************************************
+ *************************************************************/
+double log2_rz(double x) {
+  if (x > 1) 
+    return log2_rd(x);
+  else 
+    return log2_ru(x);
+}

data/ext/crlibm-1.0beta5/log2_accurate.h

@@ -0,0 +1,261 @@
+#include "crlibm.h"
+#include "crlibm_private.h"
+/*
+ * Constant to compute the logarithm base 2. 
+ */
+#ifdef WORDS_BIGENDIAN
+static const db_number 
+  norm_number = {{0x3FD60000, 0x00000000}}; /* 11*2^(-5) */
+#else
+static const db_number 
+  norm_number = {{0x00000000, 0x3FD60000}}; /* 11*2^(-5) */
+#endif
+
+
+static const scs table_ti[13]=
+/* ~-5.405684e-01 */ 
+{{{0x2298ac1f, 0x33457c40, 0x1c141e66, 0x3eaaab29, 
+0x1030633d, 0x048bef17, 0x1a91d6a1, 0x22230522},
+DB_ONE,  -1,  -1 } 
+,
+/* ~-4.150375e-01 */ 
+{{0x1a8ff971, 0x20429786, 0x017fd3b7, 0x35f97452, 
+0x0bb6c306, 0x15c5da64, 0x3efe1069, 0x2fb2da05},
+DB_ONE,  -1,  -1 } 
+,
+/* ~-2.995603e-01 */ 
+{{0x132bfee3, 0x1c3b9a19, 0x1a24978d, 0x38d67cae, 
+0x3878c2df, 0x02d6ff98, 0x24e1a2a9, 0x1b4f917d},
+DB_ONE,  -1,  -1 } 
+,
+/* ~-1.926451e-01 */ 
+{{0x0c544c05, 0x17f7a64c, 0x3354dbf1, 0x1bec1a57, 
+0x2e31ce56, 0x2b7fe8e9, 0x20d510a7, 0x19e262f3},
+DB_ONE,  -1,  -1 } 
+,
+/* ~-9.310940e-02 */ 
+{{0x05f58125, 0x2cfbb4c6, 0x1ced1447, 0x38c2b4e4, 
+0x3edd56b0, 0x1637ed79, 0x2a14f4fe, 0x3db0ce67},
+DB_ONE,  -1,  -1 } 
+,
+/* ZERO         */
+{{0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000},
+{{0, 0}},  0,   1 }
+,
+/* ~8.746284e-02 */ 
+{{0x0598fdbe, 0x2c913167, 0x33314e09, 0x2144575a, 
+0x30f2941f, 0x0fab1d27, 0x3e612491, 0x0849fe51},
+DB_ONE,  -1,   1 } 
+,
+/* ~1.699250e-01 */ 
+{{0x0ae00d1c, 0x3f7ad0f3, 0x3d005890, 0x140d175b, 
+0x289279f3, 0x14744b36, 0x0203df2c, 0x209a4bf4},
+DB_ONE,  -1,   1 } 
+,
+/* ~2.479275e-01 */ 
+{{0x0fde0b5c, 0x204d0144, 0x1d46ccc5, 0x0f09de6b, 
+0x39267ab7, 0x1b5a9520, 0x35aacfb1, 0x311d7642},
+DB_ONE,  -1,   1 } 
+,
+/* ~3.219281e-01 */ 
+{{0x149a784b, 0x3346e2bf, 0x2492bf6f, 0x3d36bf6d, 
+0x0cd96c55, 0x3f8deceb, 0x14e91b6a, 0x32020b9e},
+DB_ONE,  -1,   1 } 
+,
+/* ~3.923174e-01 */ 
+{{0x191bba89, 0x07c5c22d, 0x0b2b5056, 0x2e1a7156, 
+0x06176ea2, 0x3eba3cb1, 0x202cdeee, 0x366ac306},
+DB_ONE,  -1,   1 } 
+,
+/* ~4.594316e-01 */ 
+{{0x1d6753e0, 0x0cba83bf, 0x23ebe199, 0x015554d6, 
+0x2fcf9cc2, 0x3b7410e8, 0x256e295e, 0x1ddcfadd},
+DB_ONE,  -1,   1 } 
+,
+/* ~5.235620e-01 */ 
+{{0x21820a01, 0x2b1d532c, 0x104aea53, 0x1b12ef0a, 
+0x2a0fca1a, 0x1dd6be1d, 0x0730b711, 0x35eaa979},
+DB_ONE,  -1,   1 } 
+};
+
+
+
+static const scs table_inv_wi[13]=
+/* ~1.454545e+00 */ 
+{{{0x00000001, 0x1d1745d1, 0x1d1745d1, 0x1d1745d1, 
+0x1d1745d1, 0x1d1745d1, 0x1d183e2a, 0x36835582},
+DB_ONE,   0,   1 } 
+,
+/* ~1.333333e+00 */ 
+{{0x00000001, 0x15555555, 0x15555555, 0x15555555, 
+0x15555555, 0x15555555, 0x15549b7e, 0x1a416c6b},
+DB_ONE,   0,   1 } 
+,
+/* ~1.230769e+00 */ 
+{{0x00000001, 0x0ec4ec4e, 0x313b13b1, 0x0ec4ec4e, 
+0x313b13b1, 0x0ec4ec4e, 0x313a6825, 0x3ab28b77},
+DB_ONE,   0,   1 } 
+,
+/* ~1.142857e+00 */ 
+{{0x00000001, 0x09249249, 0x09249249, 0x09249249, 
+0x09249249, 0x09249249, 0x09238b74, 0x26f620a6},
+DB_ONE,   0,   1 } 
+,
+/* ~1.066667e+00 */ 
+{{0x00000001, 0x04444444, 0x11111111, 0x04444444, 
+0x11111111, 0x04444444, 0x1111d60e, 0x1f0c9d58},
+DB_ONE,   0,   1 } 
+,
+/* ~1.000000e+00 */ 
+{{0x00000001, 0x00000000, 0x00000000, 0x00000000, 
+0x00000000, 0x00000000, 0x00000000, 0x00000000},
+DB_ONE,   0,   1 } 
+,
+/* ~9.411765e-01 */ 
+{{0x3c3c3c3c, 0x0f0f0f0f, 0x03c3c3c3, 0x30f0f0f0, 
+0x3c3c3c3c, 0x0f0f923d, 0x16e0e0a4, 0x3a84202f},
+DB_ONE,  -1,   1 } 
+,
+/* ~8.888889e-01 */ 
+{{0x38e38e38, 0x38e38e38, 0x38e38e38, 0x38e38e38, 
+0x38e38e38, 0x38e3946a, 0x2e0ee2c9, 0x0d6e0fbd},
+DB_ONE,  -1,   1 } 
+,
+/* ~8.421053e-01 */ 
+{{0x35e50d79, 0x10d79435, 0x39435e50, 0x35e50d79, 
+0x10d79435, 0x3943324d, 0x0637ea85, 0x131a67ba},
+DB_ONE,  -1,   1 } 
+,
+/* ~8.000000e-01 */ 
+{{0x33333333, 0x0ccccccc, 0x33333333, 0x0ccccccc, 
+0x33333333, 0x0ccccccc, 0x33333333, 0x0ccccccc},
+DB_ONE,  -1,   1 } 
+,
+/* ~7.619048e-01 */ 
+{{0x30c30c30, 0x30c30c30, 0x30c30c30, 0x30c30c30, 
+0x30c30c30, 0x30c2f1a4, 0x160958a1, 0x2b03bc88},
+DB_ONE,  -1,   1 } 
+,
+/* ~7.272727e-01 */ 
+{{0x2e8ba2e8, 0x2e8ba2e8, 0x2e8ba2e8, 0x2e8ba2e8, 
+0x2e8ba2e8, 0x2e8bcb74, 0x2d78b525, 0x00a1db67},
+DB_ONE,  -1,   1 } 
+,
+/* ~6.956522e-01 */ 
+{{0x2c8590b2, 0x0590b216, 0x10b21642, 0x321642c8, 
+0x1642c859, 0x02c8590b, 0x08590b21, 0x190b2164},
+DB_ONE,  -1,   1 } 
+};
+
+
+
+
+
+
+static const scs constant_poly[20]=
+/* ~-7.247187e-02 */ 
+{{{0x04a3610e, 0x3280f22f, 0x1de04b83, 0x13d0592c, 
+0x01c1f347, 0x0e59a808, 0x0bcf5cfa, 0x3009a167},
+DB_ONE,  -1,  -1 } 
+,
+/* ~7.626763e-02 */ 
+{{0x04e191a1, 0x27127aea, 0x2fb498c3, 0x3f8e3721, 
+0x2688ed52, 0x38503e4f, 0x3b216e42, 0x17d8666c},
+DB_ONE,  -1,   1 } 
+,
+/* ~-8.014898e-02 */ 
+{{0x05212933, 0x12c0276e, 0x1534c74e, 0x1ffc3802, 
+0x36935f91, 0x25fe848d, 0x2bade416, 0x110f0662},
+DB_ONE,  -1,  -1 } 
+,
+/* ~8.486372e-02 */ 
+{{0x056e6838, 0x35aa4f4a, 0x2ae2f258, 0x30768483, 
+0x2bc43d6e, 0x176d2fe1, 0x17488263, 0x30f7670b},
+DB_ONE,  -1,   1 } 
+,
+/* ~-9.016844e-02 */ 
+{{0x05c551da, 0x1166e535, 0x10625f98, 0x08af81ee, 
+0x04feb59e, 0x2906123e, 0x0b31f878, 0x0693beb1},
+DB_ONE,  -1,  -1 } 
+,
+/* ~9.617967e-02 */ 
+{{0x0627cec6, 0x20792d0d, 0x181b90ab, 0x0c8e3405, 
+0x1fe3b53f, 0x0f6d3b7a, 0x00eefd12, 0x0808849b},
+DB_ONE,  -1,   1 } 
+,
+/* ~-1.030496e-01 */ 
+{{0x06985d8a, 0x27a1d37d, 0x3fa3c0e9, 0x37e7d679, 
+0x0379ed1d, 0x25a15e16, 0x3ef8c491, 0x2414ab4f},
+DB_ONE,  -1,  -1 } 
+,
+/* ~1.109765e-01 */ 
+{{0x071a3d5a, 0x0d27a702, 0x138411a6, 0x15701cae, 
+0x31ef415d, 0x1985227d, 0x31a4c54c, 0x15d3a279},
+DB_ONE,  -1,   1 } 
+,
+/* ~-1.202246e-01 */ 
+{{0x07b1c277, 0x03a04150, 0x3be8d05b, 0x2f373cf4, 
+0x105c73c2, 0x0ee0272b, 0x0b2bf018, 0x1ad7026f},
+DB_ONE,  -1,  -1 } 
+,
+/* ~1.311541e-01 */ 
+{{0x0864d424, 0x328046b9, 0x132f0fc6, 0x2b14d554, 
+0x189d4b79, 0x2ec40035, 0x15083d44, 0x33a13b8c},
+DB_ONE,  -1,   1 } 
+,
+/* ~-1.442695e-01 */ 
+{{0x093bb628, 0x1df37fcf, 0x022eb69a, 0x0b325d1d, 
+0x0625c904, 0x1ccaa7ae, 0x0ed7ce1d, 0x3202ff74},
+DB_ONE,  -1,  -1 } 
+,
+/* ~1.602994e-01 */ 
+{{0x0a42589e, 0x2f80551e, 0x3eb3ec54, 0x1a1094cd, 
+0x23649796, 0x328d4019, 0x3f6371c6, 0x37a359a1},
+DB_ONE,  -1,   1 } 
+,
+/* ~-1.803369e-01 */ 
+{{0x0b8aa3b2, 0x25705fc2, 0x3bbedcca, 0x35a13588, 
+0x15c06cdc, 0x39fbf52c, 0x2b666451, 0x350d8287},
+DB_ONE,  -1,  -1 } 
+,
+/* ~2.060993e-01 */ 
+{{0x0d30bb15, 0x0f5bdb27, 0x3b23121c, 0x383c6bb0, 
+0x2f3b4fd2, 0x2dba0ce0, 0x0230a445, 0x306b1136},
+DB_ONE,  -1,   1 } 
+,
+/* ~-2.404492e-01 */ 
+{{0x0f6384ee, 0x07407fae, 0x24fe0aa6, 0x3c7aefd2, 
+0x12953456, 0x0d1d1991, 0x2af86714, 0x26b4c925},
+DB_ONE,  -1,  -1 } 
+,
+/* ~2.885390e-01 */ 
+{{0x12776c50, 0x3be6ff9e, 0x12ca7330, 0x1a6d448b, 
+0x1ef18433, 0x375e9366, 0x21f2efcf, 0x38ab1d93},
+DB_ONE,  -1,   1 } 
+,
+/* ~-3.606738e-01 */ 
+{{0x17154765, 0x0ae0bf85, 0x377d0ffd, 0x2836248a, 
+0x3b8e6858, 0x123f10ae, 0x0c65387c, 0x26048456},
+DB_ONE,  -1,  -1 } 
+,
+/* ~4.808983e-01 */ 
+{{0x1ec709dc, 0x0e80ff5d, 0x09fc1552, 0x0af12c97, 
+0x37bd6a2c, 0x3ebc8f65, 0x113a7c28, 0x1663571a},
+DB_ONE,  -1,   1 } 
+,
+/* ~-7.213475e-01 */ 
+{{0x2e2a8eca, 0x15c17f0b, 0x2efa1ffb, 0x10691d3d, 
+0x09a93721, 0x2d59e835, 0x1baea424, 0x28b120a0},
+DB_ONE,  -1,  -1 } 
+,
+/* ~1.442695e+00 */ 
+{{0x00000001, 0x1c551d94, 0x2b82fe17, 0x1df43ff6, 
+0x20d23a7c, 0x3b9ff352, 0x14d59cbf, 0x00fe1bdb},
+DB_ONE,   0,   1 } 
+};
+
+
+#define constant_poly_ptr (scs_ptr)&constant_poly
+#define table_ti_ptr      (scs_ptr)&table_ti
+#define table_inv_wi_ptr  (scs_ptr)&table_inv_wi

data/ext/crlibm-1.0beta5/log_accurate.c

@@ -0,0 +1,133 @@
+/*
+ * Correctly rounded logarithm
+ *
+ * Author : David Defour
+ *
+ * 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 "log_accurate.h"
+
+/*
+ *  1) First reduction: exponent extraction      
+ *         E  
+ *  x = 2^   .(1+f)    with  0 <= f < 1
+ *
+ *  log(x) = E.log(2) + log(1+f) where:
+ *     - log(2)   is tabulated
+ *     - log(1+f) need to be evaluated 
+ *  
+ *
+ *  2) Avoiding accuracy problem when E=-1 by testing
+ *   
+ *    if (1+f >= sqrt(2)) then 
+ *        1+f = (1+f)/2;  E = E+1; 
+ *    and,
+ *        log(x) = (E+1).log(2) + log((1+f)/2)
+ *
+ *    so now:      sqrt(2)/2 <= (1+f) < sqrt(2)
+ *
+ *
+ *  3) Second reduction: tabular reduction
+ *                   -4  
+ *   wi = 1 + i. 2^
+ *                                   1  
+ *   log(1+f) = log(wi) + log ( 1 + --- . (1 + f - wi) ) 
+ *                                   wi 
+ *
+ *   then |(1+f-wi)/wi| <= 2^-5 if we use rounded to nearest.
+ *
+ *  4) Computation:
+ *   a) Table lookup of: 
+ *        - ti    = log(wi)
+ *        - inv_wi = 1/(wi)
+ *   b) Polynomial evaluation of:
+ *        - P(R) ~ log(1 + R), where R = (1+f-wi) * inv_wi 
+ *
+ *                 -5 
+ *   with  |R| < 2^
+ *
+ *
+ *  5) Reconstruction:
+ *   log(x) = E.log(2) + t_i + P(R)
+ *
+ */
+
+
+
+
+void scs_log(scs_ptr res, db_number y, int E){ 
+  scs_t R, sc_ln2_times_E, res1, addi;
+  scs_ptr ti, inv_wi;
+  db_number z, wi;
+  int i;
+
+
+#if EVAL_PERF
+  crlibm_second_step_taken++;
+#endif
+
+
+  /* to normalize y.d and round to nearest      */
+  /* + (1-trunc(sqrt(2.)/2 * 2^(4))*2^(-4) )+2.^(-(4+1))*/ 
+  z.d = y.d + norm_number.d; 
+  i = (z.i[HI] & 0x000fffff);
+  i = i >> 16; /* 0<= i <=11 */
+  
+  
+  wi.d = ((double)(11+i))*0.0625;
+
+  /* (1+f-w_i) */
+  y.d -= wi.d; 
+  
+  /* Table reduction */
+  ti     = table_ti_ptr[i]; 
+  inv_wi = table_inv_wi_ptr[i];
+   
+  /* R = (1+f-w_i)/w_i */
+  scs_set_d(R, y.d);
+  scs_mul(R, R, inv_wi);
+
+ 
+  /*
+   * Polynomial evaluation of log(1 + R) with an error less than 2^(-130)
+   */
+   
+  scs_mul(res1, constant_poly_ptr[0], R);
+  for(i=1; i<20; i++){
+    scs_add(addi, constant_poly_ptr[i], res1);
+    scs_mul(res1, addi, R);
+  }
+
+  if(E==0){
+    scs_add(res, res1, ti);
+  }else{
+    /* sc_ln2_times_E = E*log(2)  */
+    scs_set(sc_ln2_times_E, sc_ln2_ptr);
+
+    if (E >= 0){
+      scs_mul_ui(sc_ln2_times_E, (unsigned int) E);
+    }else{
+      scs_mul_ui(sc_ln2_times_E, (unsigned int) -E);
+      sc_ln2_times_E->sign = -1;
+    }
+    scs_add(addi, res1, ti);
+    scs_add(res, addi, sc_ln2_times_E); 
+  }
+}
+