intervals 0.3.56

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

@@ -0,0 +1,143 @@
+
+c3 = <float64ne> (_c3);
+c4 = <float64ne> (_c4);
+c5 = <float64ne> (_c5);
+c6 = <float64ne> (_c6);
+c7 = <float64ne> (_c7);
+
+E = 0; #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);
+
+
+#Useful additional definitions
+Log2hm = log2h + log2m; #MAPLE
+Logihm = logih + logim; #MAPLE
+#End additional
+
+LogTabPoly = Logihm + Phl; #MAPLE
+logTabPolyh = <float64ne> (LogTabPolyhl);
+logTabPolyl = <float64ne> (LogTabPolyhl - logTabPolyh);
+
+#We know that the addition of E * log2hm = 0 and logTabPolyhl is exact
+#Thus we simplify the proof at this level
+
+Loghm = 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
+Log1pZpTab = Log1pZ + Logir; #MAPLE
+
+#We apply the same simplification to the mathematical definition of the logarithm
+
+Log = 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
+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]
+/\ (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));
+
+
+
+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;
+
+(logh + logm) - Loghm -> (((logh + logm) - Loghm) / Loghm) * Loghm;
+
+(logh + logm) - Log -> ((logh + logm) - Loghm) + (Loghm - Log);

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

@@ -0,0 +1,230 @@
+
+
+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 = 0; #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
+
+#We can simplify the proof in this case since we know that adding a triple double which is 
+#equal to 0 exactly is exact.
+
+Loghml = Polyhml; #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
+
+#We apply the same simplification here
+
+MLog = MLog1pZ; #MAPLE
+
+
+#Useful additional definitions
+
+epsilon1 = (highPoly - MHighPoly) / MHighPoly; #MAPLE
+epsilon2 = (T1hl - MT1) / MT1; #MAPLE
+epsilon3 = (T2hl - MT2) / MT2; #MAPLE
+epsilon4 = (T3hl - MT3) / MT3; #MAPLE
+epsilon5 = (T4hl - MT4) / MT4; #MAPLE
+epsilon6 = (T5hl - MT5) / MT5; #MAPLE
+epsilon7 = (T6hl - MT6) / MT6; #MAPLE
+epsilon8 = (T7hl - MT7) / MT7; #MAPLE
+epsilon9 = (T8hl - MT8) / MT8; #MAPLE
+epsilon10 = (T9hl - MT9) / MT9; #MAPLE
+epsilon11 = (T10hl - MT10) / MT10; #MAPLE
+epsilon12 = (T11hl - MT11) / MT11; #MAPLE
+epsilon13 = (T12hl - MT12) / MT12; #MAPLE
+epsilon14 = (T13hl - MT13) / MT13; #MAPLE
+epsilon15 = (T14hl - MT14) / MT14; #MAPLE
+
+epsilon16 = (ZCubehml - MZCube) / MZCube; #MAPLE 
+epsilon17 = (HigherPolyMultZhml - MHigherPolyMultZ) / MHigherPolyMultZ; #MAPLE
+epsilon18 = (ZSquareHalfhml - MZSquareHalf) / MZSquareHalf; #MAPLE
+epsilon19 = (PolyWithSquarehml - MPolyWithSquare) / MPolyWithSquare; #MAPLE
+epsilon20 = (Polyhml - MLog1pZ) / MLog1pZ; #MAPLE
+
+epsilon21 = (PolyWithSquare - MPolyWithSquare) / MPolyWithSquare; #MAPLE
+epsilon22 = (Polyhml - MPoly) / MPoly; #MAPLE
+epsilon23 = (Poly - MPoly) / MPoly; #MAPLE
+
+aux1 = -0.5 * Z + MZSquare * MT14; #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]
+/\ (MPoly - MLog1pZ) / MLog1pZ in [-_epsilonApproxAccurate,_epsilonApproxAccurate]
+/\ Z in [1b-900,_zmax]
+/\ ((logh + logm + logl) - Loghml) / Loghml in [-1b-159,1b-159]
+->
+((logh + logm + logl) - MLog) / MLog in [-5735b-132,5735b-132]
+)
+/\
+(
+(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]
+/\ (MPoly - MLog1pZ) / MLog1pZ in [-_epsilonApproxAccurate,_epsilonApproxAccurate]
+/\ Z in [_zmin,-1b-900]
+/\ ((logh + logm + logl) - Loghml) / Loghml in [-1b-159,1b-159]
+->
+((logh + logm + logl) - MLog) / MLog in [-5735b-132,5735b-132]
+)
+}
+
+((logh + logm + logl) - MLog) / MLog -> ((Loghml - MLog) / MLog) + ((((logh + logm + logl) - Loghml) / Loghml) * (((Loghml - MLog) / MLog) + 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;
+
+
+epsilon2 -> epsilon1 + (((zh - Z) / Z) * (epsilon1 + 1));
+epsilon3 -> ((epsilon2 * MT1) / (AccPolyC9hl + MT1)) + (((AccPolyC9hl + T1hl) / (AccPolyC9hl + MT1)) * ((T2hl - T2) / T2));
+epsilon4 -> epsilon3 + (((T3hl - T3) / T3) * (epsilon3 + 1));
+epsilon5 -> ((epsilon4 * MT3) / (AccPolyC8hl + MT3)) + (((AccPolyC8hl + T3hl) / (AccPolyC8hl + MT3)) * ((T4hl - T4) / T4));
+epsilon6 -> epsilon5 + (((T5hl - T5) / T5) * (epsilon5 + 1));
+epsilon7 -> ((epsilon6 * MT5) / (AccPolyC7hl + MT5)) + (((AccPolyC7hl + T5hl) / (AccPolyC7hl + MT5)) * ((T6hl - T6) / T6));
+epsilon8 -> epsilon7 + (((T7hl - T7) / T7) * (epsilon7 + 1));
+epsilon9 -> ((epsilon8 * MT7) / (AccPolyC6hl + MT7)) + (((AccPolyC6hl + T7hl) / (AccPolyC6hl + MT7)) * ((T8hl - T8) / T8));
+epsilon10 -> epsilon9 + (((T9hl - T9) / T9) * (epsilon9 + 1));
+epsilon11 -> ((epsilon10 * MT9) / (AccPolyC5hl + MT9)) + (((AccPolyC5hl + T9hl) / (AccPolyC5hl + MT9)) * ((T10hl - T10) / T10));
+epsilon12 -> epsilon11 + (((T11hl - T11) / T11) * (epsilon11 + 1));
+epsilon13 -> ((epsilon12 * MT11) / (AccPolyC4hl + MT11)) + (((AccPolyC4hl + T11hl) / (AccPolyC4hl + MT11)) * ((T12hl - T12) / T12));
+epsilon14 -> epsilon13 + (((T13hl - T13) / T13) * (epsilon13 + 1));
+epsilon15 -> ((epsilon14 * MT13) / (AccPolyC3hl + MT13)) + (((AccPolyC3hl + T13hl) / (AccPolyC3hl + MT13)) * ((T14hl - T14) / T14));
+epsilon16 -> ((ZSquarehml - MZSquare) / MZSquare) + (((ZCubehml - ZCube) / ZCube) * (((ZSquarehml - MZSquare) / MZSquare) + 1));
+epsilon17 -> epsilon15 + epsilon16 + epsilon15 * epsilon16 + 
+((HigherPolyMultZhml - HigherPolyMultZ) / HigherPolyMultZ) * (1 + epsilon15 + epsilon16 + epsilon15 * epsilon16);
+epsilon18 -> (ZSquarehml - MZSquare) / MZSquare;
+epsilon19 -> epsilon21 + (1 + epsilon21) * ((PolyWithSquarehml - PolyWithSquare) / PolyWithSquare);
+epsilon20 -> (((Polyhml - MPoly) / MPoly) + ((MPoly - MLog1pZ) / MLog1pZ)) + (((Polyhml - MPoly) / MPoly) * ((MPoly - MLog1pZ) / MLog1pZ));
+epsilon21 -> ((-0.5 * epsilon18) + (Z * MT14 * epsilon17)) / (-0.5 + (Z * MT14));
+epsilon22 -> epsilon23 + (((Polyhml - Poly) / Poly) * (1+ epsilon23));
+epsilon23 -> epsilon19 * (aux1 / (1 + aux1));

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

@@ -0,0 +1,213 @@
+
+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 = 0; #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
+
+#We can simplify the proof in this case since we know that adding a triple double which is 
+#equal to 0 exactly is exact.
+
+Loghml = 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
+
+#We apply the same simplification here
+
+MLog = 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
+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]
+/\ (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);
+
+
+((logh + logm + logl) - MLog) / MLog -> ((Loghml - MLog) / MLog) + ((((logh + logm + logl) - Loghml) / Loghml) * (((Loghml - MLog) / MLog) + 1));