
(FPCore (x y z) :precision binary64 (+ x (* (* y z) z)))
double code(double x, double y, double z) {
return x + ((y * z) * z);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x + ((y * z) * z)
end function
public static double code(double x, double y, double z) {
return x + ((y * z) * z);
}
def code(x, y, z): return x + ((y * z) * z)
function code(x, y, z) return Float64(x + Float64(Float64(y * z) * z)) end
function tmp = code(x, y, z) tmp = x + ((y * z) * z); end
code[x_, y_, z_] := N[(x + N[(N[(y * z), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y \cdot z\right) \cdot z
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 3 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (+ x (* (* y z) z)))
double code(double x, double y, double z) {
return x + ((y * z) * z);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x + ((y * z) * z)
end function
public static double code(double x, double y, double z) {
return x + ((y * z) * z);
}
def code(x, y, z): return x + ((y * z) * z)
function code(x, y, z) return Float64(x + Float64(Float64(y * z) * z)) end
function tmp = code(x, y, z) tmp = x + ((y * z) * z); end
code[x_, y_, z_] := N[(x + N[(N[(y * z), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y \cdot z\right) \cdot z
\end{array}
(FPCore (x y z) :precision binary64 (fma (* y z) z x))
double code(double x, double y, double z) {
return fma((y * z), z, x);
}
function code(x, y, z) return fma(Float64(y * z), z, x) end
code[x_, y_, z_] := N[(N[(y * z), $MachinePrecision] * z + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y \cdot z, z, x\right)
\end{array}
Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.9
Applied rewrites99.9%
Final simplification99.9%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* (* y z) z))) (if (<= t_0 -1e-24) t_0 (if (<= t_0 20000000000.0) (* 1.0 x) t_0))))
double code(double x, double y, double z) {
double t_0 = (y * z) * z;
double tmp;
if (t_0 <= -1e-24) {
tmp = t_0;
} else if (t_0 <= 20000000000.0) {
tmp = 1.0 * x;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = (y * z) * z
if (t_0 <= (-1d-24)) then
tmp = t_0
else if (t_0 <= 20000000000.0d0) then
tmp = 1.0d0 * x
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = (y * z) * z;
double tmp;
if (t_0 <= -1e-24) {
tmp = t_0;
} else if (t_0 <= 20000000000.0) {
tmp = 1.0 * x;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = (y * z) * z tmp = 0 if t_0 <= -1e-24: tmp = t_0 elif t_0 <= 20000000000.0: tmp = 1.0 * x else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(Float64(y * z) * z) tmp = 0.0 if (t_0 <= -1e-24) tmp = t_0; elseif (t_0 <= 20000000000.0) tmp = Float64(1.0 * x); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = (y * z) * z; tmp = 0.0; if (t_0 <= -1e-24) tmp = t_0; elseif (t_0 <= 20000000000.0) tmp = 1.0 * x; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(y * z), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[t$95$0, -1e-24], t$95$0, If[LessEqual[t$95$0, 20000000000.0], N[(1.0 * x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(y \cdot z\right) \cdot z\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{-24}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_0 \leq 20000000000:\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (*.f64 (*.f64 y z) z) < -9.99999999999999924e-25 or 2e10 < (*.f64 (*.f64 y z) z) Initial program 99.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6484.2
Applied rewrites84.2%
Applied rewrites92.6%
if -9.99999999999999924e-25 < (*.f64 (*.f64 y z) z) < 2e10Initial program 100.0%
lift-+.f64N/A
flip-+N/A
frac-2negN/A
div-invN/A
lower-*.f64N/A
sub-negN/A
distribute-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
lower-*.f64N/A
pow2N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites55.7%
lift-fma.f64N/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6455.7
Applied rewrites55.7%
Applied rewrites89.6%
Taylor expanded in z around 0
Applied rewrites91.0%
(FPCore (x y z) :precision binary64 (* 1.0 x))
double code(double x, double y, double z) {
return 1.0 * x;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 1.0d0 * x
end function
public static double code(double x, double y, double z) {
return 1.0 * x;
}
def code(x, y, z): return 1.0 * x
function code(x, y, z) return Float64(1.0 * x) end
function tmp = code(x, y, z) tmp = 1.0 * x; end
code[x_, y_, z_] := N[(1.0 * x), $MachinePrecision]
\begin{array}{l}
\\
1 \cdot x
\end{array}
Initial program 99.9%
lift-+.f64N/A
flip-+N/A
frac-2negN/A
div-invN/A
lower-*.f64N/A
sub-negN/A
distribute-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
lower-*.f64N/A
pow2N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites44.3%
lift-fma.f64N/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6442.5
Applied rewrites42.5%
Applied rewrites78.4%
Taylor expanded in z around 0
Applied rewrites52.8%
herbie shell --seed 2024270
(FPCore (x y z)
:name "Statistics.Sample:robustSumVarWeighted from math-functions-0.1.5.2"
:precision binary64
(+ x (* (* y z) z)))