
(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 5 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 (+ x (* z (* y z))))
double code(double x, double y, double z) {
return x + (z * (y * 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 + (z * (y * z))
end function
public static double code(double x, double y, double z) {
return x + (z * (y * z));
}
def code(x, y, z): return x + (z * (y * z))
function code(x, y, z) return Float64(x + Float64(z * Float64(y * z))) end
function tmp = code(x, y, z) tmp = x + (z * (y * z)); end
code[x_, y_, z_] := N[(x + N[(z * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + z \cdot \left(y \cdot z\right)
\end{array}
Initial program 99.9%
Final simplification99.9%
(FPCore (x y z) :precision binary64 (if (<= z 2.7e+153) (+ x (* y (* z z))) (* z (* y z))))
double code(double x, double y, double z) {
double tmp;
if (z <= 2.7e+153) {
tmp = x + (y * (z * z));
} else {
tmp = z * (y * z);
}
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) :: tmp
if (z <= 2.7d+153) then
tmp = x + (y * (z * z))
else
tmp = z * (y * z)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= 2.7e+153) {
tmp = x + (y * (z * z));
} else {
tmp = z * (y * z);
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= 2.7e+153: tmp = x + (y * (z * z)) else: tmp = z * (y * z) return tmp
function code(x, y, z) tmp = 0.0 if (z <= 2.7e+153) tmp = Float64(x + Float64(y * Float64(z * z))); else tmp = Float64(z * Float64(y * z)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= 2.7e+153) tmp = x + (y * (z * z)); else tmp = z * (y * z); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, 2.7e+153], N[(x + N[(y * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(y * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 2.7 \cdot 10^{+153}:\\
\;\;\;\;x + y \cdot \left(z \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(y \cdot z\right)\\
\end{array}
\end{array}
if z < 2.7000000000000001e153Initial program 99.9%
associate-*l*95.7%
Simplified95.7%
if 2.7000000000000001e153 < z Initial program 99.9%
associate-*l*73.1%
Simplified73.1%
add-cbrt-cube73.1%
pow373.1%
add-sqr-sqrt46.5%
unpow-prod-down46.5%
pow-prod-up46.5%
*-commutative46.5%
sqrt-prod46.5%
sqrt-prod46.5%
add-sqr-sqrt46.5%
metadata-eval46.5%
Applied egg-rr46.5%
+-commutative46.5%
flip-+0.0%
pow20.0%
pow1/30.0%
pow-pow0.0%
metadata-eval0.0%
pow20.0%
swap-sqr0.0%
add-sqr-sqrt0.0%
associate-*r*0.0%
pow1/30.0%
pow-pow0.6%
metadata-eval0.6%
pow20.6%
swap-sqr0.0%
add-sqr-sqrt0.1%
associate-*r*5.9%
Applied egg-rr5.9%
unpow25.9%
associate-*r*1.7%
associate-*r*1.7%
Applied egg-rr1.7%
Taylor expanded in z around inf 73.1%
unpow273.1%
associate-*r*91.9%
*-commutative91.9%
associate-*r*91.9%
Simplified91.9%
Final simplification95.3%
(FPCore (x y z) :precision binary64 (if (<= z 4.2e+76) x (* y (* z z))))
double code(double x, double y, double z) {
double tmp;
if (z <= 4.2e+76) {
tmp = x;
} else {
tmp = y * (z * z);
}
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) :: tmp
if (z <= 4.2d+76) then
tmp = x
else
tmp = y * (z * z)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= 4.2e+76) {
tmp = x;
} else {
tmp = y * (z * z);
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= 4.2e+76: tmp = x else: tmp = y * (z * z) return tmp
function code(x, y, z) tmp = 0.0 if (z <= 4.2e+76) tmp = x; else tmp = Float64(y * Float64(z * z)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= 4.2e+76) tmp = x; else tmp = y * (z * z); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, 4.2e+76], x, N[(y * N[(z * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 4.2 \cdot 10^{+76}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(z \cdot z\right)\\
\end{array}
\end{array}
if z < 4.20000000000000013e76Initial program 99.9%
associate-*l*95.5%
Simplified95.5%
Taylor expanded in x around inf 61.5%
if 4.20000000000000013e76 < z Initial program 99.9%
associate-*l*82.0%
Simplified82.0%
add-cbrt-cube69.2%
pow369.2%
add-sqr-sqrt37.1%
unpow-prod-down37.1%
pow-prod-up37.1%
*-commutative37.1%
sqrt-prod37.1%
sqrt-prod37.1%
add-sqr-sqrt37.1%
metadata-eval37.1%
Applied egg-rr37.1%
pow1/337.1%
pow-pow49.9%
metadata-eval49.9%
pow249.9%
swap-sqr44.8%
add-sqr-sqrt82.0%
associate-*r*99.9%
*-commutative99.9%
add-cube-cbrt99.4%
unpow399.3%
flip-+15.5%
frac-2neg15.5%
Applied egg-rr15.8%
neg-sub015.8%
associate--r-15.8%
neg-sub015.8%
+-commutative15.8%
sub-neg15.8%
unpow215.8%
associate-*r*13.0%
associate-*r*13.0%
swap-sqr1.1%
associate-*r*1.1%
unpow31.1%
pow-plus1.1%
metadata-eval1.1%
neg-sub01.1%
associate--r-1.1%
neg-sub01.1%
+-commutative1.1%
sub-neg1.1%
*-commutative1.1%
Simplified1.1%
Taylor expanded in z around inf 71.1%
unpow271.1%
Simplified71.1%
Final simplification62.9%
(FPCore (x y z) :precision binary64 (if (<= z 2.4e+76) x (* z (* y z))))
double code(double x, double y, double z) {
double tmp;
if (z <= 2.4e+76) {
tmp = x;
} else {
tmp = z * (y * z);
}
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) :: tmp
if (z <= 2.4d+76) then
tmp = x
else
tmp = z * (y * z)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= 2.4e+76) {
tmp = x;
} else {
tmp = z * (y * z);
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= 2.4e+76: tmp = x else: tmp = z * (y * z) return tmp
function code(x, y, z) tmp = 0.0 if (z <= 2.4e+76) tmp = x; else tmp = Float64(z * Float64(y * z)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= 2.4e+76) tmp = x; else tmp = z * (y * z); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, 2.4e+76], x, N[(z * N[(y * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 2.4 \cdot 10^{+76}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(y \cdot z\right)\\
\end{array}
\end{array}
if z < 2.4e76Initial program 99.9%
associate-*l*95.5%
Simplified95.5%
Taylor expanded in x around inf 61.5%
if 2.4e76 < z Initial program 99.9%
associate-*l*82.0%
Simplified82.0%
add-cbrt-cube69.2%
pow369.2%
add-sqr-sqrt37.1%
unpow-prod-down37.1%
pow-prod-up37.1%
*-commutative37.1%
sqrt-prod37.1%
sqrt-prod37.1%
add-sqr-sqrt37.1%
metadata-eval37.1%
Applied egg-rr37.1%
+-commutative37.1%
flip-+0.3%
pow20.3%
pow1/30.3%
pow-pow0.3%
metadata-eval0.3%
pow20.3%
swap-sqr0.3%
add-sqr-sqrt0.3%
associate-*r*0.3%
pow1/30.3%
pow-pow1.1%
metadata-eval1.1%
pow21.1%
swap-sqr0.7%
add-sqr-sqrt12.0%
associate-*r*15.8%
Applied egg-rr15.8%
unpow215.8%
associate-*r*13.0%
associate-*r*10.3%
Applied egg-rr10.3%
Taylor expanded in z around inf 71.1%
unpow271.1%
associate-*r*83.6%
*-commutative83.6%
associate-*r*83.6%
Simplified83.6%
Final simplification64.6%
(FPCore (x y z) :precision binary64 x)
double code(double x, double y, double z) {
return x;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x
end function
public static double code(double x, double y, double z) {
return x;
}
def code(x, y, z): return x
function code(x, y, z) return x end
function tmp = code(x, y, z) tmp = x; end
code[x_, y_, z_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 99.9%
associate-*l*93.6%
Simplified93.6%
Taylor expanded in x around inf 55.3%
Final simplification55.3%
herbie shell --seed 2023293
(FPCore (x y z)
:name "Statistics.Sample:robustSumVarWeighted from math-functions-0.1.5.2"
:precision binary64
(+ x (* (* y z) z)))