intervals 0.3.56

data/ext/crlibm/maple/exp-td.mpl

@@ -0,0 +1,195 @@
+#######################################################################
+# This file is part of the crlibm library, and is distributed under
+# the  LGPL.
+# To use:
+# restart; read "exp-td.mpl";
+Digits := 120:
+
+interface(quiet=true):
+
+read "common-procedures.mpl":
+read "triple-double.mpl":
+mkdir("TEMPEXP"):
+
+L := 12:
+
+printf("   memory requirement for L = %d and two triple-double tables: %d bytes\n",L,48*2^(ceil(L/2)));
+
+rmax := log(2) / (2^(L+1)):
+
+printf("   maximal absolute value for rmax = 2^(%f)\n",log[2](rmax)):
+
+
+MsLog2Div2L := evalf(-log(2)/(2^L)):
+
+msLog2Div2Lh, msLog2Div2Lm, msLog2Div2Ll := hi_mi_lo(MsLog2Div2L):
+
+epsMsLog2Div2L := evalf(((msLog2Div2Lh + msLog2Div2Lm + msLog2Div2Ll) - MsLog2Div2L)/MsLog2Div2L):
+
+printf("   error made by storing MsLog2Div2L as a triple-double: 2^(%f)\n",log[2](epsMsLog2Div2L)):
+
+
+log2InvMult2L := nearest(2^L / (log(2))):
+
+shiftConst := 2^(52) + 2^(51):
+
+indexmask1 := 2^(L/2) - 1:
+indexmask2 := indexmask1 * 2^(L/2):
+
+largest := 2^(1023) * ((2^(53) - 1) / 2^(52)):
+smallest := 2^(-1023) * 1 * 2^(-51):
+
+overflowbound := nearest(log(largest)):
+
+overflowboundHex := ieeehexa(overflowbound):
+overflowSimplebound := convert(overflowboundHex[1],decimal,hex):
+
+underflowbound := nearest(log(2^(-1075))):
+
+denormbound := nearest(log(2^(-1022) * 1)):
+
+
+overUnderflowboundHex := ieeehexa(min(abs(underflowbound),min(abs(overflowbound),abs(denormbound)))):
+overUnderflowSimplebound := convert(overUnderflowboundHex[1],decimal,hex):
+
+twoPowerM1000 := 2^(-1000):
+twoPower1000 := 2^(1000):
+
+twoM52 := 2^(-52):
+mTwoM53 := - 2^(-53):
+
+for i from 0 to 2^(L/2) - 1 do
+	twoPowerIndex1hi[i], twoPowerIndex1mi[i], twoPowerIndex1lo[i] := hi_mi_lo(evalf(2^(i/(2^L)))):
+	twoPowerIndex2hi[i], twoPowerIndex2mi[i], twoPowerIndex2lo[i] := hi_mi_lo(evalf(2^(i/(2^(L/2))))):
+od: 
+
+
+
+PolyDegreeQuick:=4:
+printf("   degree of the polynomial used in the quick phase is %d\n",PolyDegreeQuick);
+
+
+
+polyQuick:= poly_exact(1 + x + 0.5*x^2 + x^3 * (numapprox[minimax](((exp(x) - (1 + x + 0.5*x^2))/x^3),  
+				x=-rmax..rmax, [PolyDegreeQuick-3,0], 1 ,  'deltaApprox'))):
+
+epsilonApproxQuick := numapprox[infnorm]( (polyQuick/exp(x))-1, x=-rmax..rmax):
+printf("   approximation rel error for the quick phase is 2^(%2f)\n", log2(epsilonApproxQuick) ) :
+deltaApproxQuick := numapprox[infnorm]( polyQuick-exp(x), x=-rmax..rmax):
+printf("   approximation abs error for the quick phase is 2^(%2f)\n", log2(deltaApproxQuick) ) :
+
+	
+
+PolyDegreeAccurate:=7:
+
+printf("   degree of the polynomial used in the accurate phase is %d\n",PolyDegreeAccurate):
+
+DDNumberAccu:=5:
+
+
+printf("   number of double doubles used for the coefficients is %d\n",DDNumberAccu):
+
+
+
+polyAccurate:= poly_exact2(1 + x + 0.5*x^2 + x^3 * (numapprox[minimax](((exp(x) - (1 + x + 0.5*x^2))/x^3),  
+				x=-rmax..rmax, [PolyDegreeAccurate-3,0], 1 ,  'deltaApprox')), 
+				DDNumberAccu):	
+
+
+epsilonApproxAccurate := numapprox[infnorm]( (polyAccurate/exp(x))-1, x=-rmax..rmax):
+printf("   approximation rel error for the accurate phase is 2^(%2f)\n", log2(epsilonApproxAccurate) ) :
+deltaApproxAccurate := numapprox[infnorm]( polyAccurate-exp(x), x=-rmax..rmax):
+printf("   approximation abs error for the quick phase is 2^(%2f)\n", log2(deltaApproxAccurate) ) :
+
+
+epsilon_quick := 2^(-64): # The Gappa proof will show this bound
+
+
+
+
+
+#-------------------------------------------------------------------
+# Output
+
+filename:="TEMPEXP/exp-td.h":
+fd:=fopen(filename, WRITE, TEXT):
+
+fprintf(fd, "#include \"crlibm.h\"\n#include \"crlibm_private.h\"\n"):
+
+fprintf(fd, "\n/*File generated by maple/exp-td.mpl*/\n"):
+
+fprintf(fd, "\#define L %d\n",L):
+fprintf(fd, "\#define LHALF %d\n",L/2):
+fprintf(fd, "\#define log2InvMult2L %1.50e\n",log2InvMult2L):
+fprintf(fd, "\#define msLog2Div2Lh %1.50e\n",msLog2Div2Lh):
+fprintf(fd, "\#define msLog2Div2Lm %1.50e\n",msLog2Div2Lm):
+fprintf(fd, "\#define msLog2Div2Ll %1.50e\n",msLog2Div2Ll):
+fprintf(fd, "\#define shiftConst %1.50e\n",shiftConst):
+fprintf(fd, "\#define INDEXMASK1 0x%08x\n",indexmask1):
+fprintf(fd, "\#define INDEXMASK2 0x%08x\n",indexmask2):
+fprintf(fd, "\#define OVRUDRFLWSMPLBOUND 0x%08x\n",overUnderflowSimplebound):
+fprintf(fd, "\#define OVRFLWBOUND %1.50e\n",overflowbound):
+fprintf(fd, "\#define LARGEST %1.50e\n",largest):
+fprintf(fd, "\#define SMALLEST %1.50e\n",smallest):
+fprintf(fd, "\#define DENORMBOUND %1.50e\n",denormbound):
+fprintf(fd, "\#define UNDERFLWBOUND %1.50e\n",underflowbound):
+fprintf(fd, "\#define twoPowerM1000 %1.50e\n",twoPowerM1000):
+fprintf(fd, "\#define twoPower1000 %1.50e\n",twoPower1000):
+fprintf(fd, "\#define ROUNDCST %1.50e\n", compute_rn_constant(epsilon_quick)):   
+fprintf(fd, "\#define RDROUNDCST %1.50e\n", epsilon_quick):   
+fprintf(fd, "\#define twoM52 %1.50e\n", twoM52):   
+fprintf(fd, "\#define mTwoM53 %1.50e\n", mTwoM53):   
+
+fprintf(fd,"\n\n"):
+
+for i from 3 to PolyDegreeQuick do
+	fprintf(fd, "\#define c%d %1.50e\n",i,coeff(polyQuick,x,i)):
+od:
+
+
+for i from 3 to DDNumberAccu-1 do
+	(hi,lo) := hi_lo(coeff(polyAccurate,x,i)):
+	fprintf(fd, "\#define accPolyC%dh %1.50e\n",i,hi):
+	fprintf(fd, "\#define accPolyC%dl %1.50e\n",i,lo):
+od:
+
+for i from DDNumberAccu to PolyDegreeAccurate do
+	fprintf(fd, "\#define accPolyC%d %1.50e\n",i,coeff(polyAccurate,x,i)):
+od:
+
+fprintf(fd,"\n\n"):
+
+# Print the tables
+fprintf(fd, "typedef struct tPi_t_tag {double hi; double mi; double lo;} tPi_t;  \n"):
+fprintf(fd, "static const tPi_t twoPowerIndex1[%d] = {\n", 2^(L/2)):
+for i from 0 to 2^(L/2)-1 do
+      fprintf(fd, "  { \n"):      
+      fprintf(fd, "    %1.50e, /* twoPowerIndex1hi[%d] */ \n", twoPowerIndex1hi[i], i):
+      fprintf(fd, "    %1.50e, /* twoPowerIndex1mi[%d] */ \n", twoPowerIndex1mi[i], i):
+      fprintf(fd, "    %1.50e, /* twoPowerIndex1lo[%d] */ \n", twoPowerIndex1lo[i], i):
+      fprintf(fd, "  } "):
+      if(i<2^(L/2)-1) then  fprintf(fd, ", \n"): fi
+od:
+fprintf(fd, "}; \n \n"):
+fprintf(fd, "static const tPi_t twoPowerIndex2[%d] = {\n", 2^(L/2)):
+for i from 0 to 2^(L/2)-1 do
+      fprintf(fd, "  { \n"):      
+      fprintf(fd, "    %1.50e, /* twoPowerIndex2hi[%d] */ \n", twoPowerIndex2hi[i], i):
+      fprintf(fd, "    %1.50e, /* twoPowerIndex2mi[%d] */ \n", twoPowerIndex2mi[i], i):
+      fprintf(fd, "    %1.50e, /* twoPowerIndex2lo[%d] */ \n", twoPowerIndex2lo[i], i):
+      fprintf(fd, "  } "):
+      if(i<2^(L/2)-1) then  fprintf(fd, ", \n"): fi
+od:
+fprintf(fd, "}; \n \n"):
+
+
+
+
+fprintf(fd, "\n\n"):
+
+
+
+
+printf("----DONE---\n") :
+
+

