intervals 0.3.56

data/ext/crlibm/gappa/log-td-accurate.gappa

@@ -0,0 +1,217 @@
+
+log2h = <float64ne> (_log2h);
+log2m = <float64ne> (_log2m);
+log2l = <float64ne> (_log2l);
+
+Log2hml = log2h + log2m + log2l; #MAPLE
+
+logih = <float64ne> (_logih);
+logim = <float64ne> (_logim);
+logil = <float64ne> (_logil);
+
+Logihml = logih + logim + logil; #MAPLE
+
+
+accPolyC14 = <float64ne> (_accPolyC14);
+accPolyC13 = <float64ne> (_accPolyC13);
+accPolyC12 = <float64ne> (_accPolyC12);
+accPolyC11 = <float64ne> (_accPolyC11);
+accPolyC10 = <float64ne> (_accPolyC10);
+
+accPolyC9h = <float64ne> (_accPolyC9h);
+accPolyC9l = <float64ne> (_accPolyC9l);
+AccPolyC9hl = accPolyC9h + accPolyC9l; #MAPLE
+accPolyC8h = <float64ne> (_accPolyC8h);
+accPolyC8l = <float64ne> (_accPolyC8l);
+AccPolyC8hl = accPolyC8h + accPolyC8l; #MAPLE
+accPolyC7h = <float64ne> (_accPolyC7h);
+accPolyC7l = <float64ne> (_accPolyC7l);
+AccPolyC7hl = accPolyC7h + accPolyC7l; #MAPLE
+accPolyC6h = <float64ne> (_accPolyC6h);
+accPolyC6l = <float64ne> (_accPolyC6l);
+AccPolyC6hl = accPolyC6h + accPolyC6l; #MAPLE
+accPolyC5h = <float64ne> (_accPolyC5h);
+accPolyC5l = <float64ne> (_accPolyC5l);
+AccPolyC5hl = accPolyC5h + accPolyC5l; #MAPLE
+accPolyC4h = <float64ne> (_accPolyC4h);
+accPolyC4l = <float64ne> (_accPolyC4l);
+AccPolyC4hl = accPolyC4h + accPolyC4l; #MAPLE
+accPolyC3h = <float64ne> (_accPolyC3h);
+accPolyC3l = <float64ne> (_accPolyC3l);
+AccPolyC3hl = accPolyC3h + accPolyC3l; #MAPLE
+
+E = 1; #MAPLE
+
+zh = <float64ne> (Z);
+zl = Z - zh; #MAPLE
+
+highPoly <float64ne> = accPolyC10 + zh * (accPolyC11 + zh * (accPolyC12 + zh * (accPolyC13 + zh * accPolyC14)));
+
+T1hl = zh * highPoly; #MAPLE
+
+T2 = AccPolyC9hl + T1hl; #MAPLE
+T3 = Z * T2hl; #MAPLE
+T4 = AccPolyC8hl + T3hl; #MAPLE
+T5 = Z * T4hl; #MAPLE
+T6 = AccPolyC7hl + T5hl; #MAPLE
+T7 = Z * T6hl; #MAPLE
+T8 = AccPolyC6hl + T7hl; #MAPLE
+T9 = Z * T8hl; #MAPLE
+T10 = AccPolyC5hl + T9hl; #MAPLE
+T11 = Z * T10hl; #MAPLE
+T12 = AccPolyC4hl + T11hl; #MAPLE
+T13 = Z * T12hl; #MAPLE
+T14 = AccPolyC3hl + T13hl; #MAPLE
+
+
+ZSquare = Z * Z; #MAPLE
+ZCube = Z * ZSquarehml; #MAPLE
+HigherPolyMultZ = T14hl * ZCubehml; #MAPLE
+ZSquareHalfhml = -0.5 * ZSquarehml; #MAPLE
+PolyWithSquare = ZSquareHalfhml + HigherPolyMultZhml; #MAPLE
+Poly = Z + PolyWithSquarehml; #MAPLE
+Logy = Logihml + Polyhml; #MAPLE
+Log2edhml = E * Log2hml; #MAPLE
+Logover = Log2edhml + Logyhml; #MAPLE
+
+
+#Mathematical definition of the logarithm
+
+MHighPoly = accPolyC10 + Z * (accPolyC11 + Z * (accPolyC12 + Z * (accPolyC13 + Z * accPolyC14))); #MAPLE
+MT1 = Z * MHighPoly; #MAPLE
+MT2 = AccPolyC9hl + MT1; #MAPLE
+MT3 = Z * MT2; #MAPLE
+MT4 = AccPolyC8hl + MT3; #MAPLE
+MT5 = Z * MT4; #MAPLE
+MT6 = AccPolyC7hl + MT5; #MAPLE
+MT7 = Z * MT6; #MAPLE
+MT8 = AccPolyC6hl + MT7; #MAPLE
+MT9 = Z * MT8; #MAPLE
+MT10 = AccPolyC5hl + MT9; #MAPLE
+MT11 = Z * MT10; #MAPLE
+MT12 = AccPolyC4hl + MT11; #MAPLE
+MT13 = Z * MT12; #MAPLE
+MT14 = AccPolyC3hl + MT13; #MAPLE
+MZSquare = Z * Z; #MAPLE
+MZCube = Z * MZSquare; #MAPLE
+MHigherPolyMultZ = MT14 * MZCube; #MAPLE
+MZSquareHalf = -0.5 * MZSquare; #MAPLE
+MPolyWithSquare = MZSquareHalf + MHigherPolyMultZ; #MAPLE
+MPoly = Z + MPolyWithSquare; #MAPLE
+MLogy = MLogi + MLog1pZ; #MAPLE
+MLog2E = E * MLog2; #MAPLE
+MLog = MLog2E + MLogy; #MAPLE
+
+
+#Useful additional definitions
+
+delta1 = highPoly - MHighPoly; #MAPLE
+delta2 = T1hl - MT1; #MAPLE
+delta3 = T2hl - MT2; #MAPLE
+delta4 = T3hl - MT3; #MAPLE
+delta5 = T4hl - MT4; #MAPLE
+delta6 = T5hl - MT5; #MAPLE
+delta7 = T6hl - MT6; #MAPLE
+delta8 = T7hl - MT7; #MAPLE
+delta9 = T8hl - MT8; #MAPLE
+delta10 = T9hl - MT9; #MAPLE
+delta11 = T10hl - MT10; #MAPLE
+delta12 = T11hl - MT11; #MAPLE
+delta13 = T12hl - MT12; #MAPLE
+delta14 = T13hl - MT13; #MAPLE
+delta15 = T14hl - MT14; #MAPLE
+delta16 = ZSquarehml - MZSquare; #MAPLE
+delta17 = ZCubehml - MZCube; #MAPLE
+delta18 = HigherPolyMultZhml - MHigherPolyMultZ; #MAPLE
+delta19 = ZSquareHalfhml - MZSquareHalf; #MAPLE
+delta20 = PolyWithSquarehml - MPolyWithSquare; #MAPLE
+delta21 = Polyhml - MPoly; #MAPLE
+delta22 = Logyhml - MLogy; #MAPLE
+delta23 = Log2edhml - MLog2E; #MAPLE
+delta24 = Loghml - MLog; #MAPLE
+delta25 = Logihml - MLogi; #MAPLE
+delta26 = Polyhml - MLog1pZ; #MAPLE
+
+
+#End additional definitions
+
+{
+(T2hl - T2) / T2 in [-1b-103,1b-103]
+/\ (T3hl - T3) / T3 in [-1b-102,1b-102]
+/\ (T4hl - T4) / T4 in [-1b-103,1b-103]
+/\ (T5hl - T5) / T5 in [-1b-102,1b-102]
+/\ (T6hl - T6) / T6 in [-1b-103,1b-103]
+/\ (T7hl - T7) / T7 in [-1b-102,1b-102]
+/\ (T8hl - T8) / T8 in [-1b-103,1b-103]
+/\ (T9hl - T9) / T9 in [-1b-102,1b-102]
+/\ (T10hl - T10) / T10 in [-1b-103,1b-103]
+/\ (T11hl - T11) / T11 in [-1b-102,1b-102]
+/\ (T12hl - T12) / T12 in [-1b-103,1b-103]
+/\ (T13hl - T13) / T13 in [-1b-102,1b-102]
+/\ (T14hl - T14) / T14 in [-1b-103,1b-103]
+/\ (ZSquarehml - ZSquare) / ZSquare in [-1b-149,1b-149]
+/\ (ZCubehml - ZCube) / ZCube in [-1b-144,1b-144]
+/\ (HigherPolyMultZhml - HigherPolyMultZ) / HigherPolyMultZ in [-1b-141,1b-141]
+/\ (PolyWithSquarehml - PolyWithSquare) / PolyWithSquare in [-1b-137,1b-137]
+/\ (Polyhml - Poly) / Poly in [-1b-134,1b-134]
+/\ (Logyhml - Logy) / Logy in [-1b-128,1b-128]
+/\ (Loghml - Logover) / Logover in [-1b-123,1b-123]
+/\ (Log2hml - MLog2) / MLog2 in [-1b-126,1b-126]
+/\ (Logihml - MLogi) / MLogi in [-1b-159,1b-159]
+/\ (MPoly - MLog1pZ) / MLog1pZ in [-_epsilonApproxAccurate,_epsilonApproxAccurate]
+/\ Z in [_zmin,_zmax]
+/\ ((logh + logm + logl) - Loghml) / Loghml in [-1b-159,1b-159]
+->
+((logh + logm + logl) - MLog) / MLog in [-5735b-132,5735b-132]
+}
+
+MLog1pZ -> MPoly * (1 / (((MPoly - MLog1pZ) / MLog1pZ) + 1));
+MLog2 -> Log2hml * (1 / (((Log2hml - MLog2) / MLog2) + 1));
+MLogi -> Logihml * (1 / (((Logihml - MLogi) / MLogi) + 1));
+
+T2hl -> (T2 * ((T2hl - T2) / T2)) + T2;
+T3hl -> (T3 * ((T3hl - T3) / T3)) + T3;
+T4hl -> (T4 * ((T4hl - T4) / T4)) + T4;
+T5hl -> (T5 * ((T5hl - T5) / T5)) + T5;
+T6hl -> (T6 * ((T6hl - T6) / T6)) + T6;
+T7hl -> (T7 * ((T7hl - T7) / T7)) + T7;
+T8hl -> (T8 * ((T8hl - T8) / T8)) + T8;
+T9hl -> (T9 * ((T9hl - T9) / T9)) + T9;
+T10hl -> (T10 * ((T10hl - T10) / T10)) + T10;
+T11hl -> (T11 * ((T11hl - T11) / T11)) + T11;
+T12hl -> (T12 * ((T12hl - T12) / T12)) + T12;
+T13hl -> (T13 * ((T13hl - T13) / T13)) + T13;
+T14hl -> (T14 * ((T14hl - T14) / T14)) + T14;
+
+ZSquarehml -> (ZSquare * ((ZSquarehml - ZSquare) / ZSquare)) + ZSquare;
+ZCubehml -> (ZCube * ((ZCubehml - ZCube) / ZCube)) + ZCube;
+HigherPolyMultZhml -> (HigherPolyMultZ * ((HigherPolyMultZhml - HigherPolyMultZ) / HigherPolyMultZ)) + HigherPolyMultZ;
+PolyWithSquarehml -> (PolyWithSquare * ((PolyWithSquarehml - PolyWithSquare) / PolyWithSquare)) + PolyWithSquare;
+Polyhml -> (Poly * ((Polyhml - Poly) / Poly)) + Poly;
+Logyhml -> (Logy * ((Logyhml - Logy) / Logy)) + Logy;
+
+
+delta3 -> delta2 + (T2 * ((T2hl - T2) / T2));
+delta4 -> Z * delta3 + T3 * ((T3hl - T3) / T3);
+delta5 -> delta4 + (T4 * ((T4hl - T4) / T4));
+delta6 -> Z * delta5 + T5 * ((T5hl - T5) / T5);
+delta7 -> delta6 + (T6 * ((T6hl - T6) / T6));
+delta8 -> Z * delta7 + T7 * ((T7hl - T7) / T7);
+delta9 -> delta8 + (T8 * ((T8hl - T8) / T8));
+delta10 -> Z * delta9 + T9 * ((T9hl - T9) / T9);
+delta11 -> delta10 + (T10 * ((T10hl - T10) / T10));
+delta12 -> Z * delta11 + T11 * ((T11hl - T11) / T11);
+delta13 -> delta12 + (T12 * ((T12hl - T12) / T12));
+delta14 -> Z * delta13 + T13 * ((T13hl - T13) / T13);
+delta15 -> delta14 + (T14 * ((T14hl - T14) / T14));
+delta16 -> Z*Z*((ZSquarehml - ZSquare) / ZSquare);
+delta17 -> Z * delta16 + ZCube * ((ZCubehml - ZCube) / ZCube);
+delta18 -> delta15 * delta17 + delta15 * MZCube + delta17 * MT14 + 
+		HigherPolyMultZ * ((HigherPolyMultZhml - HigherPolyMultZ) / HigherPolyMultZ);
+delta20 -> delta19 + delta18 + PolyWithSquare * ((PolyWithSquarehml - PolyWithSquare) / PolyWithSquare);
+delta21 -> delta20 + Poly * ((Polyhml - Poly) / Poly);
+delta22 -> delta25 + delta26 + Logy * ((Logyhml - Logy) / Logy);
+delta26 -> delta21 + MLog1pZ * ((MPoly - MLog1pZ) / MLog1pZ);
+delta24 -> delta23 + delta22 + Logover * ((Loghml - Logover) / Logover);
+
+((logh + logm + logl) - MLog) / MLog -> ((Loghml - MLog) / MLog) + ((((logh + logm + logl) - Loghml) / Loghml) * (((Loghml - MLog) / MLog) + 1));

