
(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 4 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
Applied rewrites99.9%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* z (* y z)))) (if (<= t_0 -0.01) t_0 (if (<= t_0 5e-30) (* x 1.0) t_0))))
double code(double x, double y, double z) {
double t_0 = z * (y * z);
double tmp;
if (t_0 <= -0.01) {
tmp = t_0;
} else if (t_0 <= 5e-30) {
tmp = x * 1.0;
} 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 = z * (y * z)
if (t_0 <= (-0.01d0)) then
tmp = t_0
else if (t_0 <= 5d-30) then
tmp = x * 1.0d0
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = z * (y * z);
double tmp;
if (t_0 <= -0.01) {
tmp = t_0;
} else if (t_0 <= 5e-30) {
tmp = x * 1.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = z * (y * z) tmp = 0 if t_0 <= -0.01: tmp = t_0 elif t_0 <= 5e-30: tmp = x * 1.0 else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(z * Float64(y * z)) tmp = 0.0 if (t_0 <= -0.01) tmp = t_0; elseif (t_0 <= 5e-30) tmp = Float64(x * 1.0); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = z * (y * z); tmp = 0.0; if (t_0 <= -0.01) tmp = t_0; elseif (t_0 <= 5e-30) tmp = x * 1.0; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -0.01], t$95$0, If[LessEqual[t$95$0, 5e-30], N[(x * 1.0), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \left(y \cdot z\right)\\
\mathbf{if}\;t\_0 \leq -0.01:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{-30}:\\
\;\;\;\;x \cdot 1\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (*.f64 (*.f64 y z) z) < -0.0100000000000000002 or 4.99999999999999972e-30 < (*.f64 (*.f64 y z) z) Initial program 99.8%
Taylor expanded in x around 0
lower-*.f64N/A
unpow2N/A
lower-*.f6480.0
Applied rewrites80.0%
Applied rewrites89.9%
if -0.0100000000000000002 < (*.f64 (*.f64 y z) z) < 4.99999999999999972e-30Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
unpow1N/A
sqr-powN/A
lower-fma.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval71.3
Applied rewrites71.3%
Taylor expanded in x around inf
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6484.5
Applied rewrites84.5%
Applied rewrites92.0%
Taylor expanded in z around 0
Applied rewrites88.2%
Final simplification89.1%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* z (* y z))) (t_1 (* y (* z z)))) (if (<= t_0 -0.01) t_1 (if (<= t_0 5e-30) (* x 1.0) t_1))))
double code(double x, double y, double z) {
double t_0 = z * (y * z);
double t_1 = y * (z * z);
double tmp;
if (t_0 <= -0.01) {
tmp = t_1;
} else if (t_0 <= 5e-30) {
tmp = x * 1.0;
} else {
tmp = t_1;
}
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) :: t_1
real(8) :: tmp
t_0 = z * (y * z)
t_1 = y * (z * z)
if (t_0 <= (-0.01d0)) then
tmp = t_1
else if (t_0 <= 5d-30) then
tmp = x * 1.0d0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = z * (y * z);
double t_1 = y * (z * z);
double tmp;
if (t_0 <= -0.01) {
tmp = t_1;
} else if (t_0 <= 5e-30) {
tmp = x * 1.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z): t_0 = z * (y * z) t_1 = y * (z * z) tmp = 0 if t_0 <= -0.01: tmp = t_1 elif t_0 <= 5e-30: tmp = x * 1.0 else: tmp = t_1 return tmp
function code(x, y, z) t_0 = Float64(z * Float64(y * z)) t_1 = Float64(y * Float64(z * z)) tmp = 0.0 if (t_0 <= -0.01) tmp = t_1; elseif (t_0 <= 5e-30) tmp = Float64(x * 1.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z) t_0 = z * (y * z); t_1 = y * (z * z); tmp = 0.0; if (t_0 <= -0.01) tmp = t_1; elseif (t_0 <= 5e-30) tmp = x * 1.0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(y * N[(z * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -0.01], t$95$1, If[LessEqual[t$95$0, 5e-30], N[(x * 1.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \left(y \cdot z\right)\\
t_1 := y \cdot \left(z \cdot z\right)\\
\mathbf{if}\;t\_0 \leq -0.01:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{-30}:\\
\;\;\;\;x \cdot 1\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 y z) z) < -0.0100000000000000002 or 4.99999999999999972e-30 < (*.f64 (*.f64 y z) z) Initial program 99.8%
Taylor expanded in x around 0
lower-*.f64N/A
unpow2N/A
lower-*.f6480.0
Applied rewrites80.0%
if -0.0100000000000000002 < (*.f64 (*.f64 y z) z) < 4.99999999999999972e-30Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
unpow1N/A
sqr-powN/A
lower-fma.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval71.3
Applied rewrites71.3%
Taylor expanded in x around inf
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6484.5
Applied rewrites84.5%
Applied rewrites92.0%
Taylor expanded in z around 0
Applied rewrites88.2%
Final simplification84.0%
(FPCore (x y z) :precision binary64 (* x 1.0))
double code(double x, double y, double z) {
return x * 1.0;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x * 1.0d0
end function
public static double code(double x, double y, double z) {
return x * 1.0;
}
def code(x, y, z): return x * 1.0
function code(x, y, z) return Float64(x * 1.0) end
function tmp = code(x, y, z) tmp = x * 1.0; end
code[x_, y_, z_] := N[(x * 1.0), $MachinePrecision]
\begin{array}{l}
\\
x \cdot 1
\end{array}
Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
unpow1N/A
sqr-powN/A
lower-fma.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval59.7
Applied rewrites59.7%
Taylor expanded in x around inf
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6480.0
Applied rewrites80.0%
Applied rewrites84.7%
Taylor expanded in z around 0
Applied rewrites48.4%
Final simplification48.4%
herbie shell --seed 2024220
(FPCore (x y z)
:name "Statistics.Sample:robustSumVarWeighted from math-functions-0.1.5.2"
:precision binary64
(+ x (* (* y z) z)))