data/ext/crlibm/maple/log-de.mpl

@@ -0,0 +1,243 @@
+#######################################################################
+# This file is part of the crlibm library, and is distributed under
+# the  LGPL.
+# To use:
+# restart; read "log-de.mpl";
+Digits := 100:
+
+interface(quiet=true):
+
+read "common-procedures.mpl":
+read "double-extended.mpl":
+mkdir("TEMPLOG"):
+
+
+log2h,log2l := hiloExt(log(2)):
+
+
+L := 7: # number of bits used to address the table
+
+MAXINDEX    := round(2^L * (sqrt(2)-1)):
+
+for i from 0 to MAXINDEX-1 do
+    center[i] := 1 + i*2^(-L): # center[i] in [1, 2[
+    # We want it to fit on 11 bits of mantissa
+    r[i] :=  round(evalf(  (1/center[i]) * 2^(11)) ) / 2^(11) ;
+
+od:
+for i from MAXINDEX to 2^L do
+    # y has been divided by two, center[i] in [0.5, 1[
+    center[i]:=(1 + i*2^(-L)) / 2:
+    # We want it to fit on 11 bits of mantissa,
+    r[i] :=  round(evalf(  (1/center[i]) * 2^(10)) ) / 2^(10) ;
+od:
+
+# Note that we go up to 2^L although the case 2^L is wrapped to zero
+# in the C code. It could be important for zmax (but it turns out not).
+
+for i from 0 to 2^L do
+    (logirh[i], logirl[i]) := hiloExt(-log(r[i])):
+od:
+
+#Computation of ZMax.
+for i from 0 to MAXINDEX-1 do
+    _x := center[i] + 2^(-L-1) :
+    zmax[i] := (_x*r[i]-1) :
+    _x := center[i] - 2^(-L-1) :
+    zmin[i] := (_x*r[i]-1) :
+od:
+for i from MAXINDEX to 2^L do
+    _x := center[i] + 2^(-L-2) :
+    zmax[i] := (_x*r[i]-1) :
+    _x := center[i] - 2^(-L-2) :
+    zmin[i] := (_x*r[i]-1) :
+od:
+
+zmaxmax:=0:
+zminmin:=0:
+for i from 0 to 2^L do
+    if zmax[i] > zmaxmax then zmaxmax := zmax[i]: fi:
+    if zmin[i] < zminmin then zminmin := zmin[i]: fi:
+od:
+printf("zminmin = -2^(%2f)   zmaxmax = 2^(%2f)\n", log2(-zminmin), log2(zmaxmax) ) :
+
+
+PolyDegreeQuick:=7:
+
+#Keep -zmaxmax..zmaxmax to keep c1=1, which is useful in the proof
+polyQuick:= polyExact2Ext(x  * numapprox[minimax](  log(1+x)/x,  x=-zmaxmax..zmaxmax,  [PolyDegreeQuick-1,0], 1 ,  'deltaApprox'), 0):
+
+epsilonApproxQuick := numapprox[infnorm]( 1-polyQuick/log(1+x), x=zminmin..zmaxmax):
+printf("   approximation rel error for the quick phase is 2^(%2f)\n", log2(epsilonApproxQuick) ) :
+deltaApproxQuick := numapprox[infnorm]( polyQuick-log(1+x), x=zminmin..zmaxmax):
+printf("   approximation abs error for the quick phase is 2^(%2f)\n", log2(deltaApproxQuick) ) :
+
+
+
+PolyDegreeAccurate:=14:
+
+printf("Computing the polynomial for accurate phase (this may take some time...)\n"):
+pe:= x  * numapprox[minimax](  log(1+x)/x,  x=-zmaxmax..zmaxmax,  [PolyDegreeAccurate-1,0], 1 ,  'deltaApprox'):
+
+
+MaxDegreeDDE:=8:  #
+
+polyAccurate := polyExact2Ext(pe, MaxDegreeDDE):
+#deltaApprox := numapprox[infnorm](polyAccurate-log(1+x), x=-zmaxmax..zmaxmax):
+epsilonApproxAccurate := numapprox[infnorm]( 1-polyAccurate/log(1+x), x=-zmaxmax..zmaxmax):
+printf("   approximation error for the accurate phase is 2^(%2f)\n", log2(epsilonApproxAccurate) ) :
+
+
+
+
+filename:="TEMPLOG/log-de.h":
+fd:=fopen(filename, WRITE, TEXT):
+
+fprintf(fd, "/*File generated by maple/log-de.mpl*/\n\n"):
+
+  fprintf(fd, "#if defined(CRLIBM_TYPECPU_X86) || defined(CRLIBM_TYPECPU_AMD64)\n\n"):
+  fprintf(fd, "  /* Coefficients are read directly from the array thanks to the following macros */ \n"):
+  for i from PolyDegreeQuick to 1 by -1 do
+    fprintf(fd, "#define c%d  c[%d]\n", i, PolyDegreeQuick-i):
+  od:
+  for i from PolyDegreeAccurate to 1 by -1 do
+    fprintf(fd, "#define c%dh  ch[%d]\n", i, PolyDegreeAccurate-i):
+  od:
+
+  for i from MaxDegreeDDE-1 to 1 by -1 do
+    fprintf(fd, "#define c%dl  cl[%d]\n", i, MaxDegreeDDE-1-i):
+  od:
+  fprintf(fd, "#define PREFETCH_POLY_ACCURATE \n"):
+  fprintf(fd, "\n#else /* not(defined(CRLIBM_TYPECPU_X86) || defined(CRLIBM_TYPECPU_AMD64)),\n   assuming Itanium, otherwise we shouldn't be there */ \n\n"):
+  fprintf(fd, "#define PREFETCH_POLY_QUICK "):
+  for i from PolyDegreeQuick to 1 by -1 do
+    fprintf(fd, "c%d=c[%d]; ", i, PolyDegreeQuick-i):
+  od:
+  fprintf(fd, "\n#define PREFETCH_POLY_ACCURATE "):
+  for i from PolyDegreeAccurate to 1 by -1 do
+    fprintf(fd, "c%dh=ch[%d]; ", i, PolyDegreeAccurate-i):
+    if i mod 4 =0 then  fprintf(fd, "\\\n        "): fi:
+  od:
+  fprintf(fd, "\\\n        "):
+  for i from MaxDegreeDDE-1 to 1 by -1 do
+    fprintf(fd, "c%dl=cl[%d]; ", i, MaxDegreeDDE-1-i):
+  od:
+
+  fprintf(fd, "\n#endif /* defined(CRLIBM_TYPECPU_X86) || defined(CRLIBM_TYPECPU_AMD64) */ \n\n"):
+
+  # Various constants
+  fprintf(fd, "#define L        %d\n", L):
+  fprintf(fd, "#define MAXINDEX %d\n", MAXINDEX):
+  fprintf(fd, "#define INDEXMASK %d\n", 2^L-1):
+  fprintf(fd, "static const long double log2h  = %1.50eL ;\n", log2h):
+  fprintf(fd, "static const long double log2l  = %1.50eL ;\n", log2l):
+  fprintf(fd, "static const long double two64 = %1.50eL ;\n", evalf(2^64)):
+
+  # The polynomials
+  #  polynomial for quick phase
+#  for i from PolyDegreeQuick to 1 by -1 do
+#    fprintf(fd, "static const long double c%d =    %1.50eL ;\n", i, coeff(polyQuick,x,i)):
+#  od:
+   fprintf(fd, "static const long double c[%d] =  {\n",PolyDegreeQuick):
+   for i from PolyDegreeQuick to 1 by -1 do
+     fprintf(fd, "   /* c%d  = */ %1.50eL, \n", i, coeff(polyQuick,x,i)):
+   od:
+  fprintf(fd, "}; \n \n"):
+
+  #  polynomial for accurate phase
+  #  polynomial for accurate phase
+  fprintf(fd, "static const long double ch[%d] =  {\n",PolyDegreeAccurate):
+   for i from PolyDegreeAccurate to 1 by -1 do
+     (ch, cl) := hiloExt(coeff(polyAccurate,x,i)):
+     fprintf(fd, "   /* ch%d  = */ %1.50eL, \n", i, ch):
+   od:
+  fprintf(fd, "}; \n \n"):
+
+  fprintf(fd, "static const long double cl[%d] =  {\n", MaxDegreeDDE):
+  for i from MaxDegreeDDE-1 to 1 by -1 do
+     (ch, cl) := hiloExt(coeff(polyAccurate,x,i)):
+     fprintf(fd, "   /* cl%d  = */ %1.50eL, \n", i, cl):
+   od:
+  fprintf(fd, "}; \n \n"):
+
+
+  # The tables
+
+
+  fprintf(fd, "typedef struct rri_tag {float r; long double logirh;  long double logirl; } rri ;  \n"):
+  fprintf(fd, "static const rri argredtable[%d] = {\n", 2^L):
+  for i from 0 to 2^L-1 do
+      fprintf(fd, "  { \n"):
+      fprintf(fd, "    %1.50eL,   /* r[%d] */ \n", r[i], i):
+      fprintf(fd, "    %1.50eL, /* logirh[%d] */ \n", logirh[i], i):
+      fprintf(fd, "    %1.50eL, /* logirl[%d] */ \n", logirl[i], i):
+      fprintf(fd, "  } "):
+      if(i<2^L-1) then  fprintf(fd, ", \n"): fi
+  od:
+fprintf(fd, "}; \n \n"):
+
+fclose(fd):
+
+printf("\n\n************ DONE TEMPLOG/log-de.h ************\n");
+
+
+
+
+
+
+for j from 0 to 2^L-1 do
+    filename:=cat("TEMPLOG/log-de_",j,".sed"):
+    fd:=fopen(filename, WRITE, TEXT):
+    fprintf(fd, " s/_log2h/%1.40e/g\n", log2h):
+    fprintf(fd, " s/_log2l/%1.40e/g\n", log2l):
+    fprintf(fd, " s/_r/%1.40e/g\n",     r[j]):
+    fprintf(fd, " s/_logirh/%1.40e/g\n", logirh[j]):
+    fprintf(fd, " s/_logirl/%1.40e/g\n", logirl[j]):
+    fprintf(fd, " s/_zmin/%1.40e/g\n", zmin[j]):
+    fprintf(fd, " s/_zmax/%1.40e/g\n", zmax[j]):
+    for i from PolyDegreeQuick to 1 by -1 do
+        fprintf(fd, " s/_c%d/%1.40e/g\n", i, coeff(polyQuick,x,i)):
+    od:
+    fprintf(fd, " s/_deltaApproxQuick/%1.40e/g\n", deltaApproxQuick):
+    fprintf(fd, " s/_epsilonApproxQuick/%1.40e/g\n", epsilonApproxQuick):
+    fclose(fd):
+  od:
+
+
+
+printf("\n\n************ DONE TEMPLOG/log-de*.sed ************\n");
+
+# A shell script to use them
+filename:="TEMPLOG/run-log-de-proof.sh":
+fd:=fopen(filename, WRITE, TEXT):
+fprintf(fd, "#!/bin/sh\n"):
+fprintf(fd, "# You probably need to edit the path to the gappa executable\n"):
+fprintf(fd, "GAPPA=~/gappa/src/gappa\n"):
+fprintf(fd, "# Test all the possible table value for E=1\n"):
+fprintf(fd, "for num in `seq 0 %d`; do\n", 2^L-1):
+fprintf(fd, "  echo $num, E=1:\n"):
+fprintf(fd, "  sed -f TEMPLOG/log-de_$num.sed log-de.gappa | $GAPPA > /dev/null\n"):
+fprintf(fd, "  echo\n"):
+fprintf(fd, "done\n"):
+fprintf(fd, "# For the case E=0 we first handle the cases 0 and %d using log-de-E0-logir0.gappa\n", 2^L):
+fprintf(fd, "echo 0 and %d, E=0:\n", 2^L):
+fprintf(fd, "sed -f TEMPLOG/log-de_0.sed log-de-E0-logir0.gappa | $GAPPA > /dev/null\n"):
+fprintf(fd, "# then the other cases where logirh <> 0\n"):
+fprintf(fd, "for num in `seq 1 %d`; do\n", 2^L-1):
+fprintf(fd, "  echo $num, E=0:\n"):
+fprintf(fd, "  sed -f TEMPLOG/log-de_$num.sed log-de-E0.gappa | $GAPPA > /dev/null\n"):
+fprintf(fd, "  echo\n"):
+fprintf(fd, "done\n"):
+fclose(fd):
+
+printf("************ DONE TEMPLOG/run-log-de-proof.sh ************\n"):
+printf("Now you should run\n"):
+printf(" sh TEMPLOG/run-log-de-proof.sh  2>TEMPLOG/Gappa.out\n"):
+printf("  (You probably need to edit the path to the gappa executable within TEMPLOG/run-log-de-proof.sh)\n"):
+printf("Then look at TEMPLOG/Gappa.out. It shouldn't contain 'no proof'.\nThis means that everything is OK.\n\n"):
+
+
+
+
+printf("----DONE---\n") :
+