data/ext/crlibm/gappa/log-td.gappa

@@ -0,0 +1,156 @@
+
+
+
+log2h = <float64ne> (_log2h);
+log2m = <float64ne> (_log2m);
+log2l = <float64ne> (_log2l);
+
+c3 = <float64ne> (_c3);
+c4 = <float64ne> (_c4);
+c5 = <float64ne> (_c5);
+c6 = <float64ne> (_c6);
+c7 = <float64ne> (_c7);
+
+
+E = 1; #MAPLE
+
+logih = <float64ne> (_logih);
+logim = <float64ne> (_logim);
+logil = <float64ne> (_logil);
+
+
+zh = <float64ne> (Z);
+zl = Z - zh; #MAPLE
+
+polyHorner <float64ne>= c3 + zh * (c4 + zh * (c5 + zh * (c6 + zh * c7)));
+
+ZhSquarehl = zh * zh; #MAPLE
+zhSquareh = <float64ne> (ZhSquarehl);
+zhSquarel = <float64ne> (ZhSquarehl - zhSquareh);
+
+zhSquareHalfh = zhSquareh * (-0.5); #MAPLE
+zhSquareHalfl = zhSquarel * (-0.5); #MAPLE
+ZhSquareHalfhl = ZhSquarehl * (-0.5); #MAPLE
+
+polyUpper <float64ne>= polyHorner * (zh * zhSquareh);
+
+
+temp = <float64ne> (zh * zl);
+T1hl = polyUpper - temp; #MAPLE
+t1h = <float64ne> (T1hl);
+t1l = <float64ne> (T1hl - t1h);
+
+T2 = Z + ZhSquareHalfhl; #MAPLE
+t2h = <float64ne> (T2hl);
+t2l = <float64ne> (T2hl - t2h);
+
+PE = T2hl + T1hl; #MAPLE
+ph = <float64ne> (Phl);
+pl = <float64ne> (Phl - ph);
+
+Log2hed = E * log2h; #MAPLE
+Log2med = E * log2m; #MAPLE
+
+Log2edhm = Log2hed + Log2med; #MAPLE
+log2edh = <float64ne> (Log2edhm);
+log2edl = <float64ne> (Log2edhm - log2edh);
+
+#Useful additional definitions
+Log2hm = log2h + log2m; #MAPLE
+Logihm = logih + logim; #MAPLE
+#End additional
+
+LogTabPoly = Logihm + Phl; #MAPLE
+logTabPolyh = <float64ne> (LogTabPolyhl);
+logTabPolyl = <float64ne> (LogTabPolyhl - logTabPolyh);
+
+LogE = Log2edhm + LogTabPolyhl; #MAPLE
+logh = <float64ne> (Loghm);
+logm = <float64ne> (Loghm - logh);
+
+#Mathematical definition of the logarithm and the polynomial
+
+Phigher = (c3 + Z * (c4 + Z * (c5 + Z * (c6 + Z * c7)))); #MAPLE
+ZZZ = Z*Z*Z; #MAPLE
+ZZZPhigher = ZZZ * Phigher; #MAPLE
+HZZ = (-0.5*Z*Z); #MAPLE
+ZpHZZ = Z + HZZ; #MAPLE
+P = ZpHZZ + ZZZPhigher; #MAPLE
+Log2E = E * Log2; #MAPLE
+Log1pZpTab = Log1pZ + Logir; #MAPLE
+Log = Log2E + Log1pZpTab; #MAPLE
+
+# Useful additional definitions
+
+HZZsimp = HZZ + (zh * zl); #MAPLE
+ZpHZZsimp = Z + HZZsimp; #MAPLE
+ZZZPhigherPzhzl = ZZZPhigher - zh * zl; #MAPLE
+zhCube = zh * zhSquareh; #MAPLE
+
+delta1 = T2hl - T2; #MAPLE
+delta2 = polyUpper - (polyHorner * zhCube); #MAPLE
+delta3 = zhCube - ZZZ; #MAPLE
+delta4 = Phl - PE; #MAPLE
+delta5 = Loghm - LogE; #MAPLE
+delta6 = P - Log1pZ; #MAPLE
+delta7 = LogTabPolyhl - LogTabPoly; #MAPLE
+
+# End additional
+
+
+{
+(T2hl - T2) / T2 in [-1b-103,1b-103]
+/\ (Phl - PE) / PE in [-1b-103,1b-103]
+/\ (LogTabPolyhl - LogTabPoly) / LogTabPoly in [-1b-103,1b-103]
+/\ (Loghm - LogE) / LogE in [-1b-103,1b-103]
+/\ (Log2hm - Log2) / Log2 in [-1b-84,1b-84]
+/\ (Logihm - Logir) / Logir in [-1b-106,1b-106]
+/\ Z in [_zmin,_zmax]
+/\ (P - Log1pZ) / Log1pZ in [-_epsilonApproxQuick,_epsilonApproxQuick]
+/\ ((logh + logm) - Loghm) / Loghm in [-1b-106,1b-106]
+->
+((logh + logm) - Log) / Log in [-5b-65,5b-65]
+}
+
+T2hl - T2 -> ((T2hl - T2) / T2) * T2;
+T2hl -> (T2hl - T2) + T2;
+
+Phl - PE -> ((Phl - PE) / PE) * PE;
+Phl -> (Phl - PE) + PE;
+
+
+LogTabPolyhl -> (LogTabPolyhl - LogTabPoly) + LogTabPoly;
+
+Loghm -> (Loghm - LogE) + LogE;
+
+Log2 -> Log2hm * (1 / (((Log2hm - Log2) / Log2) + 1));
+
+Logir -> Logihm * (1 / (((Logihm - Logir) / Logir) + 1));
+
+
+LogTabPolyhl - LogTabPoly -> ((LogTabPolyhl - LogTabPoly) / LogTabPoly) * LogTabPoly;
+
+HZZsimp -> (-0.5 * zh * zh) - (0.5 * zl * zl);
+
+T2hl - ZpHZZsimp -> (0.5 * zl * zl) + delta1;
+
+zhCube - ZZZ -> (Z * (zhSquareh - Z * Z)) - (zl * zhSquareh);
+
+polyUpper - ZZZPhigher -> ZZZ * (polyHorner - Phigher) + polyHorner * delta3 + delta2;
+
+ZpHZZ + ZZZPhigher -> ZpHZZsimp + ZZZPhigherPzhzl;
+
+Phl - P -> (T2hl - ZpHZZsimp) + (T1hl - ZZZPhigherPzhzl) + delta4;
+
+Log1pZ -> P * (1 / (((P - Log1pZ) / Log1pZ) + 1));
+P - Log1pZ -> ((P - Log1pZ) / Log1pZ) * Log1pZ;
+
+Phl - Log1pZ -> (Phl - P) + delta6;
+
+LogTabPolyhl - Log1pZpTab -> (Logihm - Logir) + (Phl - Log1pZ) + delta7;
+
+Loghm - Log -> (Log2edhm - Log2E) + (LogTabPolyhl - Log1pZpTab) + delta5;
+
+(logh + logm) - Loghm -> (((logh + logm) - Loghm) / Loghm) * Loghm;
+
+(logh + logm) - Log -> ((logh + logm) - Loghm) + (Loghm - Log);

