
(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 10 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 (/ (- x lo) hi))
(t_1 (pow t_0 2.0))
(t_2 (/ lo (/ (* hi hi) (- x lo)))))
(/
(+ (pow t_0 3.0) (pow t_2 3.0))
(+ (pow t_2 2.0) (- t_1 (* t_1 (/ lo hi)))))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = pow(t_0, 2.0);
double t_2 = lo / ((hi * hi) / (x - lo));
return (pow(t_0, 3.0) + pow(t_2, 3.0)) / (pow(t_2, 2.0) + (t_1 - (t_1 * (lo / hi))));
}
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 = (x - lo) / hi
t_1 = t_0 ** 2.0d0
t_2 = lo / ((hi * hi) / (x - lo))
code = ((t_0 ** 3.0d0) + (t_2 ** 3.0d0)) / ((t_2 ** 2.0d0) + (t_1 - (t_1 * (lo / hi))))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = Math.pow(t_0, 2.0);
double t_2 = lo / ((hi * hi) / (x - lo));
return (Math.pow(t_0, 3.0) + Math.pow(t_2, 3.0)) / (Math.pow(t_2, 2.0) + (t_1 - (t_1 * (lo / hi))));
}
def code(lo, hi, x): t_0 = (x - lo) / hi t_1 = math.pow(t_0, 2.0) t_2 = lo / ((hi * hi) / (x - lo)) return (math.pow(t_0, 3.0) + math.pow(t_2, 3.0)) / (math.pow(t_2, 2.0) + (t_1 - (t_1 * (lo / hi))))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) t_1 = t_0 ^ 2.0 t_2 = Float64(lo / Float64(Float64(hi * hi) / Float64(x - lo))) return Float64(Float64((t_0 ^ 3.0) + (t_2 ^ 3.0)) / Float64((t_2 ^ 2.0) + Float64(t_1 - Float64(t_1 * Float64(lo / hi))))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; t_1 = t_0 ^ 2.0; t_2 = lo / ((hi * hi) / (x - lo)); tmp = ((t_0 ^ 3.0) + (t_2 ^ 3.0)) / ((t_2 ^ 2.0) + (t_1 - (t_1 * (lo / hi)))); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$1 = N[Power[t$95$0, 2.0], $MachinePrecision]}, Block[{t$95$2 = N[(lo / N[(N[(hi * hi), $MachinePrecision] / N[(x - lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[Power[t$95$0, 3.0], $MachinePrecision] + N[Power[t$95$2, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[t$95$2, 2.0], $MachinePrecision] + N[(t$95$1 - N[(t$95$1 * N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
t_1 := {t_0}^{2}\\
t_2 := \frac{lo}{\frac{hi \cdot hi}{x - lo}}\\
\frac{{t_0}^{3} + {t_2}^{3}}{{t_2}^{2} + \left(t_1 - t_1 \cdot \frac{lo}{hi}\right)}
\end{array}
\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-frac9.4%
div-sub9.4%
Simplified9.4%
div-inv9.4%
inv-pow9.4%
Applied egg-rr9.4%
unpow-19.4%
Simplified9.4%
clear-num9.4%
inv-pow9.4%
Applied egg-rr9.4%
unpow-19.4%
Simplified9.4%
flip3-+9.4%
div-inv9.4%
*-commutative9.4%
clear-num9.4%
Applied egg-rr9.4%
times-frac0.0%
+-commutative0.0%
unpow20.0%
associate-/l*19.7%
unpow219.7%
Simplified98.9%
Final simplification98.9%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x lo) hi)) (t_1 (* lo (/ (- x lo) (* hi hi)))))
(/
(+ (pow t_0 3.0) (pow t_1 3.0))
(+
(pow t_1 2.0)
(- (pow t_0 2.0) (* (/ lo hi) (pow (/ hi (- x lo)) -2.0)))))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = lo * ((x - lo) / (hi * hi));
return (pow(t_0, 3.0) + pow(t_1, 3.0)) / (pow(t_1, 2.0) + (pow(t_0, 2.0) - ((lo / hi) * pow((hi / (x - lo)), -2.0))));
}
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
t_0 = (x - lo) / hi
t_1 = lo * ((x - lo) / (hi * hi))
code = ((t_0 ** 3.0d0) + (t_1 ** 3.0d0)) / ((t_1 ** 2.0d0) + ((t_0 ** 2.0d0) - ((lo / hi) * ((hi / (x - lo)) ** (-2.0d0)))))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = lo * ((x - lo) / (hi * hi));
return (Math.pow(t_0, 3.0) + Math.pow(t_1, 3.0)) / (Math.pow(t_1, 2.0) + (Math.pow(t_0, 2.0) - ((lo / hi) * Math.pow((hi / (x - lo)), -2.0))));
}
def code(lo, hi, x): t_0 = (x - lo) / hi t_1 = lo * ((x - lo) / (hi * hi)) return (math.pow(t_0, 3.0) + math.pow(t_1, 3.0)) / (math.pow(t_1, 2.0) + (math.pow(t_0, 2.0) - ((lo / hi) * math.pow((hi / (x - lo)), -2.0))))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) t_1 = Float64(lo * Float64(Float64(x - lo) / Float64(hi * hi))) return Float64(Float64((t_0 ^ 3.0) + (t_1 ^ 3.0)) / Float64((t_1 ^ 2.0) + Float64((t_0 ^ 2.0) - Float64(Float64(lo / hi) * (Float64(hi / Float64(x - lo)) ^ -2.0))))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; t_1 = lo * ((x - lo) / (hi * hi)); tmp = ((t_0 ^ 3.0) + (t_1 ^ 3.0)) / ((t_1 ^ 2.0) + ((t_0 ^ 2.0) - ((lo / hi) * ((hi / (x - lo)) ^ -2.0)))); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$1 = N[(lo * N[(N[(x - lo), $MachinePrecision] / N[(hi * hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[Power[t$95$0, 3.0], $MachinePrecision] + N[Power[t$95$1, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[t$95$1, 2.0], $MachinePrecision] + N[(N[Power[t$95$0, 2.0], $MachinePrecision] - N[(N[(lo / hi), $MachinePrecision] * N[Power[N[(hi / N[(x - lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
t_1 := lo \cdot \frac{x - lo}{hi \cdot hi}\\
\frac{{t_0}^{3} + {t_1}^{3}}{{t_1}^{2} + \left({t_0}^{2} - \frac{lo}{hi} \cdot {\left(\frac{hi}{x - lo}\right)}^{-2}\right)}
\end{array}
\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-frac9.4%
div-sub9.4%
Simplified9.4%
div-inv9.4%
inv-pow9.4%
Applied egg-rr9.4%
unpow-19.4%
Simplified9.4%
Applied egg-rr18.7%
cube-div0.0%
+-commutative0.0%
cube-div18.7%
associate-*r/0.0%
*-commutative0.0%
times-frac10.9%
associate-*l/10.6%
associate-*r/10.9%
associate-/l/18.7%
Simplified98.3%
expm1-log1p-u49.1%
expm1-udef49.2%
associate-/l/18.7%
Applied egg-rr18.7%
expm1-def18.7%
expm1-log1p18.7%
associate-*r*18.7%
unpow218.7%
associate-*r/0.0%
*-commutative0.0%
unpow20.0%
times-frac98.9%
associate-*l*98.9%
*-lft-identity98.9%
associate-*r/98.9%
associate-*l/98.5%
associate-/r/98.7%
unpow-198.7%
*-lft-identity98.7%
associate-*r/98.7%
associate-*l/98.4%
associate-/r/98.6%
unpow-198.6%
pow-sqr98.6%
metadata-eval98.6%
Simplified98.6%
Final simplification98.6%
(FPCore (lo hi x) :precision binary64 (/ (- (pow (* (- x lo) (/ lo (* hi hi))) 2.0) (pow (/ hi (- x lo)) -2.0)) (* (/ (- lo x) hi) (- 1.0 (/ lo hi)))))
double code(double lo, double hi, double x) {
return (pow(((x - lo) * (lo / (hi * hi))), 2.0) - pow((hi / (x - lo)), -2.0)) / (((lo - x) / hi) * (1.0 - (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 = ((((x - lo) * (lo / (hi * hi))) ** 2.0d0) - ((hi / (x - lo)) ** (-2.0d0))) / (((lo - x) / hi) * (1.0d0 - (lo / hi)))
end function
public static double code(double lo, double hi, double x) {
return (Math.pow(((x - lo) * (lo / (hi * hi))), 2.0) - Math.pow((hi / (x - lo)), -2.0)) / (((lo - x) / hi) * (1.0 - (lo / hi)));
}
def code(lo, hi, x): return (math.pow(((x - lo) * (lo / (hi * hi))), 2.0) - math.pow((hi / (x - lo)), -2.0)) / (((lo - x) / hi) * (1.0 - (lo / hi)))
function code(lo, hi, x) return Float64(Float64((Float64(Float64(x - lo) * Float64(lo / Float64(hi * hi))) ^ 2.0) - (Float64(hi / Float64(x - lo)) ^ -2.0)) / Float64(Float64(Float64(lo - x) / hi) * Float64(1.0 - Float64(lo / hi)))) end
function tmp = code(lo, hi, x) tmp = ((((x - lo) * (lo / (hi * hi))) ^ 2.0) - ((hi / (x - lo)) ^ -2.0)) / (((lo - x) / hi) * (1.0 - (lo / hi))); end
code[lo_, hi_, x_] := N[(N[(N[Power[N[(N[(x - lo), $MachinePrecision] * N[(lo / N[(hi * hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(hi / N[(x - lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(lo - x), $MachinePrecision] / hi), $MachinePrecision] * N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{{\left(\left(x - lo\right) \cdot \frac{lo}{hi \cdot hi}\right)}^{2} - {\left(\frac{hi}{x - lo}\right)}^{-2}}{\frac{lo - x}{hi} \cdot \left(1 - \frac{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-frac9.4%
div-sub9.4%
Simplified9.4%
div-inv9.4%
inv-pow9.4%
Applied egg-rr9.4%
unpow-19.4%
Simplified9.4%
clear-num9.4%
inv-pow9.4%
Applied egg-rr9.4%
unpow-19.4%
Simplified9.4%
clear-num9.4%
flip-+9.4%
pow29.4%
div-inv9.4%
*-commutative9.4%
pow29.4%
div-inv9.4%
*-commutative9.4%
Applied egg-rr9.4%
Simplified98.5%
Final simplification98.5%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x lo) hi)) (t_1 (/ hi (- x lo))))
(if (<= lo -1.06e+308)
(+ (exp (+ (/ x hi) (- (* (pow t_0 2.0) -0.5) (/ lo hi)))) -1.0)
(/
(+ (pow (/ (- x lo) (* hi (/ hi lo))) 2.0) (/ -1.0 (* t_1 t_1)))
(/ (+ (* lo t_0) (- lo x)) hi)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = exp(((x / hi) + ((pow(t_0, 2.0) * -0.5) - (lo / hi)))) + -1.0;
} else {
tmp = (pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_1 * t_1))) / (((lo * t_0) + (lo - x)) / hi);
}
return tmp;
}
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) :: tmp
t_0 = (x - lo) / hi
t_1 = hi / (x - lo)
if (lo <= (-1.06d+308)) then
tmp = exp(((x / hi) + (((t_0 ** 2.0d0) * (-0.5d0)) - (lo / hi)))) + (-1.0d0)
else
tmp = ((((x - lo) / (hi * (hi / lo))) ** 2.0d0) + ((-1.0d0) / (t_1 * t_1))) / (((lo * t_0) + (lo - x)) / hi)
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = Math.exp(((x / hi) + ((Math.pow(t_0, 2.0) * -0.5) - (lo / hi)))) + -1.0;
} else {
tmp = (Math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_1 * t_1))) / (((lo * t_0) + (lo - x)) / hi);
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - lo) / hi t_1 = hi / (x - lo) tmp = 0 if lo <= -1.06e+308: tmp = math.exp(((x / hi) + ((math.pow(t_0, 2.0) * -0.5) - (lo / hi)))) + -1.0 else: tmp = (math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_1 * t_1))) / (((lo * t_0) + (lo - x)) / hi) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) t_1 = Float64(hi / Float64(x - lo)) tmp = 0.0 if (lo <= -1.06e+308) tmp = Float64(exp(Float64(Float64(x / hi) + Float64(Float64((t_0 ^ 2.0) * -0.5) - Float64(lo / hi)))) + -1.0); else tmp = Float64(Float64((Float64(Float64(x - lo) / Float64(hi * Float64(hi / lo))) ^ 2.0) + Float64(-1.0 / Float64(t_1 * t_1))) / Float64(Float64(Float64(lo * t_0) + Float64(lo - x)) / hi)); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - lo) / hi; t_1 = hi / (x - lo); tmp = 0.0; if (lo <= -1.06e+308) tmp = exp(((x / hi) + (((t_0 ^ 2.0) * -0.5) - (lo / hi)))) + -1.0; else tmp = ((((x - lo) / (hi * (hi / lo))) ^ 2.0) + (-1.0 / (t_1 * t_1))) / (((lo * t_0) + (lo - x)) / hi); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$1 = N[(hi / N[(x - lo), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lo, -1.06e+308], N[(N[Exp[N[(N[(x / hi), $MachinePrecision] + N[(N[(N[Power[t$95$0, 2.0], $MachinePrecision] * -0.5), $MachinePrecision] - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[Power[N[(N[(x - lo), $MachinePrecision] / N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(-1.0 / N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(lo * t$95$0), $MachinePrecision] + N[(lo - x), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
t_1 := \frac{hi}{x - lo}\\
\mathbf{if}\;lo \leq -1.06 \cdot 10^{+308}:\\
\;\;\;\;e^{\frac{x}{hi} + \left({t_0}^{2} \cdot -0.5 - \frac{lo}{hi}\right)} + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{x - lo}{hi \cdot \frac{hi}{lo}}\right)}^{2} + \frac{-1}{t_1 \cdot t_1}}{\frac{lo \cdot t_0 + \left(lo - x\right)}{hi}}\\
\end{array}
\end{array}
if lo < -1.06e308Initial program 3.1%
Taylor expanded in hi around inf 18.7%
expm1-log1p-u18.7%
expm1-udef18.7%
Applied egg-rr18.7%
Taylor expanded in hi around inf 0.0%
associate--l+0.0%
unpow20.0%
unpow20.0%
*-rgt-identity0.0%
times-frac21.8%
*-rgt-identity21.8%
unpow221.8%
Simplified21.8%
if -1.06e308 < lo Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac18.3%
div-sub18.3%
Simplified18.3%
flip-+18.3%
pow218.3%
*-commutative18.3%
clear-num18.3%
frac-times63.3%
*-un-lft-identity63.3%
pow263.3%
associate-*r/63.2%
sub-div50.9%
Applied egg-rr50.9%
unpow250.9%
clear-num51.0%
clear-num50.9%
frac-times51.1%
metadata-eval51.1%
Applied egg-rr51.1%
Final simplification23.6%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ hi (- x lo))))
(if (<= lo -1.06e+308)
(expm1 (log1p (- (/ x hi) (* lo (/ (- 1.0 (/ x hi)) hi)))))
(/
(+ (pow (/ (- x lo) (* hi (/ hi lo))) 2.0) (/ -1.0 (* t_0 t_0)))
(/ (+ (* lo (/ (- x lo) hi)) (- lo x)) hi)))))
double code(double lo, double hi, double x) {
double t_0 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = expm1(log1p(((x / hi) - (lo * ((1.0 - (x / hi)) / hi)))));
} else {
tmp = (pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi);
}
return tmp;
}
public static double code(double lo, double hi, double x) {
double t_0 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = Math.expm1(Math.log1p(((x / hi) - (lo * ((1.0 - (x / hi)) / hi)))));
} else {
tmp = (Math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi);
}
return tmp;
}
def code(lo, hi, x): t_0 = hi / (x - lo) tmp = 0 if lo <= -1.06e+308: tmp = math.expm1(math.log1p(((x / hi) - (lo * ((1.0 - (x / hi)) / hi))))) else: tmp = (math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi) return tmp
function code(lo, hi, x) t_0 = Float64(hi / Float64(x - lo)) tmp = 0.0 if (lo <= -1.06e+308) tmp = expm1(log1p(Float64(Float64(x / hi) - Float64(lo * Float64(Float64(1.0 - Float64(x / hi)) / hi))))); else tmp = Float64(Float64((Float64(Float64(x - lo) / Float64(hi * Float64(hi / lo))) ^ 2.0) + Float64(-1.0 / Float64(t_0 * t_0))) / Float64(Float64(Float64(lo * Float64(Float64(x - lo) / hi)) + Float64(lo - x)) / hi)); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(hi / N[(x - lo), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lo, -1.06e+308], N[(Exp[N[Log[1 + N[(N[(x / hi), $MachinePrecision] - N[(lo * N[(N[(1.0 - N[(x / hi), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision], N[(N[(N[Power[N[(N[(x - lo), $MachinePrecision] / N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(-1.0 / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(lo * N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision] + N[(lo - x), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi}{x - lo}\\
\mathbf{if}\;lo \leq -1.06 \cdot 10^{+308}:\\
\;\;\;\;\mathsf{expm1}\left(\mathsf{log1p}\left(\frac{x}{hi} - lo \cdot \frac{1 - \frac{x}{hi}}{hi}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{x - lo}{hi \cdot \frac{hi}{lo}}\right)}^{2} + \frac{-1}{t_0 \cdot t_0}}{\frac{lo \cdot \frac{x - lo}{hi} + \left(lo - x\right)}{hi}}\\
\end{array}
\end{array}
if lo < -1.06e308Initial program 3.1%
Taylor expanded in lo around 0 18.7%
mul-1-neg18.7%
unsub-neg18.7%
mul-1-neg18.7%
unsub-neg18.7%
unpow218.7%
Simplified18.7%
expm1-log1p-u18.7%
associate-/r*18.7%
sub-div18.7%
Applied egg-rr18.7%
if -1.06e308 < lo Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac18.3%
div-sub18.3%
Simplified18.3%
flip-+18.3%
pow218.3%
*-commutative18.3%
clear-num18.3%
frac-times63.3%
*-un-lft-identity63.3%
pow263.3%
associate-*r/63.2%
sub-div50.9%
Applied egg-rr50.9%
unpow250.9%
clear-num51.0%
clear-num50.9%
frac-times51.1%
metadata-eval51.1%
Applied egg-rr51.1%
Final simplification20.8%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ hi (- x lo))))
(if (<= lo -1.06e+308)
(- (/ x hi) (* lo (exp (log (/ (- 1.0 (/ x hi)) hi)))))
(/
(+ (pow (/ (- x lo) (* hi (/ hi lo))) 2.0) (/ -1.0 (* t_0 t_0)))
(/ (+ (* lo (/ (- x lo) hi)) (- lo x)) hi)))))
double code(double lo, double hi, double x) {
double t_0 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = (x / hi) - (lo * exp(log(((1.0 - (x / hi)) / hi))));
} else {
tmp = (pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi);
}
return tmp;
}
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) :: tmp
t_0 = hi / (x - lo)
if (lo <= (-1.06d+308)) then
tmp = (x / hi) - (lo * exp(log(((1.0d0 - (x / hi)) / hi))))
else
tmp = ((((x - lo) / (hi * (hi / lo))) ** 2.0d0) + ((-1.0d0) / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi)
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = (x / hi) - (lo * Math.exp(Math.log(((1.0 - (x / hi)) / hi))));
} else {
tmp = (Math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi);
}
return tmp;
}
def code(lo, hi, x): t_0 = hi / (x - lo) tmp = 0 if lo <= -1.06e+308: tmp = (x / hi) - (lo * math.exp(math.log(((1.0 - (x / hi)) / hi)))) else: tmp = (math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi) return tmp
function code(lo, hi, x) t_0 = Float64(hi / Float64(x - lo)) tmp = 0.0 if (lo <= -1.06e+308) tmp = Float64(Float64(x / hi) - Float64(lo * exp(log(Float64(Float64(1.0 - Float64(x / hi)) / hi))))); else tmp = Float64(Float64((Float64(Float64(x - lo) / Float64(hi * Float64(hi / lo))) ^ 2.0) + Float64(-1.0 / Float64(t_0 * t_0))) / Float64(Float64(Float64(lo * Float64(Float64(x - lo) / hi)) + Float64(lo - x)) / hi)); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = hi / (x - lo); tmp = 0.0; if (lo <= -1.06e+308) tmp = (x / hi) - (lo * exp(log(((1.0 - (x / hi)) / hi)))); else tmp = ((((x - lo) / (hi * (hi / lo))) ^ 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(hi / N[(x - lo), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lo, -1.06e+308], N[(N[(x / hi), $MachinePrecision] - N[(lo * N[Exp[N[Log[N[(N[(1.0 - N[(x / hi), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[N[(N[(x - lo), $MachinePrecision] / N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(-1.0 / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(lo * N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision] + N[(lo - x), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi}{x - lo}\\
\mathbf{if}\;lo \leq -1.06 \cdot 10^{+308}:\\
\;\;\;\;\frac{x}{hi} - lo \cdot e^{\log \left(\frac{1 - \frac{x}{hi}}{hi}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{x - lo}{hi \cdot \frac{hi}{lo}}\right)}^{2} + \frac{-1}{t_0 \cdot t_0}}{\frac{lo \cdot \frac{x - lo}{hi} + \left(lo - x\right)}{hi}}\\
\end{array}
\end{array}
if lo < -1.06e308Initial program 3.1%
Taylor expanded in lo around 0 18.7%
mul-1-neg18.7%
unsub-neg18.7%
mul-1-neg18.7%
unsub-neg18.7%
unpow218.7%
Simplified18.7%
add-exp-log18.7%
associate-/r*18.7%
sub-div18.7%
Applied egg-rr18.7%
if -1.06e308 < lo Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac18.3%
div-sub18.3%
Simplified18.3%
flip-+18.3%
pow218.3%
*-commutative18.3%
clear-num18.3%
frac-times63.3%
*-un-lft-identity63.3%
pow263.3%
associate-*r/63.2%
sub-div50.9%
Applied egg-rr50.9%
unpow250.9%
clear-num51.0%
clear-num50.9%
frac-times51.1%
metadata-eval51.1%
Applied egg-rr51.1%
Final simplification20.8%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ hi (- x lo))))
(if (<= lo -1.06e+308)
(/ (- lo) hi)
(/
(+ (pow (/ (- x lo) (* hi (/ hi lo))) 2.0) (/ -1.0 (* t_0 t_0)))
(/ (+ (* lo (/ (- x lo) hi)) (- lo x)) hi)))))
double code(double lo, double hi, double x) {
double t_0 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = -lo / hi;
} else {
tmp = (pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi);
}
return tmp;
}
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) :: tmp
t_0 = hi / (x - lo)
if (lo <= (-1.06d+308)) then
tmp = -lo / hi
else
tmp = ((((x - lo) / (hi * (hi / lo))) ** 2.0d0) + ((-1.0d0) / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi)
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = hi / (x - lo);
double tmp;
if (lo <= -1.06e+308) {
tmp = -lo / hi;
} else {
tmp = (Math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi);
}
return tmp;
}
def code(lo, hi, x): t_0 = hi / (x - lo) tmp = 0 if lo <= -1.06e+308: tmp = -lo / hi else: tmp = (math.pow(((x - lo) / (hi * (hi / lo))), 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi) return tmp
function code(lo, hi, x) t_0 = Float64(hi / Float64(x - lo)) tmp = 0.0 if (lo <= -1.06e+308) tmp = Float64(Float64(-lo) / hi); else tmp = Float64(Float64((Float64(Float64(x - lo) / Float64(hi * Float64(hi / lo))) ^ 2.0) + Float64(-1.0 / Float64(t_0 * t_0))) / Float64(Float64(Float64(lo * Float64(Float64(x - lo) / hi)) + Float64(lo - x)) / hi)); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = hi / (x - lo); tmp = 0.0; if (lo <= -1.06e+308) tmp = -lo / hi; else tmp = ((((x - lo) / (hi * (hi / lo))) ^ 2.0) + (-1.0 / (t_0 * t_0))) / (((lo * ((x - lo) / hi)) + (lo - x)) / hi); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(hi / N[(x - lo), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lo, -1.06e+308], N[((-lo) / hi), $MachinePrecision], N[(N[(N[Power[N[(N[(x - lo), $MachinePrecision] / N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(-1.0 / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(lo * N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision] + N[(lo - x), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi}{x - lo}\\
\mathbf{if}\;lo \leq -1.06 \cdot 10^{+308}:\\
\;\;\;\;\frac{-lo}{hi}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{x - lo}{hi \cdot \frac{hi}{lo}}\right)}^{2} + \frac{-1}{t_0 \cdot t_0}}{\frac{lo \cdot \frac{x - lo}{hi} + \left(lo - x\right)}{hi}}\\
\end{array}
\end{array}
if lo < -1.06e308Initial program 3.1%
Taylor expanded in lo around 0 18.7%
mul-1-neg18.7%
unsub-neg18.7%
mul-1-neg18.7%
unsub-neg18.7%
unpow218.7%
Simplified18.7%
Taylor expanded in x around 0 18.7%
neg-mul-118.7%
distribute-neg-frac18.7%
Simplified18.7%
if -1.06e308 < lo Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac18.3%
div-sub18.3%
Simplified18.3%
flip-+18.3%
pow218.3%
*-commutative18.3%
clear-num18.3%
frac-times63.3%
*-un-lft-identity63.3%
pow263.3%
associate-*r/63.2%
sub-div50.9%
Applied egg-rr50.9%
unpow250.9%
clear-num51.0%
clear-num50.9%
frac-times51.1%
metadata-eval51.1%
Applied egg-rr51.1%
Final simplification20.8%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x lo) hi)))
(if (<= lo -1.06e+308)
(/ (- lo) hi)
(/ (- (pow t_0 2.0)) (/ (+ (* lo t_0) (- lo x)) hi)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (lo <= -1.06e+308) {
tmp = -lo / hi;
} else {
tmp = -pow(t_0, 2.0) / (((lo * t_0) + (lo - x)) / hi);
}
return tmp;
}
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) :: tmp
t_0 = (x - lo) / hi
if (lo <= (-1.06d+308)) then
tmp = -lo / hi
else
tmp = -(t_0 ** 2.0d0) / (((lo * t_0) + (lo - x)) / hi)
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (lo <= -1.06e+308) {
tmp = -lo / hi;
} else {
tmp = -Math.pow(t_0, 2.0) / (((lo * t_0) + (lo - x)) / hi);
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - lo) / hi tmp = 0 if lo <= -1.06e+308: tmp = -lo / hi else: tmp = -math.pow(t_0, 2.0) / (((lo * t_0) + (lo - x)) / hi) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) tmp = 0.0 if (lo <= -1.06e+308) tmp = Float64(Float64(-lo) / hi); else tmp = Float64(Float64(-(t_0 ^ 2.0)) / Float64(Float64(Float64(lo * t_0) + Float64(lo - x)) / hi)); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = 0.0; if (lo <= -1.06e+308) tmp = -lo / hi; else tmp = -(t_0 ^ 2.0) / (((lo * t_0) + (lo - x)) / hi); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, If[LessEqual[lo, -1.06e+308], N[((-lo) / hi), $MachinePrecision], N[((-N[Power[t$95$0, 2.0], $MachinePrecision]) / N[(N[(N[(lo * t$95$0), $MachinePrecision] + N[(lo - x), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\mathbf{if}\;lo \leq -1.06 \cdot 10^{+308}:\\
\;\;\;\;\frac{-lo}{hi}\\
\mathbf{else}:\\
\;\;\;\;\frac{-{t_0}^{2}}{\frac{lo \cdot t_0 + \left(lo - x\right)}{hi}}\\
\end{array}
\end{array}
if lo < -1.06e308Initial program 3.1%
Taylor expanded in lo around 0 18.7%
mul-1-neg18.7%
unsub-neg18.7%
mul-1-neg18.7%
unsub-neg18.7%
unpow218.7%
Simplified18.7%
Taylor expanded in x around 0 18.7%
neg-mul-118.7%
distribute-neg-frac18.7%
Simplified18.7%
if -1.06e308 < lo Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac18.3%
div-sub18.3%
Simplified18.3%
flip-+18.3%
pow218.3%
*-commutative18.3%
clear-num18.3%
frac-times63.3%
*-un-lft-identity63.3%
pow263.3%
associate-*r/63.2%
sub-div50.9%
Applied egg-rr50.9%
Taylor expanded in hi around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
*-rgt-identity0.0%
times-frac50.9%
*-rgt-identity50.9%
unpow250.9%
Simplified50.9%
Final simplification20.8%
(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 lo around 0 18.8%
mul-1-neg18.8%
unsub-neg18.8%
mul-1-neg18.8%
unsub-neg18.8%
unpow218.8%
Simplified18.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 2023203
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))