
(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 8 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 (- -1.0 (/ hi lo))))
(*
(+ (pow (* t_0 (/ x lo)) 3.0) 1.0)
(/ 1.0 (+ (+ (pow (/ (- x hi) lo) 2.0) (* t_0 (/ (- hi x) lo))) 1.0)))))
double code(double lo, double hi, double x) {
double t_0 = -1.0 - (hi / lo);
return (pow((t_0 * (x / lo)), 3.0) + 1.0) * (1.0 / ((pow(((x - hi) / lo), 2.0) + (t_0 * ((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
real(8) :: t_0
t_0 = (-1.0d0) - (hi / lo)
code = (((t_0 * (x / lo)) ** 3.0d0) + 1.0d0) * (1.0d0 / (((((x - hi) / lo) ** 2.0d0) + (t_0 * ((hi - x) / lo))) + 1.0d0))
end function
public static double code(double lo, double hi, double x) {
double t_0 = -1.0 - (hi / lo);
return (Math.pow((t_0 * (x / lo)), 3.0) + 1.0) * (1.0 / ((Math.pow(((x - hi) / lo), 2.0) + (t_0 * ((hi - x) / lo))) + 1.0));
}
def code(lo, hi, x): t_0 = -1.0 - (hi / lo) return (math.pow((t_0 * (x / lo)), 3.0) + 1.0) * (1.0 / ((math.pow(((x - hi) / lo), 2.0) + (t_0 * ((hi - x) / lo))) + 1.0))
function code(lo, hi, x) t_0 = Float64(-1.0 - Float64(hi / lo)) return Float64(Float64((Float64(t_0 * Float64(x / lo)) ^ 3.0) + 1.0) * Float64(1.0 / Float64(Float64((Float64(Float64(x - hi) / lo) ^ 2.0) + Float64(t_0 * Float64(Float64(hi - x) / lo))) + 1.0))) end
function tmp = code(lo, hi, x) t_0 = -1.0 - (hi / lo); tmp = (((t_0 * (x / lo)) ^ 3.0) + 1.0) * (1.0 / (((((x - hi) / lo) ^ 2.0) + (t_0 * ((hi - x) / lo))) + 1.0)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[Power[N[(t$95$0 * N[(x / lo), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] + 1.0), $MachinePrecision] * N[(1.0 / N[(N[(N[Power[N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] + N[(t$95$0 * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -1 - \frac{hi}{lo}\\
\left({\left(t\_0 \cdot \frac{x}{lo}\right)}^{3} + 1\right) \cdot \frac{1}{\left({\left(\frac{x - hi}{lo}\right)}^{2} + t\_0 \cdot \frac{hi - x}{lo}\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%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.8%
flip3-+18.8%
div-inv18.8%
metadata-eval18.8%
*-commutative18.8%
metadata-eval18.8%
Applied egg-rr18.8%
Taylor expanded in lo around inf 0.0%
unpow20.0%
unpow20.0%
times-frac32.2%
unpow232.2%
Simplified32.2%
Taylor expanded in x around inf 99.4%
Final simplification99.4%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (/ (- hi x) lo)) (t_1 (* (+ (/ hi lo) 1.0) t_0))) (* (+ (pow t_1 3.0) 1.0) (/ 1.0 (+ (- (* 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) + 1.0) * t_0;
return (pow(t_1, 3.0) + 1.0) * (1.0 / (((t_0 * t_0) - t_1) + 1.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 = (hi - x) / lo
t_1 = ((hi / lo) + 1.0d0) * t_0
code = ((t_1 ** 3.0d0) + 1.0d0) * (1.0d0 / (((t_0 * t_0) - t_1) + 1.0d0))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
double t_1 = ((hi / lo) + 1.0) * t_0;
return (Math.pow(t_1, 3.0) + 1.0) * (1.0 / (((t_0 * t_0) - t_1) + 1.0));
}
def code(lo, hi, x): t_0 = (hi - x) / lo t_1 = ((hi / lo) + 1.0) * t_0 return (math.pow(t_1, 3.0) + 1.0) * (1.0 / (((t_0 * t_0) - t_1) + 1.0))
function code(lo, hi, x) t_0 = Float64(Float64(hi - x) / lo) t_1 = Float64(Float64(Float64(hi / lo) + 1.0) * t_0) return Float64(Float64((t_1 ^ 3.0) + 1.0) * Float64(1.0 / Float64(Float64(Float64(t_0 * t_0) - t_1) + 1.0))) end
function tmp = code(lo, hi, x) t_0 = (hi - x) / lo; t_1 = ((hi / lo) + 1.0) * t_0; tmp = ((t_1 ^ 3.0) + 1.0) * (1.0 / (((t_0 * 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[(N[(N[(hi / lo), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$0), $MachinePrecision]}, N[(N[(N[Power[t$95$1, 3.0], $MachinePrecision] + 1.0), $MachinePrecision] * N[(1.0 / N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] - t$95$1), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi - x}{lo}\\
t_1 := \left(\frac{hi}{lo} + 1\right) \cdot t\_0\\
\left({t\_1}^{3} + 1\right) \cdot \frac{1}{\left(t\_0 \cdot t\_0 - t\_1\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%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.8%
flip3-+18.8%
div-inv18.8%
metadata-eval18.8%
*-commutative18.8%
metadata-eval18.8%
Applied egg-rr18.8%
Taylor expanded in lo around inf 0.0%
unpow20.0%
unpow20.0%
times-frac32.2%
unpow232.2%
Simplified32.2%
unpow232.2%
Applied egg-rr32.2%
Final simplification32.2%
(FPCore (lo hi x) :precision binary64 (* (+ (pow (* (+ (/ hi lo) 1.0) (/ (- hi x) lo)) 3.0) 1.0) (/ 1.0 (+ (/ (- x hi) lo) 1.0))))
double code(double lo, double hi, double x) {
return (pow((((hi / lo) + 1.0) * ((hi - x) / lo)), 3.0) + 1.0) * (1.0 / (((x - 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 / lo) + 1.0d0) * ((hi - x) / lo)) ** 3.0d0) + 1.0d0) * (1.0d0 / (((x - hi) / lo) + 1.0d0))
end function
public static double code(double lo, double hi, double x) {
return (Math.pow((((hi / lo) + 1.0) * ((hi - x) / lo)), 3.0) + 1.0) * (1.0 / (((x - hi) / lo) + 1.0));
}
def code(lo, hi, x): return (math.pow((((hi / lo) + 1.0) * ((hi - x) / lo)), 3.0) + 1.0) * (1.0 / (((x - hi) / lo) + 1.0))
function code(lo, hi, x) return Float64(Float64((Float64(Float64(Float64(hi / lo) + 1.0) * Float64(Float64(hi - x) / lo)) ^ 3.0) + 1.0) * Float64(1.0 / Float64(Float64(Float64(x - hi) / lo) + 1.0))) end
function tmp = code(lo, hi, x) tmp = (((((hi / lo) + 1.0) * ((hi - x) / lo)) ^ 3.0) + 1.0) * (1.0 / (((x - hi) / lo) + 1.0)); end
code[lo_, hi_, x_] := N[(N[(N[Power[N[(N[(N[(hi / lo), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] + 1.0), $MachinePrecision] * N[(1.0 / N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left({\left(\left(\frac{hi}{lo} + 1\right) \cdot \frac{hi - x}{lo}\right)}^{3} + 1\right) \cdot \frac{1}{\frac{x - hi}{lo} + 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%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.8%
flip3-+18.8%
div-inv18.8%
metadata-eval18.8%
*-commutative18.8%
metadata-eval18.8%
Applied egg-rr18.8%
Taylor expanded in lo around inf 32.1%
Final simplification32.1%
(FPCore (lo hi x) :precision binary64 (+ (- (* hi (/ (+ (/ hi lo) 1.0) lo)) (/ x lo)) 1.0))
double code(double lo, double hi, double x) {
return ((hi * (((hi / lo) + 1.0) / lo)) - (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 * (((hi / lo) + 1.0d0) / lo)) - (x / lo)) + 1.0d0
end function
public static double code(double lo, double hi, double x) {
return ((hi * (((hi / lo) + 1.0) / lo)) - (x / lo)) + 1.0;
}
def code(lo, hi, x): return ((hi * (((hi / lo) + 1.0) / lo)) - (x / lo)) + 1.0
function code(lo, hi, x) return Float64(Float64(Float64(hi * Float64(Float64(Float64(hi / lo) + 1.0) / lo)) - Float64(x / lo)) + 1.0) end
function tmp = code(lo, hi, x) tmp = ((hi * (((hi / lo) + 1.0) / lo)) - (x / lo)) + 1.0; end
code[lo_, hi_, x_] := N[(N[(N[(hi * N[(N[(N[(hi / lo), $MachinePrecision] + 1.0), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - N[(x / lo), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\left(hi \cdot \frac{\frac{hi}{lo} + 1}{lo} - \frac{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%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.8%
Taylor expanded in x around 0 18.8%
+-commutative18.8%
mul-1-neg18.8%
unsub-neg18.8%
associate-/l*18.8%
+-commutative18.8%
Simplified18.8%
Taylor expanded in lo around inf 18.8%
Final simplification18.8%
(FPCore (lo hi x) :precision binary64 (+ (* hi (/ (+ (/ hi lo) 1.0) lo)) 1.0))
double code(double lo, double hi, double x) {
return (hi * (((hi / lo) + 1.0) / 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 * (((hi / lo) + 1.0d0) / lo)) + 1.0d0
end function
public static double code(double lo, double hi, double x) {
return (hi * (((hi / lo) + 1.0) / lo)) + 1.0;
}
def code(lo, hi, x): return (hi * (((hi / lo) + 1.0) / lo)) + 1.0
function code(lo, hi, x) return Float64(Float64(hi * Float64(Float64(Float64(hi / lo) + 1.0) / lo)) + 1.0) end
function tmp = code(lo, hi, x) tmp = (hi * (((hi / lo) + 1.0) / lo)) + 1.0; end
code[lo_, hi_, x_] := N[(N[(hi * N[(N[(N[(hi / lo), $MachinePrecision] + 1.0), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
hi \cdot \frac{\frac{hi}{lo} + 1}{lo} + 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%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.8%
Taylor expanded in x around 0 18.8%
associate-/l*18.8%
+-commutative18.8%
Simplified18.8%
Final simplification18.8%
(FPCore (lo hi x) :precision binary64 (- 1.0 (/ x lo)))
double code(double lo, double hi, double x) {
return 1.0 - (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 - (x / lo)
end function
public static double code(double lo, double hi, double x) {
return 1.0 - (x / lo);
}
def code(lo, hi, x): return 1.0 - (x / lo)
function code(lo, hi, x) return Float64(1.0 - Float64(x / lo)) end
function tmp = code(lo, hi, x) tmp = 1.0 - (x / lo); end
code[lo_, hi_, x_] := N[(1.0 - N[(x / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \frac{x}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in hi around 0 18.7%
div-sub18.7%
sub-neg18.7%
*-inverses18.7%
metadata-eval18.7%
distribute-lft-in18.7%
metadata-eval18.7%
+-commutative18.7%
mul-1-neg18.7%
unsub-neg18.7%
Simplified18.7%
Final simplification18.7%
(FPCore (lo hi x) :precision binary64 (/ (- x lo) hi))
double code(double lo, double hi, double x) {
return (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 = (x - lo) / hi
end function
public static double code(double lo, double hi, double x) {
return (x - lo) / hi;
}
def code(lo, hi, x): return (x - lo) / hi
function code(lo, hi, x) return Float64(Float64(x - lo) / hi) end
function tmp = code(lo, hi, x) tmp = (x - lo) / hi; end
code[lo_, hi_, x_] := N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - lo}{hi}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.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 2024047
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))