data/ext/crlibm/gappa/trigoSinCosCase3.gappa

@@ -0,0 +1,204 @@
+# Usage: You need to set the constants cah, cal, sah, sal. Running the trigo.mpl Maple script
+# should create 64 files in TEMPTRIG, which can be tested independently as 
+#    sed -f    TEMPTRIG/SinACosA_1.sed  trigoSinCosCase3.gappa | ~/gappa/src/gappa > /dev/null
+
+# NOTATION CONVENTION 
+# Variables that correspond to double-precision variables in the code begin with a small letter
+# Other variables begin with a capital letter.
+# Variables that will be replaced with Maple-computed constants begin with an underscore
+# Otherwise avoid underscores as they are painful to carry on to LaTeX :)
+
+# polynomial coefficients, computed by Maple
+s3 = <float64ne>(_s3);
+s5 = <float64ne>(_s5);
+s7 = <float64ne>(_s7);
+c2 = <float64ne>(_c2);
+c4 = <float64ne>(_c4);
+c6 = <float64ne>(_c6);
+
+# Table values, computed by Maple
+cah = <float64ne>(_cah);
+cal = <float64ne>(_cal);
+sah = <float64ne>(_sah);
+sal = <float64ne>(_sal);
+
+# The variables used here:
+# x input
+# Y perfect reduced argument
+# Ydd = yh+yl, his distance to Y is specified as an hypothesis 
+# TsHat perfect ts
+# TcHat perfect tc
+# SinX exact result for sin(x)
+# SinA, CosA perfect sin(kPi/256) and cos(kPi/256)
+
+
+yh = <float64ne>(Ydd);
+yl = Ydd - yh;
+
+#######################################################################
+
+# First, a transcription of the actual computation, which could (and
+# should eventually) be generated automatically from the actual code
+
+# ---------------------Code shared by sin and cos, cut from ComputeTrigWithArgRed : 
+yh2 <float64ne>=  yh * yh;
+ts  <float64ne>=  yh2 * (s3 + yh2*(s5 + yh2*s7));
+tc  <float64ne>=  yh2 * (c2 + yh2*(c4 + yh2*c6));
+
+# ---------------------Code for the sine, cut from DosinNotZero: 
+# Mul12(&cahyh_h,&cahyh_l, cah, yh);
+cahyh = cah * yh;
+cahyh_h = <float64ne>(cahyh);
+cahyh_l = cahyh - cahyh_h;    # Exact equation because Mul12 is exact
+
+# Add12(thi, tlo, sah, cahyh_h);
+TSin = sah + cahyh_h;
+thiSin = <float64ne>(TSin);
+tloSin1 = TSin - thiSin;          # Exact equation because Add12 is exact
+
+# Rem: need to Rename tlo to tloSin1, and its second use to tloSin2.
+# It would be safer to translate code to single-assignment before
+# using Gappa, modern compilers won't make any difference.
+
+#  tlo = tc*sah+(ts*cahyh_h+(sal+(tlo+(cahyh_l+(cal*yh + cah*yl))))) ;
+tloSin2 <float64ne>= tc*sah + (ts*cahyh_h + (sal + (tloSin1 + (cahyh_l + (cal*yh + cah*yl)))));
+
+# Add12(*reshi, *reslo, thi, tlo);
+ResultSin = thiSin + tloSin2; # we don't need to split it for the proof.
+
+
+# ---------------------Code for the cos, cut from DoCosNotZero: 
+#  Mul12(&sahyh_h,&sahyh_l, sah, yh);			            
+sahyh = sah * yh;
+sahyh_h = <float64ne>(sahyh);
+sahyh_l = sahyh - sahyh_h;    # Exact equation because Mul12 is exact
+
+#  Add12(thi, tlo,  cah, -sahyh_h);			            
+TCos = cah - sahyh_h;
+thiCos = <float64ne>(TCos);
+tloCos1 = TCos - thiCos; # Exact equation because Add12 is exact
+
+#  tlo = tc*sah+(ts*cahyh_h+(sal+(tlo+(cahyh_l+(cal*yh + cah*yl))))) ;
+tloCos2 <float64ne>= tc*cah-(ts*sahyh_h-(cal+(tloCos1-(sahyh_l+(sal*yh+sah*yl))))) ; 
+
+#  Add12(*pch, *pcl,    thi, tlo);                                   
+ResultCos = thiCos + tloCos2;   # No need to split it for the proof.
+
+
+#######################################################################
+
+# Now let us pile up layers of approximations
+
+#------------------------------------- 
+#With these notations, the exact sine and cosine are given by these
+#exact mathematical formulae
+
+SinX =  SinY * CosA  +  CosY * SinA;
+CosX =  CosY * CosA  -  SinY * SinA;
+
+#-------------------------------------
+# yh2 is an approximation to :
+Y2 = Y*Y;
+# through three layers: 
+# 1/    Ydd=yh+hl = Y +/- delta_ArgRed  : in the hypotheses below
+# 2/    yh = Ydd - yl                       : already written
+# 3/    rounding error in the mult          : already written       
+
+#-------------------------------------
+# ts is an approximation to :
+TsHat = Y2 * (s3 + Y2*(s5 + Y2*s7));
+# through two layers: 
+# 1/ the approximation y2 of Y2        : done just above
+# 2/ the rounding errors in Horner         : already written
+
+#-------------------------------------
+PolySinY = Y * (1 + TsHat);
+# PolySinY is an approximation to sin(Y) as expressed in the hypotheses below :
+#  PolySinY - SinY in [-0.24126e-23, 0.24126e-23]     # delta_approx_Sin_Case3
+
+#-------------------------------------
+# Same for PolyCosY
+TcHat = Y2 * (c2 +(Y2 * (c4 + (Y2 * c6))));
+PolyCosY = 1 + TcHat;
+
+#------------------------------------- 
+#tc is an approximation to TcHat through the rounding errors, defined
+#in the definition of tc. Same for ts
+
+#-------------------------------------
+# SinReconstrExact is an approximation to ResultSin 
+SinReconstrExact = PolySinY * CosA  +  PolyCosY * SinA ;
+# The delta between ResultSin and SinReconstrExact is due to the two
+# mathematical poly approx, and has been defined just above
+CosReconstrExact = PolyCosY * CosA  -  PolySinY * SinA ;
+
+#-------------------------------------
+# The reconstruction approximates the following
+SinReconstrNoRound = Ydd*(1 + ts)*(cah+cal) + (1 + tc)*(sah+sal);
+# where Ydd is an approximation to Y
+#       ts is an approximation to TsHat
+#       tc is an approximation to TcHat : all already described
+# All what we still need to express is that the actual computation will neglect some terms
+CosReconstrNoRound = ( (1 + tc) * (cah+cal)   -  Ydd * (1 + ts)  * (sah+sal) );
+
+#-------------------------------------
+# tloSin2 is an approximation to TloSin2NoRound (because of rounding error in the operations, already described) 
+TloSin2NoRound = tc*sah+(ts*cahyh_h+(sal+(tloSin1+(cahyh_l+(cal*yh+cah*yl))))) ;
+TloCos2NoRound = tc*cah-(ts*sahyh_h-(cal+(tloCos1-(sahyh_l+(sal*yh+sah*yl)))));
+
+#  tloSinNoRound is an approximation to SinReconstrNoRound - tSinhi, the
+#  difference being the neglected terms. This error will be given as an hint
+
+NeglectedSinTerms = SinReconstrNoRound - (thiSin + TloSin2NoRound);
+NeglectedCosTerms = CosReconstrNoRound - (thiCos + TloCos2NoRound);
+
+# And finally, ResultSin is an approximation to SinX through many layers which are given in the hints.
+
+###########################################################################################
+#  The theorem to prove
+{
+    Ydd in             [-_ymaxCase3,     _ymaxCase3]                            # computed by Maple
+ /\ Ydd - Y in         [-_delta_ArgRed,  _delta_ArgRed]                         # computed by Maple
+ /\ PolySinY - SinY in [-_delta_approx_Sin_Case3,  _delta_approx_Sin_Case3]     # computed by Maple
+ /\ PolyCosY - CosY in [-_delta_approx_Cos_Case3,  _delta_approx_Cos_Case3]     # computed by Maple
+ /\ SinA-sah-sal in [-1b-104, 1b-104] 
+ /\ CosA-cah-cal in [-1b-104, 1b-104] # double-double absolute rounding error, with margin
+
+ -> 
+
+(ResultSin - SinX)/SinX in    [-3b-66,3b-66]
+/\ 
+(ResultCos - CosX)/CosX in   [-3b-66,3b-66]
+
+
+}
+
+#(ResultSin - SinX)/SinX $ SinX;
+
+###########################################################################################
+# Hints to the reduction engine: Gappa is not supposed to be clever, it's an assistant 
+
+# To get bounds on SinX, try ResultSin
+SinX -> ResultSin - (ResultSin - SinX);
+CosX -> ResultCos - (ResultCos - CosX);
+
+# To get bounds on SinA, try sah+sal
+SinA -> sah + sal + (SinA - sah - sal);
+CosA -> cah + cal + (CosA - cah - cal);
+
+# To get bounds on Y, try Ydd
+Y ->  Ydd - (Ydd - Y); 
+
+# One layer of approx error, and one layer of rounding error for SinY and CosY
+1 + tc - CosY   ->   (1 + tc - PolyCosY) + (PolyCosY - CosY);
+(Y + Y * ts) - SinY ->   ((Y + Y * ts) - PolySinY) + (PolySinY - SinY);
+
+# Layers of approximations
+ResultSin - SinX ->  (ResultSin - SinReconstrNoRound) + (SinReconstrNoRound - SinReconstrExact) + (SinReconstrExact - SinX);
+ResultCos - CosX ->  (ResultCos - CosReconstrNoRound) + (CosReconstrNoRound - CosReconstrExact) + (CosReconstrExact - CosX);
+
+NeglectedSinTerms ->  sal*tc + cal*yl + ts*(cahyh_l + cah*yl + cal*yh + cal*yl); 
+ResultSin - SinReconstrNoRound -> (ResultSin - (thiSin + TloSin2NoRound)) - (SinReconstrNoRound    -  (thiSin + TloSin2NoRound)) ;
+
+NeglectedCosTerms ->  cal*tc - sal*yl - ts*(sahyh_l + sah*yl + sal*yh + sal*yl); 
+ResultCos - CosReconstrNoRound -> (ResultCos - (thiCos + TloCos2NoRound)) - (CosReconstrNoRound    -  (thiCos + TloCos2NoRound)) ;

