crmf 0.1.1 → 0.1.3

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

@@ -0,0 +1,2515 @@
+/*
+ * Correctly rounded expm1 = e^x - 1
+ *
+ * Author : Christoph Lauter (ENS Lyon)
+ * One bug fix by 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.h"
+#include "crlibm_private.h"
+#include "triple-double.h"
+#include "expm1.h"
+#ifdef BUILD_INTERVAL_FUNCTIONS
+#include "interval.h"
+#endif
+
+
+
+#define DEBUG 0
+
+
+void expm1_direct_td(double *expm1h, double *expm1m, double *expm1l, 
+		     double x, double xSqHalfh, double xSqHalfl, double xSqh, double xSql, int expoX) {
+  double highPoly, tt1h, t1h, t1l, t2h, t2l, t3h, t3l, t4h, t4l, t5h, t5l, t6h, t6l;
+  double tt6h, tt6m, tt6l, t7h, t7m, t7l, lowPolyh, lowPolym, lowPolyl;
+  double fullHighPolyh, fullHighPolym, fullHighPolyl, polyh, polym, polyl;
+  double xCubeh, xCubem, xCubel, tt7h, tt7m, tt7l, t8h, t8m, t8l;
+  double expm1hover, expm1mover, expm1lover;
+  double r1h, r1m, r1l, r2h, r2m, r2l, r3h, r3m, r3l;
+  double rr1h, rr1m, rr1l, rr2h, rr2m, rr2l, rr3h, rr3m, rr3l;
+  double fullHighPolyhover, fullHighPolymover, fullHighPolylover;
+
+  /* Double precision evaluation steps */
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    highPoly = FMA(FMA(FMA(FMA(accuDirectpolyC15h ,x,accuDirectpolyC14h),x,accuDirectpolyC13h),x,
+                               accuDirectpolyC12h),x,accuDirectpolyC11h);
+#else
+    highPoly = accuDirectpolyC11h + x * (accuDirectpolyC12h + x * (accuDirectpolyC13h + x * (
+	       accuDirectpolyC14h + x *  accuDirectpolyC15h)));
+#endif
+
+    tt1h = x * highPoly;
+
+    /* Triple-double steps for x + x^2/2 and x^3*/
+
+    Add123(&lowPolyh,&lowPolym,&lowPolyl,x,xSqHalfh,xSqHalfl);                     /* infty - 52/53 */
+    Mul123(&xCubeh,&xCubem,&xCubel,x,xSqh,xSql);                                   /* 154 - 47/53 */
+
+
+    /* Double-double evaluation steps */
+
+    Add12(t1h,t1l,accuDirectpolyC10h,tt1h);
+    
+    MulAdd212(&t2h,&t2l,accuDirectpolyC9h,accuDirectpolyC9m,x,t1h,t1l);
+    MulAdd212(&t3h,&t3l,accuDirectpolyC8h,accuDirectpolyC8m,x,t2h,t2l);
+    MulAdd212(&t4h,&t4l,accuDirectpolyC7h,accuDirectpolyC7m,x,t3h,t3l);
+    MulAdd212(&t5h,&t5l,accuDirectpolyC6h,accuDirectpolyC6m,x,t4h,t4l);
+    MulAdd212(&t6h,&t6l,accuDirectpolyC5h,accuDirectpolyC5m,x,t5h,t5l);
+
+    /* Triple-double evaluation steps */
+
+    Mul123(&tt6h,&tt6m,&tt6l,x,t6h,t6l);                                          /* 154 - 47/53 */
+    Add233(&t7h,&t7m,&t7l,accuDirectpolyC4h,accuDirectpolyC4m,tt6h,tt6m,tt6l);    /* 150 - 43/53 */
+   
+    Mul133(&tt7h,&tt7m,&tt7l,x,t7h,t7m,t7l);                                      /* 143 - 38/53 */
+    Add33(&t8h,&t8m,&t8l,accuDirectpolyC3h,accuDirectpolyC3m,accuDirectpolyC3l,tt7h,tt7m,tt7l); /* 135 - 33/53 */
+
+    Mul33(&fullHighPolyhover,&fullHighPolymover,&fullHighPolylover,xCubeh,xCubem,xCubel,t8h,t8m,t8l); /* 130 - 29/53 */
+
+    Renormalize3(&fullHighPolyh,&fullHighPolym,&fullHighPolyl,
+		 fullHighPolyhover,fullHighPolymover,fullHighPolylover);                     /* infty - 52/53 */
+
+    Add33(&polyh,&polym,&polyl,lowPolyh,lowPolym,lowPolyl,fullHighPolyh,fullHighPolym,fullHighPolyl);
+                                                                                             /* 149 - 47/53 */
+
+    /* Reconstruction steps */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+                                                                             
+      Add133(&r1h,&r1m,&r1l,2,polyh,polym,polyl);                             
+      Mul33(&rr1h,&rr1m,&rr1l,r1h,r1m,r1l,polyh,polym,polyl);
+      if (expoX >= 1) {
+
+	/* Second reconstruction step */
+	Add133(&r2h,&r2m,&r2l,2,rr1h,rr1m,rr1l);
+	Mul33(&rr2h,&rr2m,&rr2l,r2h,r2m,r2l,rr1h,rr1m,rr1l);
+
+	if (expoX >= 2) {
+
+	  /* Third reconstruction step */
+	  Add133(&r3h,&r3m,&r3l,2,rr2h,rr2m,rr2l);
+	  Mul33(&rr3h,&rr3m,&rr3l,r3h,r3m,r3l,rr2h,rr2m,rr2l);
+
+	  /* expoX may be maximally 2 */
+
+	  expm1hover = rr3h;
+	  expm1mover = rr3m;
+	  expm1lover = rr3l;
+
+	} else {
+	  expm1hover = rr2h;
+	  expm1mover = rr2m;
+	  expm1lover = rr2l;
+	}
+
+      } else {
+	expm1hover = rr1h;
+	expm1mover = rr1m;
+	expm1lover = rr1l;
+      }
+
+    } else {
+      expm1hover = polyh;
+      expm1mover = polym;
+      expm1lover = polyl;
+    }
+
+    /* Renormalize before returning */
+
+    Renormalize3(expm1h,expm1m,expm1l,expm1hover,expm1mover,expm1lover);
+}
+
+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) {
+  double highPoly, highPolyMulth, highPolyMultm, highPolyMultl;
+  double rhSquareh, rhSquarel, rhSquareHalfh, rhSquareHalfl;
+  double rhCubeh, rhCubem, rhCubel;
+  double t1h, t1l, t2h, t2l, t3h, t3l, t4h, t4l, t5, t6;
+  double lowPolyh, lowPolym, lowPolyl;
+  double ph, pm, pl, phnorm, pmnorm, rmlMultPh, rmlMultPl;
+  double qh, ql, fullPolyh, fullPolym, fullPolyl;
+  double polyWithTbl1h, polyWithTbl1m, polyWithTbl1l;
+  double polyAddOneh,polyAddOnem,polyAddOnel;
+  double polyWithTablesh, polyWithTablesm, polyWithTablesl;
+  double exph, expm, expl, expm1hover, expm1mover, expm1lover;
+  db_number polyWithTableshdb, polyWithTablesmdb, polyWithTablesldb;
+
+  /* Polynomial approximation - double precision steps */
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+  highPoly = FMA(FMA(accuCommonpolyC7h,rh,accuCommonpolyC6h),rh,accuCommonpolyC5h);
+#else
+  highPoly = accuCommonpolyC5h + rh * (accuCommonpolyC6h + rh * accuCommonpolyC7h);
+#endif
+
+  /* Polynomial approximation - double-double precision steps */
+
+  Mul12(&t1h,&t1l,rh,highPoly);
+  Add22(&t2h,&t2l,accuCommonpolyC4h,accuCommonpolyC4m,t1h,t1l);
+  Mul122(&t3h,&t3l,rh,t2h,t2l);
+  Add22(&t4h,&t4l,accuCommonpolyC3h,accuCommonpolyC3m,t3h,t3l);
+
+  Mul12(&rhSquareh,&rhSquarel,rh,rh);
+  Mul123(&rhCubeh,&rhCubem,&rhCubel,rh,rhSquareh,rhSquarel);
+
+  rhSquareHalfh = 0.5 * rhSquareh;
+  rhSquareHalfl = 0.5 * rhSquarel;  
+
+  /* Polynomial approximation - triple-double precision steps */
+
+  Renormalize3(&lowPolyh,&lowPolym,&lowPolyl,rh,rhSquareHalfh,rhSquareHalfl);
+
+  Mul233(&highPolyMulth,&highPolyMultm,&highPolyMultl,t4h,t4l,rhCubeh,rhCubem,rhCubel);
+
+  Add33(&ph,&pm,&pl,lowPolyh,lowPolym,lowPolyl,highPolyMulth,highPolyMultm,highPolyMultl);
+
+  /* Reconstruction */
+
+  Add12(phnorm,pmnorm,ph,pm);
+  Mul22(&rmlMultPh,&rmlMultPl,rm,rl,phnorm,pmnorm);
+  Add22(&qh,&ql,rm,rl,rmlMultPh,rmlMultPl);
+
+  Add233Cond(&fullPolyh,&fullPolym,&fullPolyl,qh,ql,ph,pm,pl);
+  Add12(polyAddOneh,t5,1,fullPolyh);
+  Add12Cond(polyAddOnem,t6,t5,fullPolym);
+  polyAddOnel = t6 + fullPolyl;
+  Mul33(&polyWithTbl1h,&polyWithTbl1m,&polyWithTbl1l,tbl1h,tbl1m,tbl1l,polyAddOneh,polyAddOnem,polyAddOnel);
+  Mul33(&polyWithTablesh,&polyWithTablesm,&polyWithTablesl,
+	tbl2h,tbl2m,tbl2l,
+	polyWithTbl1h,polyWithTbl1m,polyWithTbl1l);
+
+  /* Multiplication by 2^(M) 
+
+     We perform it in integer to overcome the non-representability of 2^(1024) 
+     This case is possible for M = 1024 and polyWithTablesh < 1
+
+     The overlap in the triple-double polyWithTables[hml] stays unchanged.
+
+  */
+
+  polyWithTableshdb.d = polyWithTablesh;
+  polyWithTablesmdb.d = polyWithTablesm;
+  polyWithTablesldb.d = polyWithTablesl;
+
+  /* TODO FIXME probably at least the first of these tests is useless,
+     but I leave this to Christoph to check it. Let us be
+     conservative. Florent  */
+  if(polyWithTableshdb.d!=0)
+    polyWithTableshdb.i[HI] += M << 20;
+  if(polyWithTablesmdb.d!=0)
+    polyWithTablesmdb.i[HI] += M << 20;
+  if(polyWithTablesldb.d!=0)
+    polyWithTablesldb.i[HI] += M << 20;
+
+  exph = polyWithTableshdb.d;
+  expm = polyWithTablesmdb.d;
+  expl = polyWithTablesldb.d;
+
+  /* Subtraction of -1 
+     
+     We use a conditional Add133 
+  */
+
+  Add133Cond(&expm1hover,&expm1mover,&expm1lover,-1,exph,expm,expl);
+
+  /* Renormalization */    
+
+  Renormalize3(expm1h,expm1m,expm1l,expm1hover,expm1mover,expm1lover);
+
+}
+
+
+double expm1_rn(double x) {
+  db_number xdb, shiftedXMultdb, polyTblhdb, polyTblmdb;
+  int xIntHi, expoX, k, M, index1, index2;
+  double highPoly, tt1h, t1h, t1l, xSqh, xSql, xSqHalfh, xSqHalfl, xCubeh, xCubel, t2h, t2l, templ, tt3h, tt3l;
+  double polyh, polyl, expm1h, expm1m, expm1l;
+  double r1h, r1l, r1t, rr1h, rr1l;
+  double r2h, r2l, r2t, rr2h, rr2l;
+  double r3h, r3l, r3t, rr3h, rr3l;
+  double xMultLog2InvMult2L, shiftedXMult, kd, s1, s2, s3, s4, s5, rh, rm, rl;
+  double rhSquare, rhC3, rhSquareHalf, monomialCube, rhFour, monomialFour;
+  double tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l;
+  double highPolyWithSquare, tablesh, tablesl, t8, t9, t10, t11, t12, t13;
+  double exph, expm, t1, t2, t3;
+  double msLog2Div2LMultKh, msLog2Div2LMultKm, msLog2Div2LMultKl;
+  double middlePoly, doublePoly;
+
+
+  xdb.d = x; 
+
+  /* Strip off the sign of x for the following tests */
+
+  xIntHi = xdb.i[HI] & 0x7fffffff;
+
+  /* Test if we are so small that we can return (a corrected) x as correct rounding */
+  if (xIntHi < RETURNXBOUND) {
+    return x;
+  }
+
+
+  /* Filter out special cases like overflow, -1 in result, infinities and NaNs 
+     The filters are not sharp, we have positive arguments that flow through
+  */
+  if (xIntHi >= SIMPLEOVERFLOWBOUND) {
+    /* Test if we are +/-inf or NaN */
+    if (xIntHi >= 0x7ff00000) {
+      /* Test if NaN */
+      if (((xIntHi & 0x000fffff) | xdb.i[LO]) != 0) {
+	/* NaN */
+	return x+x;  /* return NaN */
+      }
+      /* Test if +inf or -inf */
+      if (xdb.i[HI] > 0) {
+	/* +inf */
+	return x+x;  /* return +inf */
+      }
+      
+      /* If we are here, we are -inf */
+      return -1.0;
+    }
+
+    /* If we are here, we are overflowed or a common case that flows through */
+
+    /* Test if we are actually overflowed */
+    if (x > OVERFLOWBOUND) {
+      return LARGEST * LARGEST;  /* return +inf and set flag */
+    }
+  }
+  
+  /* Test if we know already that we are -1.0 (+ correction depending on rounding mode) in result */
+  if (x < MINUSONEBOUND) {
+    return -1.0;
+  }
+
+  /* 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);
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    middlePoly = FMA(quickDirectpolyC5h,x,quickDirectpolyC4h);
+#else
+    middlePoly = quickDirectpolyC4h + x * quickDirectpolyC5h;
+#endif
+
+    doublePoly = middlePoly;
+
+    /* Special path: for small |x| we can truncate the polynomial */
+
+    if (xIntHi > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly = FMA(FMA(FMA(quickDirectpolyC9h ,x,quickDirectpolyC8h),x,
+                             quickDirectpolyC7h),x,quickDirectpolyC6h);
+#else
+      highPoly = quickDirectpolyC6h + x * (quickDirectpolyC7h + x * (
+	         quickDirectpolyC8h + x *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare = xSqh * highPoly;
+
+      doublePoly = middlePoly + highPolyWithSquare;
+
+    }
+    
+    /* Double-double evaluation steps */
+    tt1h = x * doublePoly;
+
+    xSqHalfh = 0.5 * xSqh;
+    xSqHalfl = 0.5 * xSql;
+    Add12(t2h,templ,x,xSqHalfh);
+    t2l = templ + xSqHalfl;
+    
+    Add12(t1h,t1l,quickDirectpolyC3h,tt1h);
+    Mul122(&xCubeh,&xCubel,x,xSqh,xSql);
+    Mul22(&tt3h,&tt3l,xCubeh,xCubel,t1h,t1l);
+
+    Add22(&polyh,&polyl,t2h,t2l,tt3h,tt3l);
+
+    /* Reconstruction */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h,r1t,2,polyh);
+      r1l = r1t + polyl;
+      Mul22(&rr1h,&rr1l,r1h,r1l,polyh,polyl);
+
+      if (expoX >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h,r2t,2,rr1h);
+	r2l = r2t + rr1l;
+	Mul22(&rr2h,&rr2l,r2h,r2l,rr1h,rr1l);
+
+	if (expoX >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h,r3t,2,rr2h);
+	  r3l = r3t + rr2l;
+	  Mul22(&rr3h,&rr3l,r3h,r3l,rr2h,rr2l);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h = rr3h;
+	  expm1m = rr3l;
+
+	} else {
+	  expm1h = rr2h;
+	  expm1m = rr2l;
+	}
+
+      } else {
+	expm1h = rr1h;
+	expm1m = rr1l;
+      }
+
+    } else {
+      expm1h = polyh;
+      expm1m = polyl;
+    }
+
+    /* Rounding test */
+    if(expm1h == (expm1h + (expm1m * ROUNDCSTDIRECTRN)))
+     return expm1h;
+   else 
+     {
+
+#if DEBUG 
+       printf("Launch accurate phase (direct interval)\n");
+#endif
+
+       expm1_direct_td(&expm1h, &expm1m, &expm1l, x, xSqHalfh, xSqHalfl, xSqh, xSql, expoX);
+      
+       ReturnRoundToNearest3(expm1h, expm1m, expm1l);
+
+     } /* Accurate phase launched */
+
+    /* We cannot be here, since we return in all cases before */
+  }
+
+  /* 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;
+
+  /* Range reduction - part affected by error - must be redone in accurate phase */
+  Mul12(&s1,&s2,msLog2Div2Lh,kd);
+  s3 = kd * msLog2Div2Lm;
+  s4 = s2 + s3; 
+  s5 = x + s1;
+  Add12Cond(rh,rm,s5,s4);
+
+  /* Table reads - read only two double-doubles by now */
+  tbl1h = twoPowerIndex1[index1].hi;
+  tbl1m = twoPowerIndex1[index1].mi;
+  tbl2h = twoPowerIndex2[index2].hi;
+  tbl2m = twoPowerIndex2[index2].mi;
+
+  /* Quick phase starts here */
+
+  rhSquare = rh * rh;
+  rhC3 = quickCommonpolyC3h * rh;
+
+  rhSquareHalf = 0.5 * rhSquare;
+  monomialCube = rhC3 * rhSquare;
+  rhFour = rhSquare * rhSquare;
+
+  monomialFour = quickCommonpolyC4h * rhFour;
+  
+  highPoly = monomialCube + monomialFour;
+
+  highPolyWithSquare = rhSquareHalf + highPoly;
+  
+  /* Reconstruction: integration of table values */
+  
+  Mul22(&tablesh,&tablesl,tbl1h,tbl1m,tbl2h,tbl2m);
+
+  t8 = rm + highPolyWithSquare;
+  t9 = rh + t8;
+
+  t10 = tablesh * t9;
+  
+  Add12(t11,t12,tablesh,t10);
+  t13 = t12 + tablesl;
+  Add12(polyTblhdb.d,polyTblmdb.d,t11,t13);
+  
+  /* Reconstruction: multiplication by 2^M */
+
+  /* Implement the multiplication by addition to overcome the
+     problem of the non-representability of 2^1024 (M = 1024)
+     This case is possible if polyTblhdb.d < 1
+  */
+  
+  polyTblhdb.i[HI] += M << 20;
+  if(polyTblmdb.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+	  polyTblmdb.i[HI] += M << 20;
+
+  exph = polyTblhdb.d;
+  expm = polyTblmdb.d;
+
+  /* Subtraction of 1 
+
+     Testing if the operation is necessary is more expensive than 
+     performing it in any case.
+
+     We may cancellate at most 2 bits in the subtraction for 
+     arguments 1/4 <= x <= ln(2) (0.25 <= x <= 0.69) 
+     We must therefore use conditional Add12s
+
+     Since we perform a subtraction, we may not have addition overflow towards +inf
+
+  */
+
+  Add12Cond(t1,t2,-1,exph);
+  t3 = t2 + expm;
+  Add12Cond(expm1h,expm1m,t1,t3);
+
+
+  /* Rounding test */
+  if(expm1h == (expm1h + (expm1m * ROUNDCSTCOMMONRN))) {
+    return expm1h;
+  } else {
+    /* Rest of argument reduction for accurate phase */
+    
+    Mul133(&msLog2Div2LMultKh,&msLog2Div2LMultKm,&msLog2Div2LMultKl,kd,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+    t1 = x + msLog2Div2LMultKh;
+    Add12Cond(rh,t2,t1,msLog2Div2LMultKm);
+    Add12Cond(rm,rl,t2,msLog2Div2LMultKl);
+    
+    /* Table reads for accurate phase */
+    tbl1l = twoPowerIndex1[index1].lo;
+    tbl2l = twoPowerIndex2[index2].lo;
+
+#if DEBUG 
+       printf("Launch accurate phase (common interval)\n");
+#endif
+    
+    /* Call accurate phase */
+    expm1_common_td(&expm1h, &expm1m, &expm1l, rh, rm, rl, tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l, M); 
+    
+    /* Final rounding */
+
+    ReturnRoundToNearest3(expm1h, expm1m, expm1l);
+  } /* Accurate phase launched */
+  
+  /* We cannot be here since we return before in any case */
+}
+
+double expm1_rd(double x) {
+  db_number xdb, shiftedXMultdb, polyTblhdb, polyTblmdb;
+  int xIntHi, expoX, k, M, index1, index2;
+  double highPoly, tt1h, t1h, t1l, xSqh, xSql, xSqHalfh, xSqHalfl, xCubeh, xCubel, t2h, t2l, templ, tt3h, tt3l;
+  double polyh, polyl, expm1h, expm1m, expm1l;
+  double r1h, r1l, r1t, rr1h, rr1l;
+  double r2h, r2l, r2t, rr2h, rr2l;
+  double r3h, r3l, r3t, rr3h, rr3l;
+  double xMultLog2InvMult2L, shiftedXMult, kd, s1, s2, s3, s4, s5, rh, rm, rl;
+  double rhSquare, rhC3, rhSquareHalf, monomialCube, rhFour, monomialFour;
+  double tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l;
+  double highPolyWithSquare, tablesh, tablesl, t8, t9, t10, t11, t12, t13;
+  double exph, expm, t1, t2, t3;
+  double msLog2Div2LMultKh, msLog2Div2LMultKm, msLog2Div2LMultKl;
+  double middlePoly, doublePoly;
+
+  xdb.d = x; 
+
+  /* Strip off the sign of x for the following tests */
+
+  xIntHi = xdb.i[HI] & 0x7fffffff;
+
+  /* Test if we are so small that we can return (a corrected) x as correct rounding */
+  if (xIntHi < RETURNXBOUND) {
+    /* The only algebraic result is 0 for x = +/- 0; in this case, we can return x = +/- 0
+       The truncation rest x^2/2 + x^3/6 + ... is always positive 
+       but less than 1 ulp in this case, so we round down by returning x
+    */
+    return x;
+  }
+
+
+  /* Filter out special cases like overflow, -1 in result, infinities and NaNs 
+     The filters are not sharp, we have positive arguments that flow through
+  */
+  if (xIntHi >= SIMPLEOVERFLOWBOUND) {
+    /* Test if we are +/-inf or NaN */
+    if (xIntHi >= 0x7ff00000) {
+      /* Test if NaN */
+      if (((xIntHi & 0x000fffff) | xdb.i[LO]) != 0) {
+	/* NaN */
+	return x+x;  /* return NaN */
+      }
+      /* Test if +inf or -inf */
+      if (xdb.i[HI] > 0) {
+	/* +inf */
+	return x+x;  /* return +inf */
+      }
+      
+      /* If we are here, we are -inf */
+      return -1.0;
+    }
+
+    /* If we are here, we are overflowed or a common case that flows through */
+
+    /* Test if we are actually overflowed */
+    if (x > OVERFLOWBOUND) {
+      /* We would be overflowed but as we are rounding downwards
+	 the nearest number lesser than the exact result is the greatest 
+	 normal. In any case, we must raise the inexact flag.
+      */
+      return LARGEST * (1.0 + SMALLEST);
+    }
+  }
+  
+  /* Test if we know already that we are -1.0 (+ correction depending on rounding mode) in result */
+  if (x < MINUSONEBOUND) {
+    /* We round down, so we are -1.0 */
+    return -1.0;
+  }
+
+  /* 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);
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    middlePoly = FMA(quickDirectpolyC5h,x,quickDirectpolyC4h);
+#else
+    middlePoly = quickDirectpolyC4h + x * quickDirectpolyC5h;
+#endif
+
+    doublePoly = middlePoly;
+
+    /* Special path: for small |x| we can truncate the polynomial */
+
+    if (xIntHi > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly = FMA(FMA(FMA(quickDirectpolyC9h ,x,quickDirectpolyC8h),x,
+                             quickDirectpolyC7h),x,quickDirectpolyC6h);
+#else
+      highPoly = quickDirectpolyC6h + x * (quickDirectpolyC7h + x * (
+	         quickDirectpolyC8h + x *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare = xSqh * highPoly;
+
+      doublePoly = middlePoly + highPolyWithSquare;
+
+    }
+    
+    /* Double-double evaluation steps */
+    tt1h = x * doublePoly;
+
+    xSqHalfh = 0.5 * xSqh;
+    xSqHalfl = 0.5 * xSql;
+    Add12(t2h,templ,x,xSqHalfh);
+    t2l = templ + xSqHalfl;
+    
+    Add12(t1h,t1l,quickDirectpolyC3h,tt1h);
+    Mul122(&xCubeh,&xCubel,x,xSqh,xSql);
+    Mul22(&tt3h,&tt3l,xCubeh,xCubel,t1h,t1l);
+
+    Add22(&polyh,&polyl,t2h,t2l,tt3h,tt3l);
+
+    /* Reconstruction */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h,r1t,2,polyh);
+      r1l = r1t + polyl;
+      Mul22(&rr1h,&rr1l,r1h,r1l,polyh,polyl);
+
+      if (expoX >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h,r2t,2,rr1h);
+	r2l = r2t + rr1l;
+	Mul22(&rr2h,&rr2l,r2h,r2l,rr1h,rr1l);
+
+	if (expoX >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h,r3t,2,rr2h);
+	  r3l = r3t + rr2l;
+	  Mul22(&rr3h,&rr3l,r3h,r3l,rr2h,rr2l);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h = rr3h;
+	  expm1m = rr3l;
+
+	} else {
+	  expm1h = rr2h;
+	  expm1m = rr2l;
+	}
+
+      } else {
+	expm1h = rr1h;
+	expm1m = rr1l;
+      }
+
+    } else {
+      expm1h = polyh;
+      expm1m = polyl;
+    }
+
+    /* Rounding test */
+    TEST_AND_RETURN_RD(expm1h, expm1m, ROUNDCSTDIRECTRD);
+    {
+      expm1_direct_td(&expm1h, &expm1m, &expm1l, x, xSqHalfh, xSqHalfl, xSqh, xSql, expoX);
+      
+      ReturnRoundDownwards3(expm1h, expm1m, expm1l);
+      
+    } /* Accurate phase launched */
+
+    /* We cannot be here, since we return in all cases before */
+  }
+
+  /* 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;
+
+  /* Range reduction - part affected by error - must be redone in accurate phase */
+  Mul12(&s1,&s2,msLog2Div2Lh,kd);
+  s3 = kd * msLog2Div2Lm;
+  s4 = s2 + s3; 
+  s5 = x + s1;
+  Add12Cond(rh,rm,s5,s4);
+
+  /* Table reads - read only two double-doubles by now */
+  tbl1h = twoPowerIndex1[index1].hi;
+  tbl1m = twoPowerIndex1[index1].mi;
+  tbl2h = twoPowerIndex2[index2].hi;
+  tbl2m = twoPowerIndex2[index2].mi;
+
+  /* Quick phase starts here */
+
+  rhSquare = rh * rh;
+  rhC3 = quickCommonpolyC3h * rh;
+
+  rhSquareHalf = 0.5 * rhSquare;
+  monomialCube = rhC3 * rhSquare;
+  rhFour = rhSquare * rhSquare;
+
+  monomialFour = quickCommonpolyC4h * rhFour;
+  
+  highPoly = monomialCube + monomialFour;
+
+  highPolyWithSquare = rhSquareHalf + highPoly;
+  
+  /* Reconstruction: integration of table values */
+  
+  Mul22(&tablesh,&tablesl,tbl1h,tbl1m,tbl2h,tbl2m);
+
+  t8 = rm + highPolyWithSquare;
+  t9 = rh + t8;
+
+  t10 = tablesh * t9;
+  
+  Add12(t11,t12,tablesh,t10);
+  t13 = t12 + tablesl;
+  Add12(polyTblhdb.d,polyTblmdb.d,t11,t13);
+  
+  /* Reconstruction: multiplication by 2^M */
+
+  /* Implement the multiplication by addition to overcome the
+     problem of the non-representability of 2^1024 (M = 1024)
+     This case is possible if polyTblhdb.d < 1
+  */
+  
+  polyTblhdb.i[HI] += M << 20;
+  if(polyTblmdb.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+	  polyTblmdb.i[HI] += M << 20;
+
+  exph = polyTblhdb.d;
+  expm = polyTblmdb.d;
+
+  /* Subtraction of 1 
+
+     Testing if the operation is necessary is more expensive than 
+     performing it in any case.
+
+     We may cancellate at most 2 bits in the subtraction for 
+     arguments 1/4 <= x <= ln(2) (0.25 <= x <= 0.69) 
+     We must therefore use conditional Add12s
+
+     Since we perform a subtraction, we may not have addition overflow towards +inf
+
+  */
+
+  Add12Cond(t1,t2,-1,exph);
+  t3 = t2 + expm;
+  Add12Cond(expm1h,expm1m,t1,t3);
+
+
+  /* Rounding test */
+  TEST_AND_RETURN_RD(expm1h, expm1m, ROUNDCSTCOMMONRD);
+  {
+    /* Rest of argument reduction for accurate phase */
+    
+    Mul133(&msLog2Div2LMultKh,&msLog2Div2LMultKm,&msLog2Div2LMultKl,kd,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+    t1 = x + msLog2Div2LMultKh;
+    Add12Cond(rh,t2,t1,msLog2Div2LMultKm);
+    Add12Cond(rm,rl,t2,msLog2Div2LMultKl);
+    
+    /* Table reads for accurate phase */
+    tbl1l = twoPowerIndex1[index1].lo;
+    tbl2l = twoPowerIndex2[index2].lo;
+    
+    /* Call accurate phase */
+    expm1_common_td(&expm1h, &expm1m, &expm1l, rh, rm, rl, tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l, M); 
+    
+    /* Final rounding */
+
+    ReturnRoundDownwards3(expm1h, expm1m, expm1l);
+  } /* Accurate phase launched */
+  
+  /* We cannot be here since we return before in any case */
+}
+
+double expm1_ru(double x) {
+  db_number xdb, shiftedXMultdb, polyTblhdb, polyTblmdb;
+  int xIntHi, expoX, k, M, index1, index2;
+  double highPoly, tt1h, t1h, t1l, xSqh, xSql, xSqHalfh, xSqHalfl, xCubeh, xCubel, t2h, t2l, templ, tt3h, tt3l;
+  double polyh, polyl, expm1h, expm1m, expm1l;
+  double r1h, r1l, r1t, rr1h, rr1l;
+  double r2h, r2l, r2t, rr2h, rr2l;
+  double r3h, r3l, r3t, rr3h, rr3l;
+  double xMultLog2InvMult2L, shiftedXMult, kd, s1, s2, s3, s4, s5, rh, rm, rl;
+  double rhSquare, rhC3, rhSquareHalf, monomialCube, rhFour, monomialFour;
+  double tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l;
+  double highPolyWithSquare, tablesh, tablesl, t8, t9, t10, t11, t12, t13;
+  double exph, expm, t1, t2, t3;
+  double msLog2Div2LMultKh, msLog2Div2LMultKm, msLog2Div2LMultKl;
+  double middlePoly, doublePoly;
+
+  xdb.d = x; 
+
+  /* Strip off the sign of x for the following tests */
+
+  xIntHi = xdb.i[HI] & 0x7fffffff;
+
+  /* Test if we are so small that we can return (a corrected) x as correct rounding */
+  if (xIntHi < RETURNXBOUND) {
+    /* The only algebraic result is 0 for x = +/-0; in this case, we return x = +/-0
+       The truncation rest x^2/2 + x^3/6 + ... is always positive 
+       but less than 1 ulp in this case, so we round by adding 1 ulp 
+    */
+    
+    if (x == 0.0) return x;
+
+    if (xdb.i[HI] & 0x80000000) {
+      /* x is negative 
+	 We add 1 ulp by subtracting 1 in long
+      */
+      xdb.l--;
+    } else {
+      /* x is positive 
+	 We add 1 ulp by adding 1 in long
+      */
+      xdb.l++;
+    }
+    return xdb.d;
+  }
+
+
+  /* Filter out special cases like overflow, -1 in result, infinities and NaNs 
+     The filters are not sharp, we have positive arguments that flow through
+  */
+  if (xIntHi >= SIMPLEOVERFLOWBOUND) {
+    /* Test if we are +/-inf or NaN */
+    if (xIntHi >= 0x7ff00000) {
+      /* Test if NaN */
+      if (((xIntHi & 0x000fffff) | xdb.i[LO]) != 0) {
+	/* NaN */
+	return x+x;  /* return NaN */
+      }
+      /* Test if +inf or -inf */
+      if (xdb.i[HI] > 0) {
+	/* +inf */
+	return x+x;  /* return +inf */
+      }
+      
+      /* If we are here, we are -inf */
+      return -1.0;
+    }
+
+    /* If we are here, we are overflowed or a common case that flows through */
+
+    /* Test if we are actually overflowed */
+    if (x > OVERFLOWBOUND) {
+      return LARGEST * LARGEST;  /* return +inf and set flag */
+    }
+  }
+  
+  /* Test if we know already that we are -1.0 (+ correction depending on rounding mode) in result */
+  if (x < MINUSONEBOUND) {
+    /* Round up so we are -1.0 + 1ulp */
+    return MINUSONEPLUSONEULP;
+  }
+
+  /* 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);
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    middlePoly = FMA(quickDirectpolyC5h,x,quickDirectpolyC4h);
+#else
+    middlePoly = quickDirectpolyC4h + x * quickDirectpolyC5h;
+#endif
+
+    doublePoly = middlePoly;
+
+    /* Special path: for small |x| we can truncate the polynomial */
+
+    if (xIntHi > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly = FMA(FMA(FMA(quickDirectpolyC9h ,x,quickDirectpolyC8h),x,
+                             quickDirectpolyC7h),x,quickDirectpolyC6h);
+#else
+      highPoly = quickDirectpolyC6h + x * (quickDirectpolyC7h + x * (
+	         quickDirectpolyC8h + x *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare = xSqh * highPoly;
+
+      doublePoly = middlePoly + highPolyWithSquare;
+
+    }
+    
+    /* Double-double evaluation steps */
+    tt1h = x * doublePoly;
+
+    xSqHalfh = 0.5 * xSqh;
+    xSqHalfl = 0.5 * xSql;
+    Add12(t2h,templ,x,xSqHalfh);
+    t2l = templ + xSqHalfl;
+    
+    Add12(t1h,t1l,quickDirectpolyC3h,tt1h);
+    Mul122(&xCubeh,&xCubel,x,xSqh,xSql);
+    Mul22(&tt3h,&tt3l,xCubeh,xCubel,t1h,t1l);
+
+    Add22(&polyh,&polyl,t2h,t2l,tt3h,tt3l);
+
+    /* Reconstruction */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h,r1t,2,polyh);
+      r1l = r1t + polyl;
+      Mul22(&rr1h,&rr1l,r1h,r1l,polyh,polyl);
+
+      if (expoX >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h,r2t,2,rr1h);
+	r2l = r2t + rr1l;
+	Mul22(&rr2h,&rr2l,r2h,r2l,rr1h,rr1l);
+
+	if (expoX >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h,r3t,2,rr2h);
+	  r3l = r3t + rr2l;
+	  Mul22(&rr3h,&rr3l,r3h,r3l,rr2h,rr2l);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h = rr3h;
+	  expm1m = rr3l;
+
+	} else {
+	  expm1h = rr2h;
+	  expm1m = rr2l;
+	}
+
+      } else {
+	expm1h = rr1h;
+	expm1m = rr1l;
+      }
+
+    } else {
+      expm1h = polyh;
+      expm1m = polyl;
+    }
+
+    /* Rounding test */
+    TEST_AND_RETURN_RU(expm1h, expm1m, ROUNDCSTDIRECTRD);
+    {
+      expm1_direct_td(&expm1h, &expm1m, &expm1l, x, xSqHalfh, xSqHalfl, xSqh, xSql, expoX);
+      
+      ReturnRoundUpwards3(expm1h, expm1m, expm1l);
+
+    } /* Accurate phase launched */
+
+    /* We cannot be here, since we return in all cases before */
+  }
+
+  /* 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;
+
+  /* Range reduction - part affected by error - must be redone in accurate phase */
+  Mul12(&s1,&s2,msLog2Div2Lh,kd);
+  s3 = kd * msLog2Div2Lm;
+  s4 = s2 + s3; 
+  s5 = x + s1;
+  Add12Cond(rh,rm,s5,s4);
+
+  /* Table reads - read only two double-doubles by now */
+  tbl1h = twoPowerIndex1[index1].hi;
+  tbl1m = twoPowerIndex1[index1].mi;
+  tbl2h = twoPowerIndex2[index2].hi;
+  tbl2m = twoPowerIndex2[index2].mi;
+
+  /* Quick phase starts here */
+
+  rhSquare = rh * rh;
+  rhC3 = quickCommonpolyC3h * rh;
+
+  rhSquareHalf = 0.5 * rhSquare;
+  monomialCube = rhC3 * rhSquare;
+  rhFour = rhSquare * rhSquare;
+
+  monomialFour = quickCommonpolyC4h * rhFour;
+  
+  highPoly = monomialCube + monomialFour;
+
+  highPolyWithSquare = rhSquareHalf + highPoly;
+  
+  /* Reconstruction: integration of table values */
+  
+  Mul22(&tablesh,&tablesl,tbl1h,tbl1m,tbl2h,tbl2m);
+
+  t8 = rm + highPolyWithSquare;
+  t9 = rh + t8;
+
+  t10 = tablesh * t9;
+  
+  Add12(t11,t12,tablesh,t10);
+  t13 = t12 + tablesl;
+  Add12(polyTblhdb.d,polyTblmdb.d,t11,t13);
+  
+  /* Reconstruction: multiplication by 2^M */
+
+  /* Implement the multiplication by addition to overcome the
+     problem of the non-representability of 2^1024 (M = 1024)
+     This case is possible if polyTblhdb.d < 1
+  */
+  
+  polyTblhdb.i[HI] += M << 20;
+  if(polyTblmdb.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+	  polyTblmdb.i[HI] += M << 20;
+
+  exph = polyTblhdb.d;
+  expm = polyTblmdb.d;
+
+  /* Subtraction of 1 
+
+     Testing if the operation is necessary is more expensive than 
+     performing it in any case.
+
+     We may cancellate at most 2 bits in the subtraction for 
+     arguments 1/4 <= x <= ln(2) (0.25 <= x <= 0.69) 
+     We must therefore use conditional Add12s
+
+     Since we perform a subtraction, we may not have addition overflow towards +inf
+
+  */
+
+  Add12Cond(t1,t2,-1,exph);
+  t3 = t2 + expm;
+  Add12Cond(expm1h,expm1m,t1,t3);
+
+
+  /* Rounding test */
+  TEST_AND_RETURN_RU(expm1h, expm1m, ROUNDCSTCOMMONRD);
+  {
+    /* Rest of argument reduction for accurate phase */
+    
+    Mul133(&msLog2Div2LMultKh,&msLog2Div2LMultKm,&msLog2Div2LMultKl,kd,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+    t1 = x + msLog2Div2LMultKh;
+    Add12Cond(rh,t2,t1,msLog2Div2LMultKm);
+    Add12Cond(rm,rl,t2,msLog2Div2LMultKl);
+    
+    /* Table reads for accurate phase */
+    tbl1l = twoPowerIndex1[index1].lo;
+    tbl2l = twoPowerIndex2[index2].lo;
+    
+    /* Call accurate phase */
+    expm1_common_td(&expm1h, &expm1m, &expm1l, rh, rm, rl, tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l, M); 
+    
+    /* Final rounding */
+
+    ReturnRoundUpwards3(expm1h, expm1m, expm1l);
+  } /* Accurate phase launched */
+  
+  /* We cannot be here since we return before in any case */
+}
+ 
+double expm1_rz(double x) {
+  db_number xdb, shiftedXMultdb, polyTblhdb, polyTblmdb;
+  int xIntHi, expoX, k, M, index1, index2;
+  double highPoly, tt1h, t1h, t1l, xSqh, xSql, xSqHalfh, xSqHalfl, xCubeh, xCubel, t2h, t2l, templ, tt3h, tt3l;
+  double polyh, polyl, expm1h, expm1m, expm1l;
+  double r1h, r1l, r1t, rr1h, rr1l;
+  double r2h, r2l, r2t, rr2h, rr2l;
+  double r3h, r3l, r3t, rr3h, rr3l;
+  double xMultLog2InvMult2L, shiftedXMult, kd, s1, s2, s3, s4, s5, rh, rm, rl;
+  double rhSquare, rhC3, rhSquareHalf, monomialCube, rhFour, monomialFour;
+  double tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l;
+  double highPolyWithSquare, tablesh, tablesl, t8, t9, t10, t11, t12, t13;
+  double exph, expm, t1, t2, t3;
+  double msLog2Div2LMultKh, msLog2Div2LMultKm, msLog2Div2LMultKl;
+  double middlePoly, doublePoly;
+
+  xdb.d = x; 
+
+  /* Strip off the sign of x for the following tests */
+
+  xIntHi = xdb.i[HI] & 0x7fffffff;
+
+  /* Test if we are so small that we can return (a corrected) x as correct rounding */
+  if (xIntHi < RETURNXBOUND) {
+    /* The only algebraic result is 0 for x = +/- 0; in this case, we can return x = +/- 0
+       expm1 is positive for positive x, negative for negative x
+       The truncation rest x^2/2 + x^3/6 + ... is always positive 
+       but less than 1 ulp in this case, so we round as follows:
+       
+       - x is positive => expm1 is positive => round downwards => truncate by returning x
+       - x is negative => expm1 is negative => round upwards => add 1 ulp
+    */
+
+    if (x == 0.0) return x;
+
+    if (xdb.i[HI] & 0x80000000) {
+      /* x is negative 
+	 We add 1 ulp by subtracting 1 in long
+      */
+      xdb.l--;
+      return xdb.d;
+    } else {
+      /* x is positive 
+	 We do nothing (see above)
+      */
+      return x;
+    }
+  }
+
+
+  /* Filter out special cases like overflow, -1 in result, infinities and NaNs 
+     The filters are not sharp, we have positive arguments that flow through
+  */
+  if (xIntHi >= SIMPLEOVERFLOWBOUND) {
+    /* Test if we are +/-inf or NaN */
+    if (xIntHi >= 0x7ff00000) {
+      /* Test if NaN */
+      if (((xIntHi & 0x000fffff) | xdb.i[LO]) != 0) {
+	/* NaN */
+	return x+x;  /* return NaN */
+      }
+      /* Test if +inf or -inf */
+      if (xdb.i[HI] > 0) {
+	/* +inf */
+	return x+x;  /* return +inf */
+      }
+      
+      /* If we are here, we are -inf */
+      return -1.0;
+    }
+
+    /* If we are here, we are overflowed or a common case that flows through */
+
+    /* Test if we are actually overflowed */
+    if (x > OVERFLOWBOUND) {
+      /* We would be overflowed but as we are rounding towards zero, i.e. downwards,
+	 the nearest number lesser than the exact result is the greatest 
+	 normal. In any case, we must raise the inexact flag.
+      */
+      return LARGEST * (1.0 + SMALLEST);
+    }
+  }
+  
+  /* Test if we know already that we are -1.0 (+ correction depending on rounding mode) in result */
+  if (x < MINUSONEBOUND) {
+    /* We round towards zero, i.e. upwards, so we return -1.0+1ulp */
+    return MINUSONEPLUSONEULP;
+  }
+
+  /* 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);
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    middlePoly = FMA(quickDirectpolyC5h,x,quickDirectpolyC4h);
+#else
+    middlePoly = quickDirectpolyC4h + x * quickDirectpolyC5h;
+#endif
+
+    doublePoly = middlePoly;
+
+    /* Special path: for small |x| we can truncate the polynomial */
+
+    if (xIntHi > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly = FMA(FMA(FMA(quickDirectpolyC9h ,x,quickDirectpolyC8h),x,
+                             quickDirectpolyC7h),x,quickDirectpolyC6h);
+#else
+      highPoly = quickDirectpolyC6h + x * (quickDirectpolyC7h + x * (
+	         quickDirectpolyC8h + x *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare = xSqh * highPoly;
+
+      doublePoly = middlePoly + highPolyWithSquare;
+
+    }
+    
+    /* Double-double evaluation steps */
+    tt1h = x * doublePoly;
+
+    xSqHalfh = 0.5 * xSqh;
+    xSqHalfl = 0.5 * xSql;
+    Add12(t2h,templ,x,xSqHalfh);
+    t2l = templ + xSqHalfl;
+    
+    Add12(t1h,t1l,quickDirectpolyC3h,tt1h);
+    Mul122(&xCubeh,&xCubel,x,xSqh,xSql);
+    Mul22(&tt3h,&tt3l,xCubeh,xCubel,t1h,t1l);
+
+    Add22(&polyh,&polyl,t2h,t2l,tt3h,tt3l);
+
+    /* Reconstruction */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h,r1t,2,polyh);
+      r1l = r1t + polyl;
+      Mul22(&rr1h,&rr1l,r1h,r1l,polyh,polyl);
+
+      if (expoX >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h,r2t,2,rr1h);
+	r2l = r2t + rr1l;
+	Mul22(&rr2h,&rr2l,r2h,r2l,rr1h,rr1l);
+
+	if (expoX >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h,r3t,2,rr2h);
+	  r3l = r3t + rr2l;
+	  Mul22(&rr3h,&rr3l,r3h,r3l,rr2h,rr2l);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h = rr3h;
+	  expm1m = rr3l;
+
+	} else {
+	  expm1h = rr2h;
+	  expm1m = rr2l;
+	}
+
+      } else {
+	expm1h = rr1h;
+	expm1m = rr1l;
+      }
+
+    } else {
+      expm1h = polyh;
+      expm1m = polyl;
+    }
+
+    /* Rounding test */
+    TEST_AND_RETURN_RZ(expm1h, expm1m, ROUNDCSTDIRECTRD);
+    {
+      expm1_direct_td(&expm1h, &expm1m, &expm1l, x, xSqHalfh, xSqHalfl, xSqh, xSql, expoX);
+      
+      ReturnRoundTowardsZero3(expm1h, expm1m, expm1l);
+
+    } /* Accurate phase launched */
+
+    /* We cannot be here, since we return in all cases before */
+  }
+
+  /* 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;
+
+  /* Range reduction - part affected by error - must be redone in accurate phase */
+  Mul12(&s1,&s2,msLog2Div2Lh,kd);
+  s3 = kd * msLog2Div2Lm;
+  s4 = s2 + s3; 
+  s5 = x + s1;
+  Add12Cond(rh,rm,s5,s4);
+
+  /* Table reads - read only two double-doubles by now */
+  tbl1h = twoPowerIndex1[index1].hi;
+  tbl1m = twoPowerIndex1[index1].mi;
+  tbl2h = twoPowerIndex2[index2].hi;
+  tbl2m = twoPowerIndex2[index2].mi;
+
+  /* Quick phase starts here */
+
+  rhSquare = rh * rh;
+  rhC3 = quickCommonpolyC3h * rh;
+
+  rhSquareHalf = 0.5 * rhSquare;
+  monomialCube = rhC3 * rhSquare;
+  rhFour = rhSquare * rhSquare;
+
+  monomialFour = quickCommonpolyC4h * rhFour;
+  
+  highPoly = monomialCube + monomialFour;
+
+  highPolyWithSquare = rhSquareHalf + highPoly;
+  
+  /* Reconstruction: integration of table values */
+  
+  Mul22(&tablesh,&tablesl,tbl1h,tbl1m,tbl2h,tbl2m);
+
+  t8 = rm + highPolyWithSquare;
+  t9 = rh + t8;
+
+  t10 = tablesh * t9;
+  
+  Add12(t11,t12,tablesh,t10);
+  t13 = t12 + tablesl;
+  Add12(polyTblhdb.d,polyTblmdb.d,t11,t13);
+  
+  /* Reconstruction: multiplication by 2^M */
+
+  /* Implement the multiplication by addition to overcome the
+     problem of the non-representability of 2^1024 (M = 1024)
+     This case is possible if polyTblhdb.d < 1
+  */
+  
+  polyTblhdb.i[HI] += M << 20; 
+  if(polyTblmdb.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+	  polyTblmdb.i[HI] += M << 20;
+
+  exph = polyTblhdb.d;
+  expm = polyTblmdb.d;
+
+  /* Subtraction of 1 
+
+     Testing if the operation is necessary is more expensive than 
+     performing it in any case.
+
+     We may cancellate at most 2 bits in the subtraction for 
+     arguments 1/4 <= x <= ln(2) (0.25 <= x <= 0.69) 
+     We must therefore use conditional Add12s
+
+     Since we perform a subtraction, we may not have addition overflow towards +inf
+
+  */
+
+  Add12Cond(t1,t2,-1,exph);
+  t3 = t2 + expm;
+  Add12Cond(expm1h,expm1m,t1,t3);
+
+
+  /* Rounding test */
+  TEST_AND_RETURN_RZ(expm1h, expm1m, ROUNDCSTCOMMONRD);
+  {
+
+    /* Rest of argument reduction for accurate phase */
+    
+    Mul133(&msLog2Div2LMultKh,&msLog2Div2LMultKm,&msLog2Div2LMultKl,kd,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+    t1 = x + msLog2Div2LMultKh;
+    Add12Cond(rh,t2,t1,msLog2Div2LMultKm);
+    Add12Cond(rm,rl,t2,msLog2Div2LMultKl);
+    
+    /* Table reads for accurate phase */
+    tbl1l = twoPowerIndex1[index1].lo;
+    tbl2l = twoPowerIndex2[index2].lo;
+    
+    /* Call accurate phase */
+    expm1_common_td(&expm1h, &expm1m, &expm1l, rh, rm, rl, tbl1h, tbl1m, tbl1l, tbl2h, tbl2m, tbl2l, M); 
+    
+    /* Final rounding */
+
+    ReturnRoundTowardsZero3(expm1h, expm1m, expm1l);
+  } /* Accurate phase launched */
+  
+  /* We cannot be here since we return before in any case */
+}
+
+#ifdef BUILD_INTERVAL_FUNCTIONS
+interval j_expm1(interval x)
+{
+  interval res;
+  db_number xdb_inf, shiftedXMultdb_inf, polyTblhdb_inf, polyTblmdb_inf;
+  int xIntHi_inf, expoX_inf, k_inf, M_inf, index1_inf, index2_inf;
+  double x_inf, x_sup;
+  double res_inf,res_sup;
+  double restemp_inf, restemp_sup;
+  double highPoly_inf, tt1h_inf, t1h_inf, t1l_inf, xSqh_inf, xSql_inf, xSqHalfh_inf, xSqHalfl_inf, xCubeh_inf, xCubel_inf, t2h_inf, t2l_inf, templ_inf, tt3h_inf, tt3l_inf;
+  double polyh_inf, polyl_inf, expm1h_inf, expm1m_inf, expm1l_inf;
+  double r1h_inf, r1l_inf, r1t_inf, rr1h_inf, rr1l_inf;
+  double r2h_inf, r2l_inf, r2t_inf, rr2h_inf, rr2l_inf;
+  double r3h_inf, r3l_inf, r3t_inf, rr3h_inf, rr3l_inf;
+  double xMultLog2InvMult2L_inf, shiftedXMult_inf, kd_inf, s1_inf, s2_inf, s3_inf, s4_inf, s5_inf, rh_inf, rm_inf, rl_inf;
+  double rhSquare_inf, rhC3_inf, rhSquareHalf_inf, monomialCube_inf, rhFour_inf, monomialFour_inf;
+  double tbl1h_inf, tbl1m_inf, tbl1l_inf, tbl2h_inf, tbl2m_inf, tbl2l_inf;
+  double highPolyWithSquare_inf, tablesh_inf, tablesl_inf, t8_inf, t9_inf, t10_inf, t11_inf, t12_inf, t13_inf;
+  double exph_inf, expm_inf, t1_inf, t2_inf, t3_inf;
+  double msLog2Div2LMultKh_inf, msLog2Div2LMultKm_inf, msLog2Div2LMultKl_inf;
+  double middlePoly_inf, doublePoly_inf;
+  int roundable;
+  int infDone, supDone;
+  infDone=0; supDone=0;
+
+  db_number xdb_sup, shiftedXMultdb_sup, polyTblhdb_sup, polyTblmdb_sup;
+  int xIntHi_sup, expoX_sup, k_sup, M_sup, index1_sup, index2_sup;
+  double highPoly_sup, tt1h_sup, t1h_sup, t1l_sup, xSqh_sup, xSql_sup, xSqHalfh_sup, xSqHalfl_sup, xCubeh_sup, xCubel_sup, t2h_sup, t2l_sup, templ_sup, tt3h_sup, tt3l_sup;
+  double polyh_sup, polyl_sup, expm1h_sup, expm1m_sup, expm1l_sup;
+  double r1h_sup, r1l_sup, r1t_sup, rr1h_sup, rr1l_sup;
+  double r2h_sup, r2l_sup, r2t_sup, rr2h_sup, rr2l_sup;
+  double r3h_sup, r3l_sup, r3t_sup, rr3h_sup, rr3l_sup;
+  double xMultLog2InvMult2L_sup, shiftedXMult_sup, kd_sup, s1_sup, s2_sup, s3_sup, s4_sup, s5_sup, rh_sup, rm_sup, rl_sup;
+  double rhSquare_sup, rhC3_sup, rhSquareHalf_sup, monomialCube_sup, rhFour_sup, monomialFour_sup;
+  double tbl1h_sup, tbl1m_sup, tbl1l_sup, tbl2h_sup, tbl2m_sup, tbl2l_sup;
+  double highPolyWithSquare_sup, tablesh_sup, tablesl_sup, t8_sup, t9_sup, t10_sup, t11_sup, t12_sup, t13_sup;
+  double exph_sup, expm_sup, t1_sup, t2_sup, t3_sup;
+  double msLog2Div2LMultKh_sup, msLog2Div2LMultKm_sup, msLog2Div2LMultKl_sup;
+  double middlePoly_sup, doublePoly_sup;
+
+  x_inf=LOW(x);
+  x_sup=UP(x);
+
+  xdb_inf.d = x_inf; 
+  xdb_sup.d = x_sup; 
+
+
+  /* Strip off the sign of x for the following tests */
+
+  xIntHi_inf = xdb_inf.i[HI] & 0x7fffffff;
+  xIntHi_sup = xdb_sup.i[HI] & 0x7fffffff;
+
+  /* Test if we are so small that we can return (a corrected) x as correct rounding */
+
+  if ( __builtin_expect(
+      (xIntHi_inf < RETURNXBOUND) ||
+      ((xIntHi_inf >= SIMPLEOVERFLOWBOUND) && (xIntHi_inf >= 0x7ff00000)) ||
+      ((xIntHi_inf >= SIMPLEOVERFLOWBOUND) && (xIntHi_inf >= 0x7ff00000) && (((xIntHi_inf & 0x000fffff) | xdb_inf.i[LO]) != 0)) ||
+      ((xIntHi_inf >= SIMPLEOVERFLOWBOUND) && (xIntHi_inf >= 0x7ff00000) && (xdb_inf.i[HI] > 0)) ||
+      ((xIntHi_inf >= SIMPLEOVERFLOWBOUND) && (x_inf > OVERFLOWBOUND)) ||
+      (x_inf < MINUSONEBOUND) ||
+      (xIntHi_sup < RETURNXBOUND) ||
+      ((xIntHi_sup < RETURNXBOUND) && (x_sup == 0.0)) ||
+      ((xIntHi_sup >= SIMPLEOVERFLOWBOUND) && (xIntHi_sup >= 0x7ff00000)) ||
+      ((xIntHi_sup >= SIMPLEOVERFLOWBOUND) && (xIntHi_sup >= 0x7ff00000) && (((xIntHi_sup & 0x000fffff) | xdb_sup.i[LO]) != 0)) ||
+      ((xIntHi_sup >= SIMPLEOVERFLOWBOUND) && (xIntHi_sup >= 0x7ff00000) && (xdb_sup.i[HI] > 0)) ||
+      ((xIntHi_sup >= SIMPLEOVERFLOWBOUND) && (x_sup > OVERFLOWBOUND)) ||
+      (x_sup < MINUSONEBOUND)
+     ,FALSE))
+  {
+    ASSIGN_LOW(res,expm1_rd(LOW(x)));
+    ASSIGN_UP(res,expm1_ru(UP(x)));
+    return res;
+  }
+
+  if (__builtin_expect((xIntHi_inf < DIRECTINTERVALBOUND) && (xIntHi_sup < DIRECTINTERVALBOUND),TRUE)) {
+    /* 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_inf = ((xIntHi_inf & 0x7ff00000) >> 20) - (1023 - 5);
+    expoX_sup = ((xIntHi_sup & 0x7ff00000) >> 20) - (1023 - 5);
+    
+    /* If this particularily biased exponent expoX is negative, we are already less than 1/32 */
+    if (expoX_inf >= 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_inf.i[HI] += (-expoX_inf-1) << 20;
+
+      /* We reassign the new x and maintain xIntHi */
+
+      xIntHi_inf = xdb_inf.i[HI] & 0x7fffffff;
+      x_inf = xdb_inf.d;
+    }
+
+    if (expoX_sup >= 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_sup.i[HI] += (-expoX_sup-1) << 20;
+
+      /* We reassign the new x and maintain xIntHi */
+
+      xIntHi_sup = xdb_sup.i[HI] & 0x7fffffff;
+      x_sup = xdb_sup.d;
+    }
+
+    /* Here, we have always |x| < 1/32 */
+
+
+    /* Double precision evaluation steps and one double-double step */
+
+    Mul12(&xSqh_inf,&xSql_inf,x_inf,x_inf);
+    Mul12(&xSqh_sup,&xSql_sup,x_sup,x_sup);
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    middlePoly_inf = FMA(quickDirectpolyC5h,x_inf,quickDirectpolyC4h);
+    middlePoly_sup = FMA(quickDirectpolyC5h,x_sup,quickDirectpolyC4h);
+#else
+    middlePoly_inf = quickDirectpolyC4h + x_inf * quickDirectpolyC5h;
+    middlePoly_sup = quickDirectpolyC4h + x_sup * quickDirectpolyC5h;
+#endif
+
+    doublePoly_inf = middlePoly_inf;
+    doublePoly_sup = middlePoly_sup;
+
+    /* Special path: for small |x| we can truncate the polynomial */
+
+    if (xIntHi_inf > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly_inf = FMA(FMA(FMA(quickDirectpolyC9h ,x_inf,quickDirectpolyC8h),x_inf,
+                             quickDirectpolyC7h),x_inf,quickDirectpolyC6h);
+#else
+      highPoly_inf = quickDirectpolyC6h + x_inf * (quickDirectpolyC7h + x_inf * (
+	         quickDirectpolyC8h + x_inf *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare_inf = xSqh_inf * highPoly_inf;
+
+      doublePoly_inf = middlePoly_inf + highPolyWithSquare_inf;
+
+    }
+    if (xIntHi_sup > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly_sup = FMA(FMA(FMA(quickDirectpolyC9h ,x_sup,quickDirectpolyC8h),x_sup,
+                             quickDirectpolyC7h),x_sup,quickDirectpolyC6h);
+#else
+      highPoly_sup = quickDirectpolyC6h + x_sup * (quickDirectpolyC7h + x_sup * (
+	         quickDirectpolyC8h + x_sup *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare_sup = xSqh_sup * highPoly_sup;
+
+      doublePoly_sup = middlePoly_sup + highPolyWithSquare_sup;
+
+    }
+    
+    /* Double-double evaluation steps */
+    tt1h_inf = x_inf * doublePoly_inf;
+    tt1h_sup = x_sup * doublePoly_sup;
+
+    xSqHalfh_inf = 0.5 * xSqh_inf;
+    xSqHalfh_sup = 0.5 * xSqh_sup;
+    xSqHalfl_inf = 0.5 * xSql_inf;
+    xSqHalfl_sup = 0.5 * xSql_sup;
+    Add12(t2h_inf,templ_inf,x_inf,xSqHalfh_inf);
+    Add12(t2h_sup,templ_sup,x_sup,xSqHalfh_sup);
+    t2l_inf = templ_inf + xSqHalfl_inf;
+    t2l_sup = templ_sup + xSqHalfl_sup;
+    
+    Add12(t1h_inf,t1l_inf,quickDirectpolyC3h,tt1h_inf);
+    Add12(t1h_sup,t1l_sup,quickDirectpolyC3h,tt1h_sup);
+    Mul122(&xCubeh_inf,&xCubel_inf,x_inf,xSqh_inf,xSql_inf);
+    Mul122(&xCubeh_sup,&xCubel_sup,x_sup,xSqh_sup,xSql_sup);
+    Mul22(&tt3h_inf,&tt3l_inf,xCubeh_inf,xCubel_inf,t1h_inf,t1l_inf);
+    Mul22(&tt3h_sup,&tt3l_sup,xCubeh_sup,xCubel_sup,t1h_sup,t1l_sup);
+
+    Add22(&polyh_inf,&polyl_inf,t2h_inf,t2l_inf,tt3h_inf,tt3l_inf);
+    Add22(&polyh_sup,&polyl_sup,t2h_sup,t2l_sup,tt3h_sup,tt3l_sup);
+
+    /* Reconstruction */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX_inf >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h_inf,r1t_inf,2,polyh_inf);
+      r1l_inf = r1t_inf + polyl_inf;
+      Mul22(&rr1h_inf,&rr1l_inf,r1h_inf,r1l_inf,polyh_inf,polyl_inf);
+
+      if (expoX_inf >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h_inf,r2t_inf,2,rr1h_inf);
+	r2l_inf = r2t_inf + rr1l_inf;
+	Mul22(&rr2h_inf,&rr2l_inf,r2h_inf,r2l_inf,rr1h_inf,rr1l_inf);
+
+	if (expoX_inf >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h_inf,r3t_inf,2,rr2h_inf);
+	  r3l_inf = r3t_inf + rr2l_inf;
+	  Mul22(&rr3h_inf,&rr3l_inf,r3h_inf,r3l_inf,rr2h_inf,rr2l_inf);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h_inf = rr3h_inf;
+	  expm1m_inf = rr3l_inf;
+
+	} else {
+	  expm1h_inf = rr2h_inf;
+	  expm1m_inf = rr2l_inf;
+	}
+
+      } else {
+	expm1h_inf = rr1h_inf;
+	expm1m_inf = rr1l_inf;
+      }
+
+    } else {
+      expm1h_inf = polyh_inf;
+      expm1m_inf = polyl_inf;
+    }
+    if (expoX_sup >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h_sup,r1t_sup,2,polyh_sup);
+      r1l_sup = r1t_sup + polyl_sup;
+      Mul22(&rr1h_sup,&rr1l_sup,r1h_sup,r1l_sup,polyh_sup,polyl_sup);
+
+      if (expoX_sup >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h_sup,r2t_sup,2,rr1h_sup);
+	r2l_sup = r2t_sup + rr1l_sup;
+	Mul22(&rr2h_sup,&rr2l_sup,r2h_sup,r2l_sup,rr1h_sup,rr1l_sup);
+
+	if (expoX_sup >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h_sup,r3t_sup,2,rr2h_sup);
+	  r3l_sup = r3t_sup + rr2l_sup;
+	  Mul22(&rr3h_sup,&rr3l_sup,r3h_sup,r3l_sup,rr2h_sup,rr2l_sup);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h_sup = rr3h_sup;
+	  expm1m_sup = rr3l_sup;
+
+	} else {
+	  expm1h_sup = rr2h_sup;
+	  expm1m_sup = rr2l_sup;
+	}
+
+      } else {
+	expm1h_sup = rr1h_sup;
+	expm1m_sup = rr1l_sup;
+      }
+
+    } else {
+      expm1h_sup = polyh_sup;
+      expm1m_sup = polyl_sup;
+    }
+
+
+    /* Rounding test */
+    TEST_AND_COPY_RDRU_EXPM1(roundable,restemp_inf,expm1h_inf, expm1m_inf, restemp_sup,expm1h_sup, expm1m_sup, ROUNDCSTDIRECTRD);
+    if((roundable==2) || (roundable==0))
+    {
+      expm1_direct_td(&expm1h_inf, &expm1m_inf, &expm1l_inf, x_inf, xSqHalfh_inf, xSqHalfl_inf, xSqh_inf, xSql_inf, expoX_inf);
+      
+      RoundDownwards3(&restemp_inf,expm1h_inf, expm1m_inf, expm1l_inf);
+      
+    } /* Accurate phase launched */
+    if((roundable==1) || (roundable==0))
+    {
+      expm1_direct_td(&expm1h_sup, &expm1m_sup, &expm1l_sup, x_sup, xSqHalfh_sup, xSqHalfl_sup, xSqh_sup, xSql_sup, expoX_sup);
+      
+      RoundUpwards3(&restemp_sup,expm1h_sup, expm1m_sup, expm1l_sup);
+
+    } /* Accurate phase launched */
+    ASSIGN_LOW(res,restemp_inf);
+    ASSIGN_UP(res,restemp_sup);
+    return res;
+  }
+
+
+  /* Test if we have |x| <= 1/4-1/2ulp(1/4) for knowing if we use exp(x) or approximate directly */
+
+  if (xIntHi_inf < 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_inf = ((xIntHi_inf & 0x7ff00000) >> 20) - (1023 - 5);
+    
+    /* If this particularily biased exponent expoX is negative, we are already less than 1/32 */
+    if (expoX_inf >= 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_inf.i[HI] += (-expoX_inf-1) << 20;
+
+      /* We reassign the new x and maintain xIntHi */
+
+      xIntHi_inf = xdb_inf.i[HI] & 0x7fffffff;
+      x_inf = xdb_inf.d;
+    }
+    
+    /* Here, we have always |x| < 1/32 */
+
+
+    /* Double precision evaluation steps and one double-double step */
+
+    Mul12(&xSqh_inf,&xSql_inf,x_inf,x_inf);
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    middlePoly_inf = FMA(quickDirectpolyC5h,x_inf,quickDirectpolyC4h);
+#else
+    middlePoly_inf = quickDirectpolyC4h + x_inf * quickDirectpolyC5h;
+#endif
+
+    doublePoly_inf = middlePoly_inf;
+
+    /* Special path: for small |x| we can truncate the polynomial */
+
+    if (xIntHi_inf > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly_inf = FMA(FMA(FMA(quickDirectpolyC9h ,x_inf,quickDirectpolyC8h),x_inf,
+                             quickDirectpolyC7h),x_inf,quickDirectpolyC6h);
+#else
+      highPoly_inf = quickDirectpolyC6h + x_inf * (quickDirectpolyC7h + x_inf * (
+	         quickDirectpolyC8h + x_inf *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare_inf = xSqh_inf * highPoly_inf;
+
+      doublePoly_inf = middlePoly_inf + highPolyWithSquare_inf;
+
+    }
+    
+    /* Double-double evaluation steps */
+    tt1h_inf = x_inf * doublePoly_inf;
+
+    xSqHalfh_inf = 0.5 * xSqh_inf;
+    xSqHalfl_inf = 0.5 * xSql_inf;
+    Add12(t2h_inf,templ_inf,x_inf,xSqHalfh_inf);
+    t2l_inf = templ_inf + xSqHalfl_inf;
+    
+    Add12(t1h_inf,t1l_inf,quickDirectpolyC3h,tt1h_inf);
+    Mul122(&xCubeh_inf,&xCubel_inf,x_inf,xSqh_inf,xSql_inf);
+    Mul22(&tt3h_inf,&tt3l_inf,xCubeh_inf,xCubel_inf,t1h_inf,t1l_inf);
+
+    Add22(&polyh_inf,&polyl_inf,t2h_inf,t2l_inf,tt3h_inf,tt3l_inf);
+
+    /* Reconstruction */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX_inf >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h_inf,r1t_inf,2,polyh_inf);
+      r1l_inf = r1t_inf + polyl_inf;
+      Mul22(&rr1h_inf,&rr1l_inf,r1h_inf,r1l_inf,polyh_inf,polyl_inf);
+
+      if (expoX_inf >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h_inf,r2t_inf,2,rr1h_inf);
+	r2l_inf = r2t_inf + rr1l_inf;
+	Mul22(&rr2h_inf,&rr2l_inf,r2h_inf,r2l_inf,rr1h_inf,rr1l_inf);
+
+	if (expoX_inf >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h_inf,r3t_inf,2,rr2h_inf);
+	  r3l_inf = r3t_inf + rr2l_inf;
+	  Mul22(&rr3h_inf,&rr3l_inf,r3h_inf,r3l_inf,rr2h_inf,rr2l_inf);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h_inf = rr3h_inf;
+	  expm1m_inf = rr3l_inf;
+
+	} else {
+	  expm1h_inf = rr2h_inf;
+	  expm1m_inf = rr2l_inf;
+	}
+
+      } else {
+	expm1h_inf = rr1h_inf;
+	expm1m_inf = rr1l_inf;
+      }
+
+    } else {
+      expm1h_inf = polyh_inf;
+      expm1m_inf = polyl_inf;
+    }
+
+    /* Rounding test */
+    infDone=1;
+    TEST_AND_COPY_RD(roundable,restemp_inf,expm1h_inf, expm1m_inf, ROUNDCSTDIRECTRD);
+    if(roundable==0)
+    {
+      expm1_direct_td(&expm1h_inf, &expm1m_inf, &expm1l_inf, x_inf, xSqHalfh_inf, xSqHalfl_inf, xSqh_inf, xSql_inf, expoX_inf);
+      
+      RoundDownwards3(&restemp_inf,expm1h_inf, expm1m_inf, expm1l_inf);
+      
+    } /* Accurate phase launched */
+
+  }
+
+  /* Test if we have |x| <= 1/4-1/2ulp(1/4) for knowing if we use exp(x) or approximate directly */
+
+  if (xIntHi_sup < 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_sup = ((xIntHi_sup & 0x7ff00000) >> 20) - (1023 - 5);
+    
+    /* If this particularily biased exponent expoX is negative, we are already less than 1/32 */
+    if (expoX_sup >= 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_sup.i[HI] += (-expoX_sup-1) << 20;
+
+      /* We reassign the new x and maintain xIntHi */
+
+      xIntHi_sup = xdb_sup.i[HI] & 0x7fffffff;
+      x_sup = xdb_sup.d;
+    }
+    
+    /* Here, we have always |x| < 1/32 */
+
+
+    /* Double precision evaluation steps and one double-double step */
+
+    Mul12(&xSqh_sup,&xSql_sup,x_sup,x_sup);
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+    middlePoly_sup = FMA(quickDirectpolyC5h,x_sup,quickDirectpolyC4h);
+#else
+    middlePoly_sup = quickDirectpolyC4h + x_sup * quickDirectpolyC5h;
+#endif
+
+    doublePoly_sup = middlePoly_sup;
+
+    /* Special path: for small |x| we can truncate the polynomial */
+
+    if (xIntHi_sup > SPECIALINTERVALBOUND) {
+
+#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
+      highPoly_sup = FMA(FMA(FMA(quickDirectpolyC9h ,x_sup,quickDirectpolyC8h),x_sup,
+                             quickDirectpolyC7h),x_sup,quickDirectpolyC6h);
+#else
+      highPoly_sup = quickDirectpolyC6h + x_sup * (quickDirectpolyC7h + x_sup * (
+	         quickDirectpolyC8h + x_sup *  quickDirectpolyC9h));
+#endif
+
+      highPolyWithSquare_sup = xSqh_sup * highPoly_sup;
+
+      doublePoly_sup = middlePoly_sup + highPolyWithSquare_sup;
+
+    }
+    
+    /* Double-double evaluation steps */
+    tt1h_sup = x_sup * doublePoly_sup;
+
+    xSqHalfh_sup = 0.5 * xSqh_sup;
+    xSqHalfl_sup = 0.5 * xSql_sup;
+    Add12(t2h_sup,templ_sup,x_sup,xSqHalfh_sup);
+    t2l_sup = templ_sup + xSqHalfl_sup;
+    
+    Add12(t1h_sup,t1l_sup,quickDirectpolyC3h,tt1h_sup);
+    Mul122(&xCubeh_sup,&xCubel_sup,x_sup,xSqh_sup,xSql_sup);
+    Mul22(&tt3h_sup,&tt3l_sup,xCubeh_sup,xCubel_sup,t1h_sup,t1l_sup);
+
+    Add22(&polyh_sup,&polyl_sup,t2h_sup,t2l_sup,tt3h_sup,tt3l_sup);
+
+    /* Reconstruction */
+
+    /* If we have not performed any range reduction, we have no reconstruction to do */
+    if (expoX_sup >= 0) {
+      /* If we are here, we must perform reconstruction */
+
+      /* First reconstruction step */
+      Add12(r1h_sup,r1t_sup,2,polyh_sup);
+      r1l_sup = r1t_sup + polyl_sup;
+      Mul22(&rr1h_sup,&rr1l_sup,r1h_sup,r1l_sup,polyh_sup,polyl_sup);
+
+      if (expoX_sup >= 1) {
+
+	/* Second reconstruction step */
+	Add12(r2h_sup,r2t_sup,2,rr1h_sup);
+	r2l_sup = r2t_sup + rr1l_sup;
+	Mul22(&rr2h_sup,&rr2l_sup,r2h_sup,r2l_sup,rr1h_sup,rr1l_sup);
+
+	if (expoX_sup >= 2) {
+
+	  /* Third reconstruction step */
+	  Add12(r3h_sup,r3t_sup,2,rr2h_sup);
+	  r3l_sup = r3t_sup + rr2l_sup;
+	  Mul22(&rr3h_sup,&rr3l_sup,r3h_sup,r3l_sup,rr2h_sup,rr2l_sup);
+	  
+	  /* expoX may be maximally 2 */
+
+	  expm1h_sup = rr3h_sup;
+	  expm1m_sup = rr3l_sup;
+
+	} else {
+	  expm1h_sup = rr2h_sup;
+	  expm1m_sup = rr2l_sup;
+	}
+
+      } else {
+	expm1h_sup = rr1h_sup;
+	expm1m_sup = rr1l_sup;
+      }
+
+    } else {
+      expm1h_sup = polyh_sup;
+      expm1m_sup = polyl_sup;
+    }
+
+    /* Rounding test */
+    supDone=1;
+    TEST_AND_COPY_RU(roundable,restemp_sup,expm1h_sup, expm1m_sup, ROUNDCSTDIRECTRD);
+    if(roundable==0)
+    {
+      expm1_direct_td(&expm1h_sup, &expm1m_sup, &expm1l_sup, x_sup, xSqHalfh_sup, xSqHalfl_sup, xSqh_sup, xSql_sup, expoX_sup);
+      
+      RoundUpwards3(&restemp_sup,expm1h_sup, expm1m_sup, expm1l_sup);
+
+    } /* Accurate phase launched */
+
+  }
+  if((infDone==0) && (supDone==0))
+  {
+    /* If we are here, we can use expm1(x) = exp(x) - 1 */
+
+    /* Range reduction - exact part: compute k as double and as int */
+
+    xMultLog2InvMult2L_inf = x_inf * log2InvMult2L;
+    xMultLog2InvMult2L_sup = x_sup * log2InvMult2L;
+    shiftedXMult_inf = xMultLog2InvMult2L_inf + shiftConst;
+    shiftedXMult_sup = xMultLog2InvMult2L_sup + shiftConst;
+    kd_inf = shiftedXMult_inf - shiftConst;
+    kd_sup = shiftedXMult_sup - shiftConst;
+    shiftedXMultdb_inf.d = shiftedXMult_inf;
+    shiftedXMultdb_sup.d = shiftedXMult_sup;
+    k_inf = shiftedXMultdb_inf.i[LO];
+    k_sup = shiftedXMultdb_sup.i[LO];
+    M_inf = k_inf >> 12;
+    M_sup = k_sup >> 12;
+    index1_inf = k_inf & INDEXMASK1;
+    index1_sup = k_sup & INDEXMASK1;
+    index2_inf = (k_inf & INDEXMASK2) >> 6;
+    index2_sup = (k_sup & INDEXMASK2) >> 6;
+
+
+    /* Range reduction - part affected by error - must be redone in accurate phase */
+    Mul12(&s1_inf,&s2_inf,msLog2Div2Lh,kd_inf);
+    Mul12(&s1_sup,&s2_sup,msLog2Div2Lh,kd_sup);
+    s3_inf = kd_inf * msLog2Div2Lm;
+    s3_sup = kd_sup * msLog2Div2Lm;
+    s4_inf = s2_inf + s3_inf; 
+    s4_sup = s2_sup + s3_sup; 
+    s5_inf = x_inf + s1_inf;
+    s5_sup = x_sup + s1_sup;
+    Add12Cond(rh_inf,rm_inf,s5_inf,s4_inf);
+    Add12Cond(rh_sup,rm_sup,s5_sup,s4_sup);
+
+
+    /* Table reads - read only two double-doubles by now */
+    tbl1h_inf = twoPowerIndex1[index1_inf].hi;
+    tbl1h_sup = twoPowerIndex1[index1_sup].hi;
+    tbl1m_inf = twoPowerIndex1[index1_inf].mi;
+    tbl1m_sup = twoPowerIndex1[index1_sup].mi;
+    tbl2h_inf = twoPowerIndex2[index2_inf].hi;
+    tbl2h_sup = twoPowerIndex2[index2_sup].hi;
+    tbl2m_inf = twoPowerIndex2[index2_inf].mi;
+    tbl2m_sup = twoPowerIndex2[index2_sup].mi;
+
+    /* Quick phase starts here */
+
+    rhSquare_inf = rh_inf * rh_inf;
+    rhSquare_sup = rh_sup * rh_sup;
+    rhC3_inf = quickCommonpolyC3h * rh_inf;
+    rhC3_sup = quickCommonpolyC3h * rh_sup;
+
+    rhSquareHalf_inf = 0.5 * rhSquare_inf;
+    rhSquareHalf_sup = 0.5 * rhSquare_sup;
+
+    monomialCube_inf = rhC3_inf * rhSquare_inf;
+    monomialCube_sup = rhC3_sup * rhSquare_sup;
+    rhFour_inf = rhSquare_inf * rhSquare_inf;
+    rhFour_sup = rhSquare_sup * rhSquare_sup;
+
+    monomialFour_inf = quickCommonpolyC4h * rhFour_inf;
+    monomialFour_sup = quickCommonpolyC4h * rhFour_sup;
+    highPoly_inf = monomialCube_inf + monomialFour_inf;
+    highPoly_sup = monomialCube_sup + monomialFour_sup;
+    highPolyWithSquare_inf = rhSquareHalf_inf + highPoly_inf;
+    highPolyWithSquare_sup = rhSquareHalf_sup + highPoly_sup;
+
+    /* Reconstruction: integration of table values */
+  
+    Mul22(&tablesh_inf,&tablesl_inf,tbl1h_inf,tbl1m_inf,tbl2h_inf,tbl2m_inf);
+    Mul22(&tablesh_sup,&tablesl_sup,tbl1h_sup,tbl1m_sup,tbl2h_sup,tbl2m_sup);
+
+    t8_inf = rm_inf + highPolyWithSquare_inf;
+    t8_sup = rm_sup + highPolyWithSquare_sup;
+    t9_inf = rh_inf + t8_inf;
+    t9_sup = rh_sup + t8_sup;
+
+    t10_inf = tablesh_inf * t9_inf;
+    t10_sup = tablesh_sup * t9_sup;
+
+    Add12(t11_inf,t12_inf,tablesh_inf,t10_inf);
+    Add12(t11_sup,t12_sup,tablesh_sup,t10_sup);
+    t13_inf = t12_inf + tablesl_inf;
+    t13_sup = t12_sup + tablesl_sup;
+    Add12(polyTblhdb_inf.d,polyTblmdb_inf.d,t11_inf,t13_inf);
+    Add12(polyTblhdb_sup.d,polyTblmdb_sup.d,t11_sup,t13_sup);
+
+    /* Reconstruction: multiplication by 2^M */
+
+    /* Implement the multiplication by addition to overcome the
+       problem of the non-representability of 2^1024 (M = 1024)
+       This case is possible if polyTblhdb.d < 1
+    */
+  
+    polyTblhdb_inf.i[HI] += M_inf << 20;
+    polyTblhdb_sup.i[HI] += M_sup << 20;
+	 if(polyTblmdb_inf.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+		 polyTblmdb_inf.i[HI] += M_inf << 20;
+	 if(polyTblmdb_sup.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+		 polyTblmdb_sup.i[HI] += M_sup << 20;
+
+    exph_inf = polyTblhdb_inf.d;
+    exph_sup = polyTblhdb_sup.d;
+    expm_inf = polyTblmdb_inf.d;
+    expm_sup = polyTblmdb_sup.d;
+
+    /* Subtraction of 1 
+
+       Testing if the operation is necessary is more expensive than 
+       performing it in any case.
+
+       We may cancellate at most 2 bits in the subtraction for 
+       arguments 1/4 <= x <= ln(2) (0.25 <= x <= 0.69) 
+       We must therefore use conditional Add12s
+
+       Since we perform a subtraction, we may not have addition overflow towards +inf
+
+    */
+
+    Add12Cond(t1_inf,t2_inf,-1,exph_inf);
+    Add12Cond(t1_sup,t2_sup,-1,exph_sup);
+    t3_inf = t2_inf + expm_inf;
+    t3_sup = t2_sup + expm_sup;
+    Add12Cond(expm1h_inf,expm1m_inf,t1_inf,t3_inf);
+    Add12Cond(expm1h_sup,expm1m_sup,t1_sup,t3_sup);
+
+
+    /* Rounding test */
+    TEST_AND_COPY_RDRU_EXPM1(roundable,res_inf,expm1h_inf, expm1m_inf, res_sup,expm1h_sup, expm1m_sup, ROUNDCSTCOMMONRD);
+    if((roundable==2) || (roundable==0))
+    {
+      /* Rest of argument reduction for accurate phase */
+    
+      Mul133(&msLog2Div2LMultKh_inf,&msLog2Div2LMultKm_inf,&msLog2Div2LMultKl_inf,kd_inf,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+      t1_inf = x_inf + msLog2Div2LMultKh_inf;
+      Add12Cond(rh_inf,t2_inf,t1_inf,msLog2Div2LMultKm_inf);
+      Add12Cond(rm_inf,rl_inf,t2_inf,msLog2Div2LMultKl_inf);
+    
+      /* Table reads for accurate phase */
+      tbl1l_inf = twoPowerIndex1[index1_inf].lo;
+      tbl2l_inf = twoPowerIndex2[index2_inf].lo;
+    
+      /* Call accurate phase */
+      expm1_common_td(&expm1h_inf, &expm1m_inf, &expm1l_inf, rh_inf, rm_inf, rl_inf, tbl1h_inf, tbl1m_inf, tbl1l_inf, tbl2h_inf, tbl2m_inf, tbl2l_inf, M_inf); 
+    
+      /* Final rounding */
+
+      RoundDownwards3(&res_inf,expm1h_inf, expm1m_inf, expm1l_inf);
+    } /* Accurate phase launched */
+    if((roundable==1) || (roundable==0))
+    {
+      /* Rest of argument reduction for accurate phase */
+      Mul133(&msLog2Div2LMultKh_sup,&msLog2Div2LMultKm_sup,&msLog2Div2LMultKl_sup,kd_sup,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+      t1_sup = x_sup + msLog2Div2LMultKh_sup;
+      Add12Cond(rh_sup,t2_sup,t1_sup,msLog2Div2LMultKm_sup);
+      Add12Cond(rm_sup,rl_sup,t2_sup,msLog2Div2LMultKl_sup);
+    
+      /* Table reads for accurate phase */
+      tbl1l_sup = twoPowerIndex1[index1_sup].lo;
+      tbl2l_sup = twoPowerIndex2[index2_sup].lo;
+    
+      /* Call accurate phase */
+      expm1_common_td(&expm1h_sup, &expm1m_sup, &expm1l_sup, rh_sup, rm_sup, rl_sup, tbl1h_sup, tbl1m_sup, tbl1l_sup, tbl2h_sup, tbl2m_sup, tbl2l_sup, M_sup); 
+    
+      /* Final rounding */
+
+      RoundUpwards3(&res_sup,expm1h_sup, expm1m_sup, expm1l_sup);
+    } /* Accurate phase launched */
+
+    ASSIGN_LOW(res,res_inf);
+    ASSIGN_UP(res,res_sup);
+    return res;
+  }
+  if((supDone==1))
+  {
+    /* If we are here, we can use expm1(x) = exp(x) - 1 */
+
+    /* Range reduction - exact part: compute k as double and as int */
+
+    xMultLog2InvMult2L_inf = x_inf * log2InvMult2L;
+    shiftedXMult_inf = xMultLog2InvMult2L_inf + shiftConst;
+    kd_inf = shiftedXMult_inf - shiftConst;
+    shiftedXMultdb_inf.d = shiftedXMult_inf;
+    k_inf = shiftedXMultdb_inf.i[LO];
+    M_inf = k_inf >> 12;
+    index1_inf = k_inf & INDEXMASK1;
+    index2_inf = (k_inf & INDEXMASK2) >> 6;
+
+
+    /* Range reduction - part affected by error - must be redone in accurate phase */
+    Mul12(&s1_inf,&s2_inf,msLog2Div2Lh,kd_inf);
+    s3_inf = kd_inf * msLog2Div2Lm;
+    s4_inf = s2_inf + s3_inf; 
+    s5_inf = x_inf + s1_inf;
+    Add12Cond(rh_inf,rm_inf,s5_inf,s4_inf);
+
+
+    /* Table reads - read only two double-doubles by now */
+    tbl1h_inf = twoPowerIndex1[index1_inf].hi;
+    tbl1m_inf = twoPowerIndex1[index1_inf].mi;
+    tbl2h_inf = twoPowerIndex2[index2_inf].hi;
+    tbl2m_inf = twoPowerIndex2[index2_inf].mi;
+
+    /* Quick phase starts here */
+
+    rhSquare_inf = rh_inf * rh_inf;
+    rhC3_inf = quickCommonpolyC3h * rh_inf;
+
+    rhSquareHalf_inf = 0.5 * rhSquare_inf;
+
+    monomialCube_inf = rhC3_inf * rhSquare_inf;
+    rhFour_inf = rhSquare_inf * rhSquare_inf;
+
+    monomialFour_inf = quickCommonpolyC4h * rhFour_inf;
+    highPoly_inf = monomialCube_inf + monomialFour_inf;
+    highPolyWithSquare_inf = rhSquareHalf_inf + highPoly_inf;
+
+    /* Reconstruction: integration of table values */
+  
+    Mul22(&tablesh_inf,&tablesl_inf,tbl1h_inf,tbl1m_inf,tbl2h_inf,tbl2m_inf);
+
+    t8_inf = rm_inf + highPolyWithSquare_inf;
+    t9_inf = rh_inf + t8_inf;
+
+    t10_inf = tablesh_inf * t9_inf;
+
+    Add12(t11_inf,t12_inf,tablesh_inf,t10_inf);
+    t13_inf = t12_inf + tablesl_inf;
+    Add12(polyTblhdb_inf.d,polyTblmdb_inf.d,t11_inf,t13_inf);
+
+    /* Reconstruction: multiplication by 2^M */
+
+    /* Implement the multiplication by addition to overcome the
+       problem of the non-representability of 2^1024 (M = 1024)
+       This case is possible if polyTblhdb.d < 1
+    */
+  
+    polyTblhdb_inf.i[HI] += M_inf << 20;
+	 if(polyTblmdb_inf.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+		 polyTblmdb_inf.i[HI] += M_inf << 20;
+
+    exph_inf = polyTblhdb_inf.d;
+    expm_inf = polyTblmdb_inf.d;
+
+    /* Subtraction of 1 
+
+       Testing if the operation is necessary is more expensive than 
+       performing it in any case.
+
+       We may cancellate at most 2 bits in the subtraction for 
+       arguments 1/4 <= x <= ln(2) (0.25 <= x <= 0.69) 
+       We must therefore use conditional Add12s
+
+       Since we perform a subtraction, we may not have addition overflow towards +inf
+
+    */
+
+    Add12Cond(t1_inf,t2_inf,-1,exph_inf);
+    t3_inf = t2_inf + expm_inf;
+    Add12Cond(expm1h_inf,expm1m_inf,t1_inf,t3_inf);
+
+
+    /* Rounding test */
+    TEST_AND_COPY_RD(roundable,res_inf,expm1h_inf, expm1m_inf, ROUNDCSTCOMMONRD);
+    if(roundable==0)
+    {
+      /* Rest of argument reduction for accurate phase */
+    
+      Mul133(&msLog2Div2LMultKh_inf,&msLog2Div2LMultKm_inf,&msLog2Div2LMultKl_inf,kd_inf,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+      t1_inf = x_inf + msLog2Div2LMultKh_inf;
+      Add12Cond(rh_inf,t2_inf,t1_inf,msLog2Div2LMultKm_inf);
+      Add12Cond(rm_inf,rl_inf,t2_inf,msLog2Div2LMultKl_inf);
+    
+      /* Table reads for accurate phase */
+      tbl1l_inf = twoPowerIndex1[index1_inf].lo;
+      tbl2l_inf = twoPowerIndex2[index2_inf].lo;
+    
+      /* Call accurate phase */
+      expm1_common_td(&expm1h_inf, &expm1m_inf, &expm1l_inf, rh_inf, rm_inf, rl_inf, tbl1h_inf, tbl1m_inf, tbl1l_inf, tbl2h_inf, tbl2m_inf, tbl2l_inf, M_inf); 
+    
+      /* Final rounding */
+
+      RoundDownwards3(&res_inf,expm1h_inf, expm1m_inf, expm1l_inf);
+    } /* Accurate phase launched */
+
+  }
+  if(infDone==1)
+  {
+    /* If we are here, we can use expm1(x) = exp(x) - 1 */
+
+    /* Range reduction - exact part: compute k as double and as int */
+
+    xMultLog2InvMult2L_sup = x_sup * log2InvMult2L;
+    shiftedXMult_sup = xMultLog2InvMult2L_sup + shiftConst;
+    kd_sup = shiftedXMult_sup - shiftConst;
+    shiftedXMultdb_sup.d = shiftedXMult_sup;
+    k_sup = shiftedXMultdb_sup.i[LO];
+    M_sup = k_sup >> 12;
+    index1_sup = k_sup & INDEXMASK1;
+    index2_sup = (k_sup & INDEXMASK2) >> 6;
+
+
+    /* Range reduction - part affected by error - must be redone in accurate phase */
+    Mul12(&s1_sup,&s2_sup,msLog2Div2Lh,kd_sup);
+    s3_sup = kd_sup * msLog2Div2Lm;
+    s4_sup = s2_sup + s3_sup; 
+    s5_sup = x_sup + s1_sup;
+    Add12Cond(rh_sup,rm_sup,s5_sup,s4_sup);
+
+
+    /* Table reads - read only two double-doubles by now */
+    tbl1h_sup = twoPowerIndex1[index1_sup].hi;
+    tbl1m_sup = twoPowerIndex1[index1_sup].mi;
+    tbl2h_sup = twoPowerIndex2[index2_sup].hi;
+    tbl2m_sup = twoPowerIndex2[index2_sup].mi;
+
+    /* Quick phase starts here */
+
+    rhSquare_sup = rh_sup * rh_sup;
+    rhC3_sup = quickCommonpolyC3h * rh_sup;
+
+    rhSquareHalf_sup = 0.5 * rhSquare_sup;
+
+    monomialCube_sup = rhC3_sup * rhSquare_sup;
+    rhFour_sup = rhSquare_sup * rhSquare_sup;
+
+    monomialFour_sup = quickCommonpolyC4h * rhFour_sup;
+    highPoly_sup = monomialCube_sup + monomialFour_sup;
+    highPolyWithSquare_sup = rhSquareHalf_sup + highPoly_sup;
+
+    /* Reconstruction: integration of table values */
+  
+    Mul22(&tablesh_sup,&tablesl_sup,tbl1h_sup,tbl1m_sup,tbl2h_sup,tbl2m_sup);
+
+    t8_sup = rm_sup + highPolyWithSquare_sup;
+    t9_sup = rh_sup + t8_sup;
+
+    t10_sup = tablesh_sup * t9_sup;
+
+    Add12(t11_sup,t12_sup,tablesh_sup,t10_sup);
+    t13_sup = t12_sup + tablesl_sup;
+    Add12(polyTblhdb_sup.d,polyTblmdb_sup.d,t11_sup,t13_sup);
+
+    /* Reconstruction: multiplication by 2^M */
+
+    /* Implement the multiplication by addition to overcome the
+       problem of the non-representability of 2^1024 (M = 1024)
+       This case is possible if polyTblhdb.d < 1
+    */
+  
+    polyTblhdb_sup.i[HI] += M_sup << 20;
+	 if(polyTblmdb_sup.d!=0.0) /* predicted true, but it happens for x=-4.1588039009762204, thanks Morten */
+		 polyTblmdb_sup.i[HI] += M_sup << 20;
+
+    exph_sup = polyTblhdb_sup.d;
+    expm_sup = polyTblmdb_sup.d;
+
+    /* Subtraction of 1 
+
+       Testing if the operation is necessary is more expensive than 
+       performing it in any case.
+
+       We may cancellate at most 2 bits in the subtraction for 
+       arguments 1/4 <= x <= ln(2) (0.25 <= x <= 0.69) 
+       We must therefore use conditional Add12s
+
+       Since we perform a subtraction, we may not have addition overflow towards +inf
+
+    */
+
+    Add12Cond(t1_sup,t2_sup,-1,exph_sup);
+    t3_sup = t2_sup + expm_sup;
+    Add12Cond(expm1h_sup,expm1m_sup,t1_sup,t3_sup);
+
+    /* Rounding test */
+    TEST_AND_COPY_RU(roundable,res_sup,expm1h_sup, expm1m_sup, ROUNDCSTCOMMONRD);
+    if(roundable==0)
+    {
+      /* Rest of argument reduction for accurate phase */
+      Mul133(&msLog2Div2LMultKh_sup,&msLog2Div2LMultKm_sup,&msLog2Div2LMultKl_sup,kd_sup,msLog2Div2Lh,msLog2Div2Lm,msLog2Div2Ll);
+      t1_sup = x_sup + msLog2Div2LMultKh_sup;
+      Add12Cond(rh_sup,t2_sup,t1_sup,msLog2Div2LMultKm_sup);
+      Add12Cond(rm_sup,rl_sup,t2_sup,msLog2Div2LMultKl_sup);
+    
+      /* Table reads for accurate phase */
+      tbl1l_sup = twoPowerIndex1[index1_sup].lo;
+      tbl2l_sup = twoPowerIndex2[index2_sup].lo;
+    
+      /* Call accurate phase */
+      expm1_common_td(&expm1h_sup, &expm1m_sup, &expm1l_sup, rh_sup, rm_sup, rl_sup, tbl1h_sup, tbl1m_sup, tbl1l_sup, tbl2h_sup, tbl2m_sup, tbl2l_sup, M_sup); 
+    
+      /* Final rounding */
+
+      RoundUpwards3(&res_sup,expm1h_sup, expm1m_sup, expm1l_sup);
+    } /* Accurate phase launched */
+  }
+
+  if (infDone==1) res_inf=restemp_inf;
+  if (supDone==1) res_sup=restemp_sup;
+  ASSIGN_LOW(res,res_inf);
+  ASSIGN_UP(res,res_sup);
+  return res;
+}
+#endif