
(FPCore (x y z) :precision binary64 (* (/ 1.0 2.0) (+ x (* y (sqrt z)))))
double code(double x, double y, double z) {
return (1.0 / 2.0) * (x + (y * sqrt(z)));
}
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 / 2.0d0) * (x + (y * sqrt(z)))
end function
public static double code(double x, double y, double z) {
return (1.0 / 2.0) * (x + (y * Math.sqrt(z)));
}
def code(x, y, z): return (1.0 / 2.0) * (x + (y * math.sqrt(z)))
function code(x, y, z) return Float64(Float64(1.0 / 2.0) * Float64(x + Float64(y * sqrt(z)))) end
function tmp = code(x, y, z) tmp = (1.0 / 2.0) * (x + (y * sqrt(z))); end
code[x_, y_, z_] := N[(N[(1.0 / 2.0), $MachinePrecision] * N[(x + N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{2} \cdot \left(x + y \cdot \sqrt{z}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (* (/ 1.0 2.0) (+ x (* y (sqrt z)))))
double code(double x, double y, double z) {
return (1.0 / 2.0) * (x + (y * sqrt(z)));
}
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 / 2.0d0) * (x + (y * sqrt(z)))
end function
public static double code(double x, double y, double z) {
return (1.0 / 2.0) * (x + (y * Math.sqrt(z)));
}
def code(x, y, z): return (1.0 / 2.0) * (x + (y * math.sqrt(z)))
function code(x, y, z) return Float64(Float64(1.0 / 2.0) * Float64(x + Float64(y * sqrt(z)))) end
function tmp = code(x, y, z) tmp = (1.0 / 2.0) * (x + (y * sqrt(z))); end
code[x_, y_, z_] := N[(N[(1.0 / 2.0), $MachinePrecision] * N[(x + N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{2} \cdot \left(x + y \cdot \sqrt{z}\right)
\end{array}
(FPCore (x y z) :precision binary64 (* 0.5 (+ x (* y (sqrt z)))))
double code(double x, double y, double z) {
return 0.5 * (x + (y * sqrt(z)));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 0.5d0 * (x + (y * sqrt(z)))
end function
public static double code(double x, double y, double z) {
return 0.5 * (x + (y * Math.sqrt(z)));
}
def code(x, y, z): return 0.5 * (x + (y * math.sqrt(z)))
function code(x, y, z) return Float64(0.5 * Float64(x + Float64(y * sqrt(z)))) end
function tmp = code(x, y, z) tmp = 0.5 * (x + (y * sqrt(z))); end
code[x_, y_, z_] := N[(0.5 * N[(x + N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(x + y \cdot \sqrt{z}\right)
\end{array}
Initial program 99.8%
metadata-eval99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x y z)
:precision binary64
(if (<= x -2.5e-11)
(* 0.5 x)
(if (<= x 1.86e+55)
(* 0.5 (* y (sqrt z)))
(* 0.5 (- x (* y (/ y (/ x z))))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -2.5e-11) {
tmp = 0.5 * x;
} else if (x <= 1.86e+55) {
tmp = 0.5 * (y * sqrt(z));
} else {
tmp = 0.5 * (x - (y * (y / (x / 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 (x <= (-2.5d-11)) then
tmp = 0.5d0 * x
else if (x <= 1.86d+55) then
tmp = 0.5d0 * (y * sqrt(z))
else
tmp = 0.5d0 * (x - (y * (y / (x / z))))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -2.5e-11) {
tmp = 0.5 * x;
} else if (x <= 1.86e+55) {
tmp = 0.5 * (y * Math.sqrt(z));
} else {
tmp = 0.5 * (x - (y * (y / (x / z))));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -2.5e-11: tmp = 0.5 * x elif x <= 1.86e+55: tmp = 0.5 * (y * math.sqrt(z)) else: tmp = 0.5 * (x - (y * (y / (x / z)))) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -2.5e-11) tmp = Float64(0.5 * x); elseif (x <= 1.86e+55) tmp = Float64(0.5 * Float64(y * sqrt(z))); else tmp = Float64(0.5 * Float64(x - Float64(y * Float64(y / Float64(x / z))))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -2.5e-11) tmp = 0.5 * x; elseif (x <= 1.86e+55) tmp = 0.5 * (y * sqrt(z)); else tmp = 0.5 * (x - (y * (y / (x / z)))); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -2.5e-11], N[(0.5 * x), $MachinePrecision], If[LessEqual[x, 1.86e+55], N[(0.5 * N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(x - N[(y * N[(y / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.5 \cdot 10^{-11}:\\
\;\;\;\;0.5 \cdot x\\
\mathbf{elif}\;x \leq 1.86 \cdot 10^{+55}:\\
\;\;\;\;0.5 \cdot \left(y \cdot \sqrt{z}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(x - y \cdot \frac{y}{\frac{x}{z}}\right)\\
\end{array}
\end{array}
if x < -2.50000000000000009e-11Initial program 99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around inf 80.4%
if -2.50000000000000009e-11 < x < 1.86e55Initial program 99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around 0 82.7%
if 1.86e55 < x Initial program 99.9%
metadata-eval99.9%
Simplified99.9%
cancel-sign-sub99.9%
distribute-lft-neg-in99.9%
flip--30.6%
sqr-neg30.6%
swap-sqr30.3%
rem-square-sqrt30.3%
sub-neg30.3%
Applied egg-rr30.3%
div-sub30.3%
associate-/l*74.0%
associate-*r*77.8%
frac-2neg77.8%
sub-neg77.8%
+-commutative77.8%
distribute-rgt-neg-in77.8%
fma-def77.8%
distribute-lft-neg-in77.8%
neg-mul-177.8%
times-frac89.0%
metadata-eval89.0%
frac-2neg89.0%
/-rgt-identity89.0%
sub-neg89.0%
+-commutative89.0%
Applied egg-rr89.0%
Taylor expanded in y around 0 87.9%
Taylor expanded in y around 0 87.3%
associate-/l*89.3%
Simplified89.3%
Final simplification83.5%
(FPCore (x y z) :precision binary64 (* 0.5 (- x (* (/ y x) (* y z)))))
double code(double x, double y, double z) {
return 0.5 * (x - ((y / x) * (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 = 0.5d0 * (x - ((y / x) * (y * z)))
end function
public static double code(double x, double y, double z) {
return 0.5 * (x - ((y / x) * (y * z)));
}
def code(x, y, z): return 0.5 * (x - ((y / x) * (y * z)))
function code(x, y, z) return Float64(0.5 * Float64(x - Float64(Float64(y / x) * Float64(y * z)))) end
function tmp = code(x, y, z) tmp = 0.5 * (x - ((y / x) * (y * z))); end
code[x_, y_, z_] := N[(0.5 * N[(x - N[(N[(y / x), $MachinePrecision] * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(x - \frac{y}{x} \cdot \left(y \cdot z\right)\right)
\end{array}
Initial program 99.8%
metadata-eval99.8%
Simplified99.8%
cancel-sign-sub99.8%
distribute-lft-neg-in99.8%
flip--53.9%
sqr-neg53.9%
swap-sqr49.9%
rem-square-sqrt49.9%
sub-neg49.9%
Applied egg-rr49.9%
div-sub49.9%
associate-*r*53.8%
*-commutative53.8%
associate-/l*64.6%
frac-sub41.4%
frac-2neg41.4%
neg-mul-141.4%
distribute-lft-neg-in41.4%
times-frac39.8%
Applied egg-rr53.7%
Taylor expanded in y around 0 26.8%
Taylor expanded in x around 0 44.3%
*-lft-identity44.3%
fma-def44.3%
mul-1-neg44.3%
fma-neg44.3%
*-lft-identity44.3%
unpow244.3%
associate-*r*45.9%
*-lft-identity45.9%
associate-*l/45.9%
associate-*r*48.6%
*-commutative48.6%
associate-*r/48.6%
*-rgt-identity48.6%
Simplified48.6%
Final simplification48.6%
(FPCore (x y z) :precision binary64 (* 0.5 (- x (* y (/ y (/ x z))))))
double code(double x, double y, double z) {
return 0.5 * (x - (y * (y / (x / z))));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 0.5d0 * (x - (y * (y / (x / z))))
end function
public static double code(double x, double y, double z) {
return 0.5 * (x - (y * (y / (x / z))));
}
def code(x, y, z): return 0.5 * (x - (y * (y / (x / z))))
function code(x, y, z) return Float64(0.5 * Float64(x - Float64(y * Float64(y / Float64(x / z))))) end
function tmp = code(x, y, z) tmp = 0.5 * (x - (y * (y / (x / z)))); end
code[x_, y_, z_] := N[(0.5 * N[(x - N[(y * N[(y / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(x - y \cdot \frac{y}{\frac{x}{z}}\right)
\end{array}
Initial program 99.8%
metadata-eval99.8%
Simplified99.8%
cancel-sign-sub99.8%
distribute-lft-neg-in99.8%
flip--53.9%
sqr-neg53.9%
swap-sqr49.9%
rem-square-sqrt49.9%
sub-neg49.9%
Applied egg-rr49.9%
div-sub49.9%
associate-/l*67.2%
associate-*r*72.1%
frac-2neg72.1%
sub-neg72.1%
+-commutative72.1%
distribute-rgt-neg-in72.1%
fma-def72.1%
distribute-lft-neg-in72.1%
neg-mul-172.1%
times-frac87.0%
metadata-eval87.0%
frac-2neg87.0%
/-rgt-identity87.0%
sub-neg87.0%
+-commutative87.0%
Applied egg-rr87.0%
Taylor expanded in y around 0 85.5%
Taylor expanded in y around 0 48.6%
associate-/l*49.5%
Simplified49.5%
Final simplification49.5%
(FPCore (x y z) :precision binary64 (* 0.5 x))
double code(double x, double y, double z) {
return 0.5 * x;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 0.5d0 * x
end function
public static double code(double x, double y, double z) {
return 0.5 * x;
}
def code(x, y, z): return 0.5 * x
function code(x, y, z) return Float64(0.5 * x) end
function tmp = code(x, y, z) tmp = 0.5 * x; end
code[x_, y_, z_] := N[(0.5 * x), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot x
\end{array}
Initial program 99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in x around inf 47.5%
Final simplification47.5%
herbie shell --seed 2023297
(FPCore (x y z)
:name "Diagrams.Solve.Polynomial:quadForm from diagrams-solve-0.1, B"
:precision binary64
(* (/ 1.0 2.0) (+ x (* y (sqrt z)))))