crmf 0.1.1 → 0.1.2

data/ext/crlibm-1.0beta5/exp_build_coeffs/exp_fast_table.c

@@ -0,0 +1,125 @@
+#include <stdio.h>
+
+#include <gmp.h>
+#include <mpfr.h>
+
+
+/*
+ * This program builds the tables used in the first step of the exponential
+ * Auteur : David Defour in a hurry             Date : 15/06/2003  
+ *
+ * build command:
+  gcc -I/usr/local/include/ -L/usr/local/lib/  exp_firststep_table.c -o exp_firststep_table -lgmp  -lmpfr 
+ */
+
+
+/* don't forget to check that */
+#define LITTLE_ENDIAN
+
+#ifdef LITTLE_ENDIAN
+#define HI(x) *(1+(int*)&x)
+#define LO(x) *(int*)&x
+#else
+#define HI(x) *(int*)&x
+#define LO(x) *(1+(int*)&x)
+#endif
+
+
+/* This is the number of bits considered to address the table. It can
+   be changed by the command-line second argument, but should stay to
+   8 for the exp as distributed */
+
+int PREC=8;
+
+
+
+#define CC_MPFR(d1, d2, a, res, rest, f, A, B){ \
+    mpfr_exp(res, a, GMP_RNDN); \
+    d1 = mpfr_get_d(res, GMP_RNDN);\
+    mpfr_set_d(rest, d1, GMP_RNDN);\
+    mpfr_sub(res, res, rest, GMP_RNDN);\
+    d2 = mpfr_get_d(res, GMP_RNDN); \
+    fprintf(f,"\t {{{0x%.8x, 0x%.8x}}, {{0x%.8x, 0x%.8x}}}", A(d1), B(d1), A(d2), B(d2));}
+
+
+void compute(FILE *f){
+  mpfr_t a, b, step, res, rest;
+  double d, d1, d2;
+  int i, end;
+
+  /* Memory allocation */
+  mpfr_init2(a,   300);
+  mpfr_init2(b,   300);
+  mpfr_init2(res, 300);
+  mpfr_init2(rest,300);
+  mpfr_init2(step,300);
+
+
+  /* Set step to 2^-PREC */
+  mpfr_set_ui(step, 1, GMP_RNDN);
+  mpfr_div_2ui(step, step, PREC, GMP_RNDN);
+
+  /* Compute bound of the interval [a, b] */
+  mpfr_set_ui(res, 2, GMP_RNDN);
+  mpfr_log(a, res, GMP_RNDN); 
+  mpfr_div_2ui(a, a, 1, GMP_RNDN);
+
+  mpfr_mul_2ui(a, a, PREC, GMP_RNDN);
+  mpfr_round(a, a);
+  d = mpfr_get_d(a, GMP_RNDN);
+  mpfr_div_2ui(a, a, PREC, GMP_RNDN);
+
+  mpfr_neg(a, a, GMP_RNDN);
+  mpfr_set(b, a, GMP_RNDN);
+  
+  end = (2 * d) + 1; /* +1 because this range is centered in 0 and '0' need to be taken into account */
+
+  fprintf(f,"static const scs_db_number tab_exp[%d][2] = { \n",end);
+  fprintf(f,"#ifdef WORDS_BIGENDIAN\n");
+
+  for(i=0; i<(end-1) ; i++){
+    CC_MPFR(d1, d2, a, res, rest, f, HI, LO);
+    fprintf(f,", \n");
+    mpfr_add(a, a, step, GMP_RNDN);
+  }
+  CC_MPFR(d1, d2, a, res, rest, f, HI, LO);
+
+  fprintf(f,"\n#else \n");
+  mpfr_set(a, b, GMP_RNDN);
+  for(i=0; i<(end-1) ; i++){
+    CC_MPFR(d1, d2, a, res, rest, f, LO, HI);
+    fprintf(f,", \n");
+    mpfr_add(a, a, step, GMP_RNDN);
+  }
+  CC_MPFR(d1, d2, a, res, rest, f, LO, HI);
+
+  fprintf(f,"\n#endif \n}; \n\n");
+
+
+  mpfr_clear(a);  
+  mpfr_clear(b);
+  mpfr_clear(res); 
+  mpfr_clear(rest); 
+  mpfr_clear(step);
+} 
+
+
+
+int main (int argc, char *argv[]) 
+{ 
+  FILE *f;
+
+  if (argc == 3) 
+    PREC = atoi(argv[2]);
+  
+  f = fopen (argv[1], "w");
+  if (f== NULL){
+    fprintf(stderr," Cannot open file %s  \n", argv[1]);    exit(1);
+  }
+
+  compute(f);
+
+  fclose(f);
+  return 0;
+}
+

data/ext/crlibm-1.0beta5/expm1-standalone.c

