
(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 (- (/ x hi) (/ (pow (/ lo hi) 2.0) (* (/ lo hi) (+ 1.0 (+ (exp (log1p (/ (- x lo) hi))) -1.0))))))
double code(double lo, double hi, double x) {
return (x / hi) - (pow((lo / hi), 2.0) / ((lo / hi) * (1.0 + (exp(log1p(((x - lo) / hi))) + -1.0))));
}
public static double code(double lo, double hi, double x) {
return (x / hi) - (Math.pow((lo / hi), 2.0) / ((lo / hi) * (1.0 + (Math.exp(Math.log1p(((x - lo) / hi))) + -1.0))));
}
def code(lo, hi, x): return (x / hi) - (math.pow((lo / hi), 2.0) / ((lo / hi) * (1.0 + (math.exp(math.log1p(((x - lo) / hi))) + -1.0))))
function code(lo, hi, x) return Float64(Float64(x / hi) - Float64((Float64(lo / hi) ^ 2.0) / Float64(Float64(lo / hi) * Float64(1.0 + Float64(exp(log1p(Float64(Float64(x - lo) / hi))) + -1.0))))) end
code[lo_, hi_, x_] := N[(N[(x / hi), $MachinePrecision] - N[(N[Power[N[(lo / hi), $MachinePrecision], 2.0], $MachinePrecision] / N[(N[(lo / hi), $MachinePrecision] * N[(1.0 + N[(N[Exp[N[Log[1 + N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{hi} - \frac{{\left(\frac{lo}{hi}\right)}^{2}}{\frac{lo}{hi} \cdot \left(1 + \left(e^{\mathsf{log1p}\left(\frac{x - lo}{hi}\right)} + -1\right)\right)}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 0.0%
associate--l+0.0%
associate-/l*18.8%
unpow218.8%
Simplified18.8%
flip--18.8%
pow218.8%
associate-/r/18.8%
pow218.8%
associate-/r/18.8%
fma-def18.8%
Applied egg-rr18.8%
associate-*l/0.0%
associate-/l*18.8%
associate-*l/10.0%
associate-/r/10.0%
*-rgt-identity10.0%
associate-*r/10.0%
associate-/r/10.6%
associate-*l/10.6%
*-lft-identity10.6%
associate-/r*18.8%
fma-udef18.8%
associate-*l/0.0%
times-frac99.2%
*-rgt-identity99.2%
distribute-lft-out99.0%
Simplified99.0%
expm1-log1p-u98.9%
expm1-udef99.0%
Applied egg-rr99.0%
Taylor expanded in hi around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
times-frac99.0%
unpow299.0%
Simplified99.0%
Final simplification99.0%
(FPCore (lo hi x) :precision binary64 (- (/ x hi) (/ (pow (/ lo hi) 2.0) (* (/ lo hi) (+ (/ (- x lo) hi) 1.0)))))
double code(double lo, double hi, double x) {
return (x / hi) - (pow((lo / hi), 2.0) / ((lo / hi) * (((x - lo) / hi) + 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 = (x / hi) - (((lo / hi) ** 2.0d0) / ((lo / hi) * (((x - lo) / hi) + 1.0d0)))
end function
public static double code(double lo, double hi, double x) {
return (x / hi) - (Math.pow((lo / hi), 2.0) / ((lo / hi) * (((x - lo) / hi) + 1.0)));
}
def code(lo, hi, x): return (x / hi) - (math.pow((lo / hi), 2.0) / ((lo / hi) * (((x - lo) / hi) + 1.0)))
function code(lo, hi, x) return Float64(Float64(x / hi) - Float64((Float64(lo / hi) ^ 2.0) / Float64(Float64(lo / hi) * Float64(Float64(Float64(x - lo) / hi) + 1.0)))) end
function tmp = code(lo, hi, x) tmp = (x / hi) - (((lo / hi) ^ 2.0) / ((lo / hi) * (((x - lo) / hi) + 1.0))); end
code[lo_, hi_, x_] := N[(N[(x / hi), $MachinePrecision] - N[(N[Power[N[(lo / hi), $MachinePrecision], 2.0], $MachinePrecision] / N[(N[(lo / hi), $MachinePrecision] * N[(N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{hi} - \frac{{\left(\frac{lo}{hi}\right)}^{2}}{\frac{lo}{hi} \cdot \left(\frac{x - lo}{hi} + 1\right)}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 0.0%
associate--l+0.0%
associate-/l*18.8%
unpow218.8%
Simplified18.8%
flip--18.8%
pow218.8%
associate-/r/18.8%
pow218.8%
associate-/r/18.8%
fma-def18.8%
Applied egg-rr18.8%
associate-*l/0.0%
associate-/l*18.8%
associate-*l/10.0%
associate-/r/10.0%
*-rgt-identity10.0%
associate-*r/10.0%
associate-/r/10.6%
associate-*l/10.6%
*-lft-identity10.6%
associate-/r*18.8%
fma-udef18.8%
associate-*l/0.0%
times-frac99.2%
*-rgt-identity99.2%
distribute-lft-out99.0%
Simplified99.0%
Taylor expanded in hi around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
times-frac99.0%
unpow299.0%
Simplified99.0%
Final simplification99.0%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (fma (/ hi lo) (* (- hi x) (/ 1.0 lo)) (/ hi lo))))
double code(double lo, double hi, double x) {
return 1.0 + fma((hi / lo), ((hi - x) * (1.0 / lo)), (hi / lo));
}
function code(lo, hi, x) return Float64(1.0 + fma(Float64(hi / lo), Float64(Float64(hi - x) * Float64(1.0 / lo)), Float64(hi / lo))) end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(hi / lo), $MachinePrecision] * N[(N[(hi - x), $MachinePrecision] * N[(1.0 / lo), $MachinePrecision]), $MachinePrecision] + N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \mathsf{fma}\left(\frac{hi}{lo}, \left(hi - x\right) \cdot \frac{1}{lo}, \frac{hi}{lo}\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%
div-inv18.9%
Applied egg-rr18.9%
Taylor expanded in hi around inf 18.9%
Final simplification18.9%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (* (/ (- hi x) lo) (+ 1.0 (/ hi lo)))))
double code(double lo, double hi, double x) {
return 1.0 + (((hi - x) / lo) * (1.0 + (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 = 1.0d0 + (((hi - x) / lo) * (1.0d0 + (hi / lo)))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + (((hi - x) / lo) * (1.0 + (hi / lo)));
}
def code(lo, hi, x): return 1.0 + (((hi - x) / lo) * (1.0 + (hi / lo)))
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(Float64(hi - x) / lo) * Float64(1.0 + Float64(hi / lo)))) end
function tmp = code(lo, hi, x) tmp = 1.0 + (((hi - x) / lo) * (1.0 + (hi / lo))); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision] * N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{hi - x}{lo} \cdot \left(1 + \frac{hi}{lo}\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%
unpow20.0%
times-frac18.9%
associate-+r-18.9%
div-sub18.9%
*-lft-identity18.9%
distribute-rgt-out18.9%
+-commutative18.9%
Simplified18.9%
Final simplification18.9%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (* (/ hi lo) (+ 1.0 (/ hi lo)))))
double code(double lo, double hi, double x) {
return 1.0 + ((hi / lo) * (1.0 + (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 = 1.0d0 + ((hi / lo) * (1.0d0 + (hi / lo)))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + ((hi / lo) * (1.0 + (hi / lo)));
}
def code(lo, hi, x): return 1.0 + ((hi / lo) * (1.0 + (hi / lo)))
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(hi / lo) * Float64(1.0 + Float64(hi / lo)))) end
function tmp = code(lo, hi, x) tmp = 1.0 + ((hi / lo) * (1.0 + (hi / lo))); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(hi / lo), $MachinePrecision] * N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{hi}{lo} \cdot \left(1 + \frac{hi}{lo}\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%
clear-num18.9%
inv-pow18.9%
Applied egg-rr18.9%
unpow-118.9%
Simplified18.9%
Taylor expanded in x around 0 0.0%
*-rgt-identity0.0%
unpow20.0%
unpow20.0%
times-frac18.9%
distribute-lft-in18.9%
Simplified18.9%
Final simplification18.9%
(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 2023279
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))