
(FPCore (x y z) :precision binary64 (+ (+ (+ (* x y) (* z z)) (* z z)) (* z z)))
double code(double x, double y, double z) {
return (((x * y) + (z * z)) + (z * z)) + (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)) + (z * z)) + (z * z)
end function
public static double code(double x, double y, double z) {
return (((x * y) + (z * z)) + (z * z)) + (z * z);
}
def code(x, y, z): return (((x * y) + (z * z)) + (z * z)) + (z * z)
function code(x, y, z) return Float64(Float64(Float64(Float64(x * y) + Float64(z * z)) + Float64(z * z)) + Float64(z * z)) end
function tmp = code(x, y, z) tmp = (((x * y) + (z * z)) + (z * z)) + (z * z); end
code[x_, y_, z_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(z * z), $MachinePrecision]), $MachinePrecision] + N[(z * z), $MachinePrecision]), $MachinePrecision] + N[(z * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + z \cdot z\right) + z \cdot z\right) + z \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)) (* z z)) (* z z)))
double code(double x, double y, double z) {
return (((x * y) + (z * z)) + (z * z)) + (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)) + (z * z)) + (z * z)
end function
public static double code(double x, double y, double z) {
return (((x * y) + (z * z)) + (z * z)) + (z * z);
}
def code(x, y, z): return (((x * y) + (z * z)) + (z * z)) + (z * z)
function code(x, y, z) return Float64(Float64(Float64(Float64(x * y) + Float64(z * z)) + Float64(z * z)) + Float64(z * z)) end
function tmp = code(x, y, z) tmp = (((x * y) + (z * z)) + (z * z)) + (z * z); end
code[x_, y_, z_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(z * z), $MachinePrecision]), $MachinePrecision] + N[(z * z), $MachinePrecision]), $MachinePrecision] + N[(z * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + z \cdot z\right) + z \cdot z\right) + z \cdot z
\end{array}
(FPCore (x y z) :precision binary64 (fma z z (fma x y (* 2.0 (* z z)))))
double code(double x, double y, double z) {
return fma(z, z, fma(x, y, (2.0 * (z * z))));
}
function code(x, y, z) return fma(z, z, fma(x, y, Float64(2.0 * Float64(z * z)))) end
code[x_, y_, z_] := N[(z * z + N[(x * y + N[(2.0 * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(z, z, \mathsf{fma}\left(x, y, 2 \cdot \left(z \cdot z\right)\right)\right)
\end{array}
Initial program 99.5%
+-commutative99.5%
fma-def99.6%
associate-+l+99.6%
fma-def99.6%
count-299.6%
Simplified99.6%
Final simplification99.6%
(FPCore (x y z) :precision binary64 (fma x y (* z (* z 3.0))))
double code(double x, double y, double z) {
return fma(x, y, (z * (z * 3.0)));
}
function code(x, y, z) return fma(x, y, Float64(z * Float64(z * 3.0))) end
code[x_, y_, z_] := N[(x * y + N[(z * N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, y, z \cdot \left(z \cdot 3\right)\right)
\end{array}
Initial program 99.5%
associate-+l+99.5%
associate-+l+99.5%
fma-def99.5%
count-299.5%
distribute-lft1-in99.5%
metadata-eval99.5%
*-commutative99.5%
associate-*l*99.5%
metadata-eval99.5%
metadata-eval99.5%
Simplified99.5%
Final simplification99.5%
(FPCore (x y z) :precision binary64 (+ (* z (* z 3.0)) (* x y)))
double code(double x, double y, double z) {
return (z * (z * 3.0)) + (x * y);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (z * (z * 3.0d0)) + (x * y)
end function
public static double code(double x, double y, double z) {
return (z * (z * 3.0)) + (x * y);
}
def code(x, y, z): return (z * (z * 3.0)) + (x * y)
function code(x, y, z) return Float64(Float64(z * Float64(z * 3.0)) + Float64(x * y)) end
function tmp = code(x, y, z) tmp = (z * (z * 3.0)) + (x * y); end
code[x_, y_, z_] := N[(N[(z * N[(z * 3.0), $MachinePrecision]), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
z \cdot \left(z \cdot 3\right) + x \cdot y
\end{array}
Initial program 99.5%
associate-+l+99.5%
associate-+l+99.5%
fma-def99.5%
count-299.5%
distribute-lft1-in99.5%
metadata-eval99.5%
*-commutative99.5%
associate-*l*99.5%
metadata-eval99.5%
metadata-eval99.5%
Simplified99.5%
fma-udef99.5%
flip-+36.8%
pow236.8%
associate-*r*36.8%
associate-*r*36.7%
swap-sqr36.6%
pow236.6%
pow236.6%
pow-sqr36.7%
metadata-eval36.7%
metadata-eval36.7%
associate-*r*36.7%
pow236.7%
Applied egg-rr36.7%
unpow236.7%
add-sqr-sqrt36.7%
add-sqr-sqrt36.6%
sqrt-unprod36.1%
swap-sqr36.1%
pow-sqr36.1%
metadata-eval36.1%
metadata-eval36.1%
flip-+88.9%
+-commutative88.9%
metadata-eval88.9%
pow-sqr88.9%
metadata-eval88.9%
swap-sqr88.9%
sqrt-unprod99.4%
Applied egg-rr99.7%
fma-udef99.3%
unpow299.3%
Simplified99.3%
unpow254.0%
*-commutative54.0%
*-commutative54.0%
swap-sqr53.9%
rem-square-sqrt54.1%
associate-*r*54.1%
Applied egg-rr99.5%
Final simplification99.5%
(FPCore (x y z) :precision binary64 (if (<= z 510000000000.0) (* x y) (* z (* z 3.0))))
double code(double x, double y, double z) {
double tmp;
if (z <= 510000000000.0) {
tmp = x * y;
} else {
tmp = z * (z * 3.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) :: tmp
if (z <= 510000000000.0d0) then
tmp = x * y
else
tmp = z * (z * 3.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= 510000000000.0) {
tmp = x * y;
} else {
tmp = z * (z * 3.0);
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= 510000000000.0: tmp = x * y else: tmp = z * (z * 3.0) return tmp
function code(x, y, z) tmp = 0.0 if (z <= 510000000000.0) tmp = Float64(x * y); else tmp = Float64(z * Float64(z * 3.0)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= 510000000000.0) tmp = x * y; else tmp = z * (z * 3.0); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, 510000000000.0], N[(x * y), $MachinePrecision], N[(z * N[(z * 3.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 510000000000:\\
\;\;\;\;x \cdot y\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(z \cdot 3\right)\\
\end{array}
\end{array}
if z < 5.1e11Initial program 99.9%
Taylor expanded in x around inf 63.8%
if 5.1e11 < z Initial program 98.2%
associate-+l+98.2%
associate-+l+98.2%
fma-def98.2%
count-298.2%
distribute-lft1-in98.2%
metadata-eval98.2%
*-commutative98.2%
associate-*l*98.2%
metadata-eval98.2%
metadata-eval98.2%
Simplified98.2%
fma-udef98.2%
flip-+24.0%
pow224.0%
associate-*r*23.9%
associate-*r*23.9%
swap-sqr23.8%
pow223.8%
pow223.8%
pow-sqr24.0%
metadata-eval24.0%
metadata-eval24.0%
associate-*r*23.9%
pow223.9%
Applied egg-rr23.9%
unpow223.9%
add-sqr-sqrt23.9%
add-sqr-sqrt23.9%
sqrt-unprod22.9%
swap-sqr22.9%
pow-sqr23.0%
metadata-eval23.0%
metadata-eval23.0%
flip-+77.1%
+-commutative77.1%
metadata-eval77.1%
pow-sqr77.0%
metadata-eval77.0%
swap-sqr77.0%
sqrt-unprod98.1%
Applied egg-rr99.6%
fma-udef98.0%
unpow298.0%
Simplified98.0%
Taylor expanded in z around inf 85.3%
unpow285.3%
unpow285.3%
swap-sqr85.5%
unpow285.5%
Simplified85.5%
unpow285.5%
*-commutative85.5%
*-commutative85.5%
swap-sqr85.3%
rem-square-sqrt85.7%
associate-*r*85.7%
Applied egg-rr85.7%
Final simplification69.1%
(FPCore (x y z) :precision binary64 (* x y))
double code(double x, double y, double z) {
return x * y;
}
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
end function
public static double code(double x, double y, double z) {
return x * y;
}
def code(x, y, z): return x * y
function code(x, y, z) return Float64(x * y) end
function tmp = code(x, y, z) tmp = x * y; end
code[x_, y_, z_] := N[(x * y), $MachinePrecision]
\begin{array}{l}
\\
x \cdot y
\end{array}
Initial program 99.5%
Taylor expanded in x around inf 52.9%
Final simplification52.9%
(FPCore (x y z) :precision binary64 (+ (* (* 3.0 z) z) (* y x)))
double code(double x, double y, double z) {
return ((3.0 * z) * z) + (y * x);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((3.0d0 * z) * z) + (y * x)
end function
public static double code(double x, double y, double z) {
return ((3.0 * z) * z) + (y * x);
}
def code(x, y, z): return ((3.0 * z) * z) + (y * x)
function code(x, y, z) return Float64(Float64(Float64(3.0 * z) * z) + Float64(y * x)) end
function tmp = code(x, y, z) tmp = ((3.0 * z) * z) + (y * x); end
code[x_, y_, z_] := N[(N[(N[(3.0 * z), $MachinePrecision] * z), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(3 \cdot z\right) \cdot z + y \cdot x
\end{array}
herbie shell --seed 2023301
(FPCore (x y z)
:name "Linear.Quaternion:$c/ from linear-1.19.1.3, A"
:precision binary64
:herbie-target
(+ (* (* 3.0 z) z) (* y x))
(+ (+ (+ (* x y) (* z z)) (* z z)) (* z z)))