data/ext/crlibm/gappa/trigoTanCase2.gappa

@@ -0,0 +1,73 @@
+# Usage: You need to replace a few constants (beginning by _) by numerical
+# values. Running the trigo.mpl Maple script will generate a
+# TEMPTRIG/tanCase2.sed sed script that does it.
+# Then sed -f TEMPTRIG/TanCase2.sed trigoTanCase2.gappa | gappa  > /dev/null
+
+
+# NOTATION CONVENTION 
+# Variables that correspond to double-precision variables in the code begin with a small letter
+# Other variables begin with a capital letter.
+# Otherwise avoid underscores as they are painful to carry on to LaTeX :)
+
+
+
+# Definition of the polynomial constants:
+t11 = <float64ne>(_t11);
+t9  = <float64ne>(_t9);
+t7  = <float64ne>(_t7);
+t5  = <float64ne>(_t5);
+t3h = <float64ne>(_t3h);
+t3l = <float64ne>(_t3l);
+
+#######################################################################
+
+# First, a transcription of the actual computation, which could (and
+# should eventually) be generated automatically from the actual code
+
+# ---------------------Code cut from tan_rn : 
+#    x2 = x*x;
+x2 <float64ne>= x * x;
+X2 = x*x;
+
+#    p5 = t5 + x2*(t7 + x2*(t9 + x2*t11));
+p5 <float64ne>= t5 + x2*(t7 + x2*(t9 + x2*t11));
+P5            = t5 + X2*(t7 + X2*(t9 + X2*t11));
+
+#    tt = x2*(t3h + (t3l + x2*p5));
+tt <float64ne>= x2*(t3h + (t3l + x2*p5));
+Tt            = X2*(t3h + (t3l + X2*p5));
+
+#    Add12(rri.rh, rri.rl, x, x*tt);   
+rdd = x + <float64ne>(x*tt);  # The Add12 is exact
+
+Poly = x+x*Tt;
+
+epsilon=(rdd - TanX)/TanX;
+
+{
+    x in [1b-30, _xmax]
+ /\ (Poly - TanX)/TanX in [-_maxEpsApprox, _maxEpsApprox]
+ /\ ((Poly - TanX)/TanX)/x in [-_maxEpsApproxOverX, _maxEpsApproxOverX]
+
+->  
+
+epsilon in ?
+/\
+epsilon/x in  [-1b-56,1b-56] 
+ 
+}
+
+# Use a dichotomy on x to get an interval of epsilon/x
+epsilon/x $ x;
+
+# The usual hint for relative errors, with an additional /x*x so that Gappa uses the Maple-computed mathematical bound
+(rdd - TanX)/TanX -> (rdd - Poly)/Poly  + (((Poly - TanX)/TanX)/x)*x + ((rdd - Poly)/Poly) * ((Poly - TanX)/TanX) ; 
+
+(rdd - Poly)/Poly  ->  ((<float64ne>(x*tt) - x*Tt) / x) * (x/Poly);
+
+# I'm not sure I understand why this one improves the result
+(<float64ne>(x*tt) - x*Tt)/x -> ((<float64ne>(x*tt) - x*tt)/(x*tt)) * tt   +  (tt - Tt);  
+
+# Easy hints
+x/Poly -> 1/(Poly/x);
+Poly/x -> 1+Tt;