
(FPCore (lo hi x) :precision binary64 (/ (- x lo) (- hi lo)))
double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = (x - lo) / (hi - lo)
end function
public static double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
def code(lo, hi, x): return (x - lo) / (hi - lo)
function code(lo, hi, x) return Float64(Float64(x - lo) / Float64(hi - lo)) end
function tmp = code(lo, hi, x) tmp = (x - lo) / (hi - lo); end
code[lo_, hi_, x_] := N[(N[(x - lo), $MachinePrecision] / N[(hi - lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - lo}{hi - lo}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 7 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (lo hi x) :precision binary64 (/ (- x lo) (- hi lo)))
double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = (x - lo) / (hi - lo)
end function
public static double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
def code(lo, hi, x): return (x - lo) / (hi - lo)
function code(lo, hi, x) return Float64(Float64(x - lo) / Float64(hi - lo)) end
function tmp = code(lo, hi, x) tmp = (x - lo) / (hi - lo); end
code[lo_, hi_, x_] := N[(N[(x - lo), $MachinePrecision] / N[(hi - lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - lo}{hi - lo}
\end{array}
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (* lo lo) hi)) (t_1 (/ (- hi x) t_0)) (t_2 (/ (+ hi x) lo)))
(+
1.0
(/
(* (fma t_2 (+ t_2 (/ (- x hi) t_0)) (pow t_1 2.0)) (+ t_2 t_1))
(+
(pow (/ (- hi x) (* lo (/ lo hi))) 2.0)
(+ (pow t_2 2.0) (* (/ hi lo) (* t_2 (/ (- x hi) lo)))))))))
double code(double lo, double hi, double x) {
double t_0 = (lo * lo) / hi;
double t_1 = (hi - x) / t_0;
double t_2 = (hi + x) / lo;
return 1.0 + ((fma(t_2, (t_2 + ((x - hi) / t_0)), pow(t_1, 2.0)) * (t_2 + t_1)) / (pow(((hi - x) / (lo * (lo / hi))), 2.0) + (pow(t_2, 2.0) + ((hi / lo) * (t_2 * ((x - hi) / lo))))));
}
function code(lo, hi, x) t_0 = Float64(Float64(lo * lo) / hi) t_1 = Float64(Float64(hi - x) / t_0) t_2 = Float64(Float64(hi + x) / lo) return Float64(1.0 + Float64(Float64(fma(t_2, Float64(t_2 + Float64(Float64(x - hi) / t_0)), (t_1 ^ 2.0)) * Float64(t_2 + t_1)) / Float64((Float64(Float64(hi - x) / Float64(lo * Float64(lo / hi))) ^ 2.0) + Float64((t_2 ^ 2.0) + Float64(Float64(hi / lo) * Float64(t_2 * Float64(Float64(x - hi) / lo))))))) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(lo * lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$1 = N[(N[(hi - x), $MachinePrecision] / t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision]}, N[(1.0 + N[(N[(N[(t$95$2 * N[(t$95$2 + N[(N[(x - hi), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision] * N[(t$95$2 + t$95$1), $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[(N[(hi - x), $MachinePrecision] / N[(lo * N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(N[Power[t$95$2, 2.0], $MachinePrecision] + N[(N[(hi / lo), $MachinePrecision] * N[(t$95$2 * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{lo \cdot lo}{hi}\\
t_1 := \frac{hi - x}{t_0}\\
t_2 := \frac{hi + x}{lo}\\
1 + \frac{\mathsf{fma}\left(t_2, t_2 + \frac{x - hi}{t_0}, {t_1}^{2}\right) \cdot \left(t_2 + t_1\right)}{{\left(\frac{hi - x}{lo \cdot \frac{lo}{hi}}\right)}^{2} + \left({t_2}^{2} + \frac{hi}{lo} \cdot \left(t_2 \cdot \frac{x - hi}{lo}\right)\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.9%
distribute-lft-out--18.9%
associate-*r/18.9%
fma-neg18.9%
Simplified18.9%
clear-num18.9%
inv-pow18.9%
sub-neg18.9%
add-sqr-sqrt9.5%
sqrt-unprod13.4%
sqr-neg13.4%
sqrt-unprod9.3%
add-sqr-sqrt18.9%
Applied egg-rr18.9%
fma-udef18.9%
unpow-118.9%
clear-num18.9%
flip3-+18.9%
pow218.9%
clear-num18.9%
unpow-118.9%
clear-num18.9%
unpow-118.9%
pow-prod-up18.9%
metadata-eval18.9%
Applied egg-rr18.9%
times-frac0.0%
*-commutative0.0%
associate-/l*21.1%
associate-*r/19.4%
+-commutative19.4%
times-frac0.0%
*-commutative0.0%
associate-/l*39.3%
associate-*r/39.4%
Simplified39.4%
sum-cubes39.4%
+-commutative39.4%
+-commutative39.4%
+-commutative39.4%
+-commutative39.4%
Applied egg-rr39.4%
Simplified41.1%
Final simplification41.1%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (+ hi x) lo)))
(+
1.0
(/
(pow t_0 3.0)
(+
(pow (/ (- hi x) (* lo (/ lo hi))) 2.0)
(+ (pow t_0 2.0) (* (/ hi lo) (* t_0 (/ (- x hi) lo)))))))))
double code(double lo, double hi, double x) {
double t_0 = (hi + x) / lo;
return 1.0 + (pow(t_0, 3.0) / (pow(((hi - x) / (lo * (lo / hi))), 2.0) + (pow(t_0, 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))));
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
real(8) :: t_0
t_0 = (hi + x) / lo
code = 1.0d0 + ((t_0 ** 3.0d0) / ((((hi - x) / (lo * (lo / hi))) ** 2.0d0) + ((t_0 ** 2.0d0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (hi + x) / lo;
return 1.0 + (Math.pow(t_0, 3.0) / (Math.pow(((hi - x) / (lo * (lo / hi))), 2.0) + (Math.pow(t_0, 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))));
}
def code(lo, hi, x): t_0 = (hi + x) / lo return 1.0 + (math.pow(t_0, 3.0) / (math.pow(((hi - x) / (lo * (lo / hi))), 2.0) + (math.pow(t_0, 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))))
function code(lo, hi, x) t_0 = Float64(Float64(hi + x) / lo) return Float64(1.0 + Float64((t_0 ^ 3.0) / Float64((Float64(Float64(hi - x) / Float64(lo * Float64(lo / hi))) ^ 2.0) + Float64((t_0 ^ 2.0) + Float64(Float64(hi / lo) * Float64(t_0 * Float64(Float64(x - hi) / lo))))))) end
function tmp = code(lo, hi, x) t_0 = (hi + x) / lo; tmp = 1.0 + ((t_0 ^ 3.0) / ((((hi - x) / (lo * (lo / hi))) ^ 2.0) + ((t_0 ^ 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo)))))); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision]}, N[(1.0 + N[(N[Power[t$95$0, 3.0], $MachinePrecision] / N[(N[Power[N[(N[(hi - x), $MachinePrecision] / N[(lo * N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(N[Power[t$95$0, 2.0], $MachinePrecision] + N[(N[(hi / lo), $MachinePrecision] * N[(t$95$0 * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi + x}{lo}\\
1 + \frac{{t_0}^{3}}{{\left(\frac{hi - x}{lo \cdot \frac{lo}{hi}}\right)}^{2} + \left({t_0}^{2} + \frac{hi}{lo} \cdot \left(t_0 \cdot \frac{x - hi}{lo}\right)\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.9%
distribute-lft-out--18.9%
associate-*r/18.9%
fma-neg18.9%
Simplified18.9%
clear-num18.9%
inv-pow18.9%
sub-neg18.9%
add-sqr-sqrt9.5%
sqrt-unprod13.4%
sqr-neg13.4%
sqrt-unprod9.3%
add-sqr-sqrt18.9%
Applied egg-rr18.9%
fma-udef18.9%
unpow-118.9%
clear-num18.9%
flip3-+18.9%
pow218.9%
clear-num18.9%
unpow-118.9%
clear-num18.9%
unpow-118.9%
pow-prod-up18.9%
metadata-eval18.9%
Applied egg-rr18.9%
times-frac0.0%
*-commutative0.0%
associate-/l*21.1%
associate-*r/19.4%
+-commutative19.4%
times-frac0.0%
*-commutative0.0%
associate-/l*39.3%
associate-*r/39.4%
Simplified39.4%
Taylor expanded in lo around inf 0.0%
cube-div41.1%
Simplified41.1%
Final simplification41.1%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (+ hi x) lo)) (t_1 (* lo (/ lo hi))) (t_2 (/ (- x hi) t_1)))
(+
1.0
(/
(* (+ (* t_2 t_2) (+ (* t_0 t_0) (* t_0 t_2))) (- t_0 t_2))
(+
(pow (/ (- hi x) t_1) 2.0)
(+ (pow t_0 2.0) (* (/ hi lo) (* t_0 (/ (- x hi) lo)))))))))
double code(double lo, double hi, double x) {
double t_0 = (hi + x) / lo;
double t_1 = lo * (lo / hi);
double t_2 = (x - hi) / t_1;
return 1.0 + ((((t_2 * t_2) + ((t_0 * t_0) + (t_0 * t_2))) * (t_0 - t_2)) / (pow(((hi - x) / t_1), 2.0) + (pow(t_0, 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))));
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
t_0 = (hi + x) / lo
t_1 = lo * (lo / hi)
t_2 = (x - hi) / t_1
code = 1.0d0 + ((((t_2 * t_2) + ((t_0 * t_0) + (t_0 * t_2))) * (t_0 - t_2)) / ((((hi - x) / t_1) ** 2.0d0) + ((t_0 ** 2.0d0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (hi + x) / lo;
double t_1 = lo * (lo / hi);
double t_2 = (x - hi) / t_1;
return 1.0 + ((((t_2 * t_2) + ((t_0 * t_0) + (t_0 * t_2))) * (t_0 - t_2)) / (Math.pow(((hi - x) / t_1), 2.0) + (Math.pow(t_0, 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))));
}
def code(lo, hi, x): t_0 = (hi + x) / lo t_1 = lo * (lo / hi) t_2 = (x - hi) / t_1 return 1.0 + ((((t_2 * t_2) + ((t_0 * t_0) + (t_0 * t_2))) * (t_0 - t_2)) / (math.pow(((hi - x) / t_1), 2.0) + (math.pow(t_0, 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo))))))
function code(lo, hi, x) t_0 = Float64(Float64(hi + x) / lo) t_1 = Float64(lo * Float64(lo / hi)) t_2 = Float64(Float64(x - hi) / t_1) return Float64(1.0 + Float64(Float64(Float64(Float64(t_2 * t_2) + Float64(Float64(t_0 * t_0) + Float64(t_0 * t_2))) * Float64(t_0 - t_2)) / Float64((Float64(Float64(hi - x) / t_1) ^ 2.0) + Float64((t_0 ^ 2.0) + Float64(Float64(hi / lo) * Float64(t_0 * Float64(Float64(x - hi) / lo))))))) end
function tmp = code(lo, hi, x) t_0 = (hi + x) / lo; t_1 = lo * (lo / hi); t_2 = (x - hi) / t_1; tmp = 1.0 + ((((t_2 * t_2) + ((t_0 * t_0) + (t_0 * t_2))) * (t_0 - t_2)) / ((((hi - x) / t_1) ^ 2.0) + ((t_0 ^ 2.0) + ((hi / lo) * (t_0 * ((x - hi) / lo)))))); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[(lo * N[(lo / hi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x - hi), $MachinePrecision] / t$95$1), $MachinePrecision]}, N[(1.0 + N[(N[(N[(N[(t$95$2 * t$95$2), $MachinePrecision] + N[(N[(t$95$0 * t$95$0), $MachinePrecision] + N[(t$95$0 * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 - t$95$2), $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[(N[(hi - x), $MachinePrecision] / t$95$1), $MachinePrecision], 2.0], $MachinePrecision] + N[(N[Power[t$95$0, 2.0], $MachinePrecision] + N[(N[(hi / lo), $MachinePrecision] * N[(t$95$0 * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi + x}{lo}\\
t_1 := lo \cdot \frac{lo}{hi}\\
t_2 := \frac{x - hi}{t_1}\\
1 + \frac{\left(t_2 \cdot t_2 + \left(t_0 \cdot t_0 + t_0 \cdot t_2\right)\right) \cdot \left(t_0 - t_2\right)}{{\left(\frac{hi - x}{t_1}\right)}^{2} + \left({t_0}^{2} + \frac{hi}{lo} \cdot \left(t_0 \cdot \frac{x - hi}{lo}\right)\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.9%
distribute-lft-out--18.9%
associate-*r/18.9%
fma-neg18.9%
Simplified18.9%
clear-num18.9%
inv-pow18.9%
sub-neg18.9%
add-sqr-sqrt9.5%
sqrt-unprod13.4%
sqr-neg13.4%
sqrt-unprod9.3%
add-sqr-sqrt18.9%
Applied egg-rr18.9%
fma-udef18.9%
unpow-118.9%
clear-num18.9%
flip3-+18.9%
pow218.9%
clear-num18.9%
unpow-118.9%
clear-num18.9%
unpow-118.9%
pow-prod-up18.9%
metadata-eval18.9%
Applied egg-rr18.9%
times-frac0.0%
*-commutative0.0%
associate-/l*21.1%
associate-*r/19.4%
+-commutative19.4%
times-frac0.0%
*-commutative0.0%
associate-/l*39.3%
associate-*r/39.4%
Simplified39.4%
sum-cubes39.4%
+-commutative39.4%
+-commutative39.4%
+-commutative39.4%
+-commutative39.4%
Applied egg-rr39.4%
Final simplification39.4%
(FPCore (lo hi x)
:precision binary64
(+
1.0
(*
lo
(/
(- (pow (/ (- hi x) (* lo (/ lo hi))) 2.0) (pow (/ (- hi x) lo) 2.0))
(- x (+ hi (* (/ hi lo) (- x hi))))))))
double code(double lo, double hi, double x) {
return 1.0 + (lo * ((pow(((hi - x) / (lo * (lo / hi))), 2.0) - pow(((hi - x) / lo), 2.0)) / (x - (hi + ((hi / lo) * (x - hi))))));
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = 1.0d0 + (lo * (((((hi - x) / (lo * (lo / hi))) ** 2.0d0) - (((hi - x) / lo) ** 2.0d0)) / (x - (hi + ((hi / lo) * (x - hi))))))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + (lo * ((Math.pow(((hi - x) / (lo * (lo / hi))), 2.0) - Math.pow(((hi - x) / lo), 2.0)) / (x - (hi + ((hi / lo) * (x - hi))))));
}
def code(lo, hi, x): return 1.0 + (lo * ((math.pow(((hi - x) / (lo * (lo / hi))), 2.0) - math.pow(((hi - x) / lo), 2.0)) / (x - (hi + ((hi / lo) * (x - hi))))))
function code(lo, hi, x) return Float64(1.0 + Float64(lo * Float64(Float64((Float64(Float64(hi - x) / Float64(lo * Float64(lo / hi))) ^ 2.0) - (Float64(Float64(hi - x) / lo) ^ 2.0)) / Float64(x - Float64(hi + Float64(Float64(hi / lo) * Float64(x - hi))))))) end
function tmp = code(lo, hi, x) tmp = 1.0 + (lo * (((((hi - x) / (lo * (lo / hi))) ^ 2.0) - (((hi - x) / lo) ^ 2.0)) / (x - (hi + ((hi / lo) * (x - hi)))))); end
code[lo_, hi_, x_] := N[(1.0 + N[(lo * N[(N[(N[Power[N[(N[(hi - x), $MachinePrecision] / N[(lo * N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(x - N[(hi + N[(N[(hi / lo), $MachinePrecision] * N[(x - hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + lo \cdot \frac{{\left(\frac{hi - x}{lo \cdot \frac{lo}{hi}}\right)}^{2} - {\left(\frac{hi - x}{lo}\right)}^{2}}{x - \left(hi + \frac{hi}{lo} \cdot \left(x - hi\right)\right)}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.9%
distribute-lft-out--18.9%
associate-*r/18.9%
fma-neg18.9%
Simplified18.9%
Taylor expanded in lo around 0 0.0%
+-commutative0.0%
associate--l+0.0%
unpow20.0%
times-frac18.9%
div-sub18.9%
Simplified18.9%
flip-+18.9%
div-sub18.9%
pow218.9%
associate-*r/38.3%
sub-div95.3%
pow295.3%
associate-*r/76.0%
sub-div18.8%
Applied egg-rr18.8%
div-sub18.8%
associate-/r/18.8%
times-frac0.0%
*-commutative0.0%
associate-/l*22.7%
associate-*r/22.4%
associate--r-22.1%
*-commutative22.1%
Simplified22.1%
Final simplification22.1%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (/ (- (pow (/ (- hi x) lo) 2.0) (pow (/ (- hi x) (* lo (/ lo hi))) 2.0)) (/ (- (+ hi (* (/ hi lo) (- x hi))) x) lo))))
double code(double lo, double hi, double x) {
return 1.0 + ((pow(((hi - x) / lo), 2.0) - pow(((hi - x) / (lo * (lo / hi))), 2.0)) / (((hi + ((hi / lo) * (x - hi))) - x) / lo));
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = 1.0d0 + (((((hi - x) / lo) ** 2.0d0) - (((hi - x) / (lo * (lo / hi))) ** 2.0d0)) / (((hi + ((hi / lo) * (x - hi))) - x) / lo))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + ((Math.pow(((hi - x) / lo), 2.0) - Math.pow(((hi - x) / (lo * (lo / hi))), 2.0)) / (((hi + ((hi / lo) * (x - hi))) - x) / lo));
}
def code(lo, hi, x): return 1.0 + ((math.pow(((hi - x) / lo), 2.0) - math.pow(((hi - x) / (lo * (lo / hi))), 2.0)) / (((hi + ((hi / lo) * (x - hi))) - x) / lo))
function code(lo, hi, x) return Float64(1.0 + Float64(Float64((Float64(Float64(hi - x) / lo) ^ 2.0) - (Float64(Float64(hi - x) / Float64(lo * Float64(lo / hi))) ^ 2.0)) / Float64(Float64(Float64(hi + Float64(Float64(hi / lo) * Float64(x - hi))) - x) / lo))) end
function tmp = code(lo, hi, x) tmp = 1.0 + (((((hi - x) / lo) ^ 2.0) - (((hi - x) / (lo * (lo / hi))) ^ 2.0)) / (((hi + ((hi / lo) * (x - hi))) - x) / lo)); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(N[Power[N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(N[(hi - x), $MachinePrecision] / N[(lo * N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(hi + N[(N[(hi / lo), $MachinePrecision] * N[(x - hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{{\left(\frac{hi - x}{lo}\right)}^{2} - {\left(\frac{hi - x}{lo \cdot \frac{lo}{hi}}\right)}^{2}}{\frac{\left(hi + \frac{hi}{lo} \cdot \left(x - hi\right)\right) - x}{lo}}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.9%
distribute-lft-out--18.9%
associate-*r/18.9%
fma-neg18.9%
Simplified18.9%
Taylor expanded in lo around 0 0.0%
+-commutative0.0%
associate--l+0.0%
unpow20.0%
times-frac18.9%
div-sub18.9%
Simplified18.9%
flip-+18.9%
frac-2neg18.9%
pow218.9%
pow218.9%
associate-*r/19.1%
sub-div18.8%
Applied egg-rr18.8%
times-frac0.0%
*-commutative0.0%
associate-/l*22.8%
associate-*r/22.5%
distribute-neg-frac22.5%
associate--r-22.2%
*-commutative22.2%
Simplified22.2%
Final simplification22.2%
(FPCore (lo hi x) :precision binary64 (* (/ (+ hi x) lo) (/ hi lo)))
double code(double lo, double hi, double x) {
return ((hi + x) / lo) * (hi / lo);
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = ((hi + x) / lo) * (hi / lo)
end function
public static double code(double lo, double hi, double x) {
return ((hi + x) / lo) * (hi / lo);
}
def code(lo, hi, x): return ((hi + x) / lo) * (hi / lo)
function code(lo, hi, x) return Float64(Float64(Float64(hi + x) / lo) * Float64(hi / lo)) end
function tmp = code(lo, hi, x) tmp = ((hi + x) / lo) * (hi / lo); end
code[lo_, hi_, x_] := N[(N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] * N[(hi / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{hi + x}{lo} \cdot \frac{hi}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.9%
distribute-lft-out--18.9%
associate-*r/18.9%
fma-neg18.9%
Simplified18.9%
expm1-log1p-u18.9%
expm1-udef18.9%
Applied egg-rr18.8%
expm1-def18.8%
expm1-log1p18.8%
fma-def18.8%
distribute-lft1-in18.9%
+-commutative18.9%
+-commutative18.9%
fma-def18.9%
Simplified18.9%
Taylor expanded in hi around -inf 0.0%
+-commutative0.0%
mul-1-neg0.0%
unsub-neg0.0%
unpow20.0%
unpow20.0%
times-frac9.9%
unpow29.9%
unpow29.9%
associate-*r/9.9%
neg-mul-19.9%
Simplified9.9%
Taylor expanded in lo around 0 0.0%
associate-*r*0.0%
neg-mul-10.0%
cancel-sign-sub0.0%
unpow20.0%
distribute-lft-in0.0%
unpow20.0%
times-frac19.4%
Simplified19.4%
Final simplification19.4%
(FPCore (lo hi x) :precision binary64 1.0)
double code(double lo, double hi, double x) {
return 1.0;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = 1.0d0
end function
public static double code(double lo, double hi, double x) {
return 1.0;
}
def code(lo, hi, x): return 1.0
function code(lo, hi, x) return 1.0 end
function tmp = code(lo, hi, x) tmp = 1.0; end
code[lo_, hi_, x_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 18.7%
Final simplification18.7%
herbie shell --seed 2023277
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))