
(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 11 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 (/ (+ hi x) lo)) (t_1 (/ hi (/ (* lo lo) (- hi x)))))
(+
(/
(+ (pow t_1 3.0) (pow t_0 3.0))
(fma (* (/ hi lo) (/ hi lo)) (* t_0 (/ (- hi x) lo)) (* t_0 (- t_0 t_1))))
1.0)))
double code(double lo, double hi, double x) {
double t_0 = (hi + x) / lo;
double t_1 = hi / ((lo * lo) / (hi - x));
return ((pow(t_1, 3.0) + pow(t_0, 3.0)) / fma(((hi / lo) * (hi / lo)), (t_0 * ((hi - x) / lo)), (t_0 * (t_0 - t_1)))) + 1.0;
}
function code(lo, hi, x) t_0 = Float64(Float64(hi + x) / lo) t_1 = Float64(hi / Float64(Float64(lo * lo) / Float64(hi - x))) return Float64(Float64(Float64((t_1 ^ 3.0) + (t_0 ^ 3.0)) / fma(Float64(Float64(hi / lo) * Float64(hi / lo)), Float64(t_0 * Float64(Float64(hi - x) / lo)), Float64(t_0 * Float64(t_0 - t_1)))) + 1.0) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[(hi / N[(N[(lo * lo), $MachinePrecision] / N[(hi - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[Power[t$95$1, 3.0], $MachinePrecision] + N[Power[t$95$0, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(hi / lo), $MachinePrecision] * N[(hi / lo), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[(t$95$0 - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi + x}{lo}\\
t_1 := \frac{hi}{\frac{lo \cdot lo}{hi - x}}\\
\frac{{t_1}^{3} + {t_0}^{3}}{\mathsf{fma}\left(\frac{hi}{lo} \cdot \frac{hi}{lo}, t_0 \cdot \frac{hi - x}{lo}, t_0 \cdot \left(t_0 - t_1\right)\right)} + 1
\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-frac19.0%
distribute-lft-out--19.0%
associate-*r/19.0%
fma-neg19.0%
Simplified19.0%
add-cbrt-cube19.0%
pow319.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod14.5%
sqr-neg14.5%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
fma-udef19.0%
flip3-+19.0%
rem-cube-cbrt19.0%
pow219.0%
rem-cbrt-cube19.0%
rem-cbrt-cube19.0%
Applied egg-rr19.0%
times-frac0.0%
unpow20.0%
associate-/l*21.2%
unpow221.2%
+-commutative21.2%
swap-sqr21.2%
fma-def21.2%
Simplified24.4%
expm1-log1p-u13.5%
expm1-udef13.5%
sub-neg13.5%
add-sqr-sqrt6.8%
sqrt-unprod10.5%
sqr-neg10.5%
sqrt-unprod6.7%
add-sqr-sqrt13.5%
Applied egg-rr13.5%
expm1-def13.5%
expm1-log1p24.4%
+-commutative24.4%
Simplified24.4%
Final simplification24.4%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (+ hi x) lo)) (t_1 (/ hi (/ (* lo lo) (- hi x)))))
(+
(/
(+ (pow t_1 3.0) (pow t_0 3.0))
(fma
(* (/ hi lo) (/ hi lo))
(* (/ hi lo) (/ (- hi x) lo))
(* t_0 (- t_0 t_1))))
1.0)))
double code(double lo, double hi, double x) {
double t_0 = (hi + x) / lo;
double t_1 = hi / ((lo * lo) / (hi - x));
return ((pow(t_1, 3.0) + pow(t_0, 3.0)) / fma(((hi / lo) * (hi / lo)), ((hi / lo) * ((hi - x) / lo)), (t_0 * (t_0 - t_1)))) + 1.0;
}
function code(lo, hi, x) t_0 = Float64(Float64(hi + x) / lo) t_1 = Float64(hi / Float64(Float64(lo * lo) / Float64(hi - x))) return Float64(Float64(Float64((t_1 ^ 3.0) + (t_0 ^ 3.0)) / fma(Float64(Float64(hi / lo) * Float64(hi / lo)), Float64(Float64(hi / lo) * Float64(Float64(hi - x) / lo)), Float64(t_0 * Float64(t_0 - t_1)))) + 1.0) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[(hi / N[(N[(lo * lo), $MachinePrecision] / N[(hi - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[Power[t$95$1, 3.0], $MachinePrecision] + N[Power[t$95$0, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(hi / lo), $MachinePrecision] * N[(hi / lo), $MachinePrecision]), $MachinePrecision] * N[(N[(hi / lo), $MachinePrecision] * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[(t$95$0 - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi + x}{lo}\\
t_1 := \frac{hi}{\frac{lo \cdot lo}{hi - x}}\\
\frac{{t_1}^{3} + {t_0}^{3}}{\mathsf{fma}\left(\frac{hi}{lo} \cdot \frac{hi}{lo}, \frac{hi}{lo} \cdot \frac{hi - x}{lo}, t_0 \cdot \left(t_0 - t_1\right)\right)} + 1
\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-frac19.0%
distribute-lft-out--19.0%
associate-*r/19.0%
fma-neg19.0%
Simplified19.0%
add-cbrt-cube19.0%
pow319.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod14.5%
sqr-neg14.5%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
fma-udef19.0%
flip3-+19.0%
rem-cube-cbrt19.0%
pow219.0%
rem-cbrt-cube19.0%
rem-cbrt-cube19.0%
Applied egg-rr19.0%
times-frac0.0%
unpow20.0%
associate-/l*21.2%
unpow221.2%
+-commutative21.2%
swap-sqr21.2%
fma-def21.2%
Simplified24.4%
Taylor expanded in hi around inf 24.4%
Final simplification24.4%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- hi x) lo)) (t_1 (/ (+ hi x) lo)))
(+
(/
(pow t_1 3.0)
(fma
(* (/ hi lo) (/ hi lo))
(* t_0 t_0)
(* t_1 (- t_1 (/ hi (/ (* lo lo) (- hi x)))))))
1.0)))
double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
double t_1 = (hi + x) / lo;
return (pow(t_1, 3.0) / fma(((hi / lo) * (hi / lo)), (t_0 * t_0), (t_1 * (t_1 - (hi / ((lo * lo) / (hi - x))))))) + 1.0;
}
function code(lo, hi, x) t_0 = Float64(Float64(hi - x) / lo) t_1 = Float64(Float64(hi + x) / lo) return Float64(Float64((t_1 ^ 3.0) / fma(Float64(Float64(hi / lo) * Float64(hi / lo)), Float64(t_0 * t_0), Float64(t_1 * Float64(t_1 - Float64(hi / Float64(Float64(lo * lo) / Float64(hi - x))))))) + 1.0) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision]}, N[(N[(N[Power[t$95$1, 3.0], $MachinePrecision] / N[(N[(N[(hi / lo), $MachinePrecision] * N[(hi / lo), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 * t$95$0), $MachinePrecision] + N[(t$95$1 * N[(t$95$1 - N[(hi / N[(N[(lo * lo), $MachinePrecision] / N[(hi - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi - x}{lo}\\
t_1 := \frac{hi + x}{lo}\\
\frac{{t_1}^{3}}{\mathsf{fma}\left(\frac{hi}{lo} \cdot \frac{hi}{lo}, t_0 \cdot t_0, t_1 \cdot \left(t_1 - \frac{hi}{\frac{lo \cdot lo}{hi - x}}\right)\right)} + 1
\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-frac19.0%
distribute-lft-out--19.0%
associate-*r/19.0%
fma-neg19.0%
Simplified19.0%
add-cbrt-cube19.0%
pow319.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod14.5%
sqr-neg14.5%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
fma-udef19.0%
flip3-+19.0%
rem-cube-cbrt19.0%
pow219.0%
rem-cbrt-cube19.0%
rem-cbrt-cube19.0%
Applied egg-rr19.0%
times-frac0.0%
unpow20.0%
associate-/l*21.2%
unpow221.2%
+-commutative21.2%
swap-sqr21.2%
fma-def21.2%
Simplified24.4%
Taylor expanded in lo around inf 0.0%
cube-div24.4%
Simplified24.4%
Final simplification24.4%
(FPCore (lo hi x) :precision binary64 (fabs (pow (/ lo hi) 2.0)))
double code(double lo, double hi, double x) {
return fabs(pow((lo / hi), 2.0));
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = abs(((lo / hi) ** 2.0d0))
end function
public static double code(double lo, double hi, double x) {
return Math.abs(Math.pow((lo / hi), 2.0));
}
def code(lo, hi, x): return math.fabs(math.pow((lo / hi), 2.0))
function code(lo, hi, x) return abs((Float64(lo / hi) ^ 2.0)) end
function tmp = code(lo, hi, x) tmp = abs(((lo / hi) ^ 2.0)); end
code[lo_, hi_, x_] := N[Abs[N[Power[N[(lo / hi), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\left|{\left(\frac{lo}{hi}\right)}^{2}\right|
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.9%
div-sub8.9%
Simplified8.9%
add-sqr-sqrt8.1%
sqrt-unprod18.1%
pow218.1%
fma-def18.1%
Applied egg-rr18.1%
unpow218.1%
rem-sqrt-square18.1%
fma-udef18.1%
*-rgt-identity18.1%
distribute-lft-out18.1%
distribute-rgt-out18.1%
*-lft-identity18.1%
distribute-lft1-in18.1%
distribute-rgt1-in18.1%
*-lft-identity18.1%
distribute-rgt-out18.1%
Simplified18.1%
Taylor expanded in lo around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
times-frac19.1%
unpow219.1%
Simplified19.1%
Final simplification19.1%
(FPCore (lo hi x) :precision binary64 (fabs (* (/ lo hi) (/ (- x lo) hi))))
double code(double lo, double hi, double x) {
return fabs(((lo / hi) * ((x - lo) / hi)));
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = abs(((lo / hi) * ((x - lo) / hi)))
end function
public static double code(double lo, double hi, double x) {
return Math.abs(((lo / hi) * ((x - lo) / hi)));
}
def code(lo, hi, x): return math.fabs(((lo / hi) * ((x - lo) / hi)))
function code(lo, hi, x) return abs(Float64(Float64(lo / hi) * Float64(Float64(x - lo) / hi))) end
function tmp = code(lo, hi, x) tmp = abs(((lo / hi) * ((x - lo) / hi))); end
code[lo_, hi_, x_] := N[Abs[N[(N[(lo / hi), $MachinePrecision] * N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\left|\frac{lo}{hi} \cdot \frac{x - lo}{hi}\right|
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.9%
div-sub8.9%
Simplified8.9%
add-sqr-sqrt8.1%
sqrt-unprod18.1%
pow218.1%
fma-def18.1%
Applied egg-rr18.1%
unpow218.1%
rem-sqrt-square18.1%
fma-udef18.1%
*-rgt-identity18.1%
distribute-lft-out18.1%
distribute-rgt-out18.1%
*-lft-identity18.1%
distribute-lft1-in18.1%
distribute-rgt1-in18.1%
*-lft-identity18.1%
distribute-rgt-out18.1%
Simplified18.1%
Taylor expanded in lo around inf 19.1%
Final simplification19.1%
(FPCore (lo hi x) :precision binary64 (+ (+ (/ (+ hi x) lo) (* (/ hi lo) (/ (- hi x) lo))) 1.0))
double code(double lo, double hi, double x) {
return (((hi + x) / lo) + ((hi / lo) * ((hi - x) / lo))) + 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 = (((hi + x) / lo) + ((hi / lo) * ((hi - x) / lo))) + 1.0d0
end function
public static double code(double lo, double hi, double x) {
return (((hi + x) / lo) + ((hi / lo) * ((hi - x) / lo))) + 1.0;
}
def code(lo, hi, x): return (((hi + x) / lo) + ((hi / lo) * ((hi - x) / lo))) + 1.0
function code(lo, hi, x) return Float64(Float64(Float64(Float64(hi + x) / lo) + Float64(Float64(hi / lo) * Float64(Float64(hi - x) / lo))) + 1.0) end
function tmp = code(lo, hi, x) tmp = (((hi + x) / lo) + ((hi / lo) * ((hi - x) / lo))) + 1.0; end
code[lo_, hi_, x_] := N[(N[(N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + N[(N[(hi / lo), $MachinePrecision] * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\left(\frac{hi + x}{lo} + \frac{hi}{lo} \cdot \frac{hi - x}{lo}\right) + 1
\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-frac19.0%
distribute-lft-out--19.0%
associate-*r/19.0%
fma-neg19.0%
Simplified19.0%
add-cbrt-cube19.0%
pow319.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod14.5%
sqr-neg14.5%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
fma-udef19.0%
rem-cbrt-cube19.0%
Applied egg-rr19.0%
Final simplification19.0%
(FPCore (lo hi x) :precision binary64 (+ (+ (/ (+ hi x) lo) (* (/ hi lo) (/ hi lo))) 1.0))
double code(double lo, double hi, double x) {
return (((hi + x) / lo) + ((hi / lo) * (hi / lo))) + 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 = (((hi + x) / lo) + ((hi / lo) * (hi / lo))) + 1.0d0
end function
public static double code(double lo, double hi, double x) {
return (((hi + x) / lo) + ((hi / lo) * (hi / lo))) + 1.0;
}
def code(lo, hi, x): return (((hi + x) / lo) + ((hi / lo) * (hi / lo))) + 1.0
function code(lo, hi, x) return Float64(Float64(Float64(Float64(hi + x) / lo) + Float64(Float64(hi / lo) * Float64(hi / lo))) + 1.0) end
function tmp = code(lo, hi, x) tmp = (((hi + x) / lo) + ((hi / lo) * (hi / lo))) + 1.0; end
code[lo_, hi_, x_] := N[(N[(N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + N[(N[(hi / lo), $MachinePrecision] * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\left(\frac{hi + x}{lo} + \frac{hi}{lo} \cdot \frac{hi}{lo}\right) + 1
\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-frac19.0%
distribute-lft-out--19.0%
associate-*r/19.0%
fma-neg19.0%
Simplified19.0%
add-cbrt-cube19.0%
pow319.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod14.5%
sqr-neg14.5%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
fma-udef19.0%
rem-cbrt-cube19.0%
Applied egg-rr19.0%
Taylor expanded in hi around inf 19.0%
Final simplification19.0%
(FPCore (lo hi x) :precision binary64 (+ (* (/ (+ hi x) lo) (+ (/ hi lo) 1.0)) 1.0))
double code(double lo, double hi, double x) {
return (((hi + x) / lo) * ((hi / lo) + 1.0)) + 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 = (((hi + x) / lo) * ((hi / lo) + 1.0d0)) + 1.0d0
end function
public static double code(double lo, double hi, double x) {
return (((hi + x) / lo) * ((hi / lo) + 1.0)) + 1.0;
}
def code(lo, hi, x): return (((hi + x) / lo) * ((hi / lo) + 1.0)) + 1.0
function code(lo, hi, x) return Float64(Float64(Float64(Float64(hi + x) / lo) * Float64(Float64(hi / lo) + 1.0)) + 1.0) end
function tmp = code(lo, hi, x) tmp = (((hi + x) / lo) * ((hi / lo) + 1.0)) + 1.0; end
code[lo_, hi_, x_] := N[(N[(N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] * N[(N[(hi / lo), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{hi + x}{lo} \cdot \left(\frac{hi}{lo} + 1\right) + 1
\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-frac19.0%
distribute-lft-out--19.0%
associate-*r/19.0%
fma-neg19.0%
Simplified19.0%
fma-udef19.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod15.1%
sqr-neg15.1%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod14.5%
sqr-neg14.5%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
distribute-lft1-in19.0%
+-commutative19.0%
+-commutative19.0%
Simplified19.0%
Final simplification19.0%
(FPCore (lo hi x) :precision binary64 (+ (* (/ hi lo) (+ (/ hi lo) 1.0)) 1.0))
double code(double lo, double hi, double x) {
return ((hi / lo) * ((hi / lo) + 1.0)) + 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 = ((hi / lo) * ((hi / lo) + 1.0d0)) + 1.0d0
end function
public static double code(double lo, double hi, double x) {
return ((hi / lo) * ((hi / lo) + 1.0)) + 1.0;
}
def code(lo, hi, x): return ((hi / lo) * ((hi / lo) + 1.0)) + 1.0
function code(lo, hi, x) return Float64(Float64(Float64(hi / lo) * Float64(Float64(hi / lo) + 1.0)) + 1.0) end
function tmp = code(lo, hi, x) tmp = ((hi / lo) * ((hi / lo) + 1.0)) + 1.0; end
code[lo_, hi_, x_] := N[(N[(N[(hi / lo), $MachinePrecision] * N[(N[(hi / lo), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{hi}{lo} \cdot \left(\frac{hi}{lo} + 1\right) + 1
\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-frac19.0%
distribute-lft-out--19.0%
associate-*r/19.0%
fma-neg19.0%
Simplified19.0%
add-cbrt-cube19.0%
pow319.0%
sub-neg19.0%
add-sqr-sqrt9.5%
sqrt-unprod14.5%
sqr-neg14.5%
sqrt-unprod9.4%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
fma-udef19.0%
rem-cbrt-cube19.0%
Applied egg-rr19.0%
Taylor expanded in x around 0 0.0%
*-rgt-identity0.0%
unpow20.0%
unpow20.0%
times-frac19.0%
distribute-lft-in19.0%
Simplified19.0%
Final simplification19.0%
(FPCore (lo hi x) :precision binary64 (/ (- lo) hi))
double code(double lo, double hi, double x) {
return -lo / hi;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = -lo / hi
end function
public static double code(double lo, double hi, double x) {
return -lo / hi;
}
def code(lo, hi, x): return -lo / hi
function code(lo, hi, x) return Float64(Float64(-lo) / hi) end
function tmp = code(lo, hi, x) tmp = -lo / hi; end
code[lo_, hi_, x_] := N[((-lo) / hi), $MachinePrecision]
\begin{array}{l}
\\
\frac{-lo}{hi}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
Taylor expanded in x around 0 18.8%
neg-mul-118.8%
distribute-neg-frac18.8%
Simplified18.8%
Final simplification18.8%
(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 2023299
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))