@@ -0,0 +1,119 @@
+#include "crlibm.h"
+#include "crlibm_private.h"
+#include "triple-double.h"
+#include "expm1.h"
+
+#define AVOID_FMA 0
+
+
+extern void expm1_direct_td(double *expm1h, double *expm1m, double *expm1l, 
+	         	    double x, double xSqHalfh, double xSqHalfl, double xSqh, double xSql, int expoX);
+
+extern void expm1_common_td(double *expm1h, double *expm1m, double *expm1l, 
+			    double rh, double rm, double rl, 
+			    double tbl1h, double tbl1m, double tbl1l, 
+			    double tbl2h, double tbl2m, double tbl2l, 
+			    int M);
+
+
+/* Function expm1_13
+
+   Computes exp(x)-1 with an accuracy of 120 bits (128 for |x| <= 2^(-5)) as
+
+   (expm1h + expm1m + expm1l) \approx exp(x) - 1
+
+   There is no special case handling. 
+
+   |x| is supposed to be greater than 2^(-53)
+
+   x is supposed to be in the range -37...709
+
+   The triple-double exph + expm + expl is non-overlapping.
+
+*/
+
+void expm1_13(double *expm1h, double *expm1m, double *expm1l, double x) {
+  db_number xdb, shiftedXMultdb;
+  int xIntHi, expoX, k, M, index1, index2;
+  double xSqh, xSql, xSqHalfh, xSqHalfl;
+  double t1, t2;
+  double msLog2Div2LMultKh, msLog2Div2LMultKm, msLog2Div2LMultKl;
+  double xMultLog2InvMult2L, shiftedXMult, kd, rh, rm, rl;
+  double tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l;
+
+  
+  xdb.d = x; 
+  xIntHi = xdb.i[HI] & 0x7fffffff;
+
+  /* Test if we have |x| <= 1/4-1/2ulp(1/4) for knowing if we use exp(x) or approximate directly */
+
+  if (xIntHi < DIRECTINTERVALBOUND) {
+    /* We approximate expm1 directly after a range reduction as follows
+
+       expm1(x) = (expm1(x/2) + 2) * expm1(x/2)
+
+       We perform the range reduction in such a way that finally |x| < 1/32 
+    */
+
+    /* Extract the exponent of |x| and add 5 (2^5 = 32) */
+    expoX = ((xIntHi & 0x7ff00000) >> 20) - (1023 - 5);
+    
+    /* If this particularily biased exponent expoX is negative, we are already less than 1/32 */
+    if (expoX >= 0) {
+      /* If we are here, we must perform range reduction */
+
+
+      /* We multiply x by 2^(-expoX-1) by bit manipulation 
+	 x cannot be denormalized so there is no danger
+      */
+      xdb.i[HI] += (-expoX-1) << 20;
+
+      /* We reassign the new x and maintain xIntHi */
+
+      xIntHi = xdb.i[HI] & 0x7fffffff;
+      x = xdb.d;
+    }
+    
+    /* Here, we have always |x| < 1/32 */
+
+
+    /* Double precision evaluation steps and one double-double step */
+
+    Mul12(&xSqh,&xSql,x,x);
+    xSqHalfh = 0.5 * xSqh;
+    xSqHalfl = 0.5 * xSql;
+
+    expm1_direct_td(expm1h, expm1m, expm1l, x, xSqHalfh, xSqHalfl, xSqh, xSql, expoX);
+       
+  } else {
+
+    /* If we are here, we can use expm1(x) = exp(x) - 1 */
+    
+    /* Range reduction - exact part: compute k as double and as int */
+    
+    xMultLog2InvMult2L = x * log2InvMult2L;
+    shiftedXMult = xMultLog2InvMult2L + shiftConst;
+    kd = shiftedXMult - shiftConst;
+    shiftedXMultdb.d = shiftedXMult;
+    k = shiftedXMultdb.i[LO];
+    M = k >> 12;
+    index1 = k & INDEXMASK1;
+    index2 = (k & INDEXMASK2) >> 6;
+    
+    
+    Mul133(&msLog2Div2LMultKh,&msLog2Div2LMultKm,&msLog2Div2LMultKl,kd,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+    t1 = x + msLog2Div2LMultKh;
+    Add12Cond(rh,t2,t1,msLog2Div2LMultKm);
+    Add12Cond(rm,rl,t2,msLog2Div2LMultKl);
+    
+    tbl1h = twoPowerIndex1[index1].hi;
+    tbl1m = twoPowerIndex1[index1].mi;
+    tbl2h = twoPowerIndex2[index2].hi;
+    tbl2m = twoPowerIndex2[index2].mi;
+    tbl1l = twoPowerIndex1[index1].lo;
+    tbl2l = twoPowerIndex2[index2].lo;
+    
+    expm1_common_td(expm1h, expm1m, expm1l, rh, rm, rl, tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l, M); 
+    
+  }
+}