
(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 (fma y (sqrt z) x)))
double code(double x, double y, double z) {
return 0.5 * fma(y, sqrt(z), x);
}
function code(x, y, z) return Float64(0.5 * fma(y, sqrt(z), x)) end
code[x_, y_, z_] := N[(0.5 * N[(y * N[Sqrt[z], $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \mathsf{fma}\left(y, \sqrt{z}, x\right)
\end{array}
Initial program 99.8%
metadata-eval99.8%
+-commutative99.8%
fma-def99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x y z) :precision binary64 (if (<= x -510000.0) (* 0.5 x) (if (<= x 1.15e+36) (* 0.5 (/ y (pow z -0.5))) (* 0.5 (fabs x)))))
double code(double x, double y, double z) {
double tmp;
if (x <= -510000.0) {
tmp = 0.5 * x;
} else if (x <= 1.15e+36) {
tmp = 0.5 * (y / pow(z, -0.5));
} else {
tmp = 0.5 * fabs(x);
}
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 <= (-510000.0d0)) then
tmp = 0.5d0 * x
else if (x <= 1.15d+36) then
tmp = 0.5d0 * (y / (z ** (-0.5d0)))
else
tmp = 0.5d0 * abs(x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -510000.0) {
tmp = 0.5 * x;
} else if (x <= 1.15e+36) {
tmp = 0.5 * (y / Math.pow(z, -0.5));
} else {
tmp = 0.5 * Math.abs(x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -510000.0: tmp = 0.5 * x elif x <= 1.15e+36: tmp = 0.5 * (y / math.pow(z, -0.5)) else: tmp = 0.5 * math.fabs(x) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -510000.0) tmp = Float64(0.5 * x); elseif (x <= 1.15e+36) tmp = Float64(0.5 * Float64(y / (z ^ -0.5))); else tmp = Float64(0.5 * abs(x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -510000.0) tmp = 0.5 * x; elseif (x <= 1.15e+36) tmp = 0.5 * (y / (z ^ -0.5)); else tmp = 0.5 * abs(x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -510000.0], N[(0.5 * x), $MachinePrecision], If[LessEqual[x, 1.15e+36], N[(0.5 * N[(y / N[Power[z, -0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Abs[x], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -510000:\\
\;\;\;\;0.5 \cdot x\\
\mathbf{elif}\;x \leq 1.15 \cdot 10^{+36}:\\
\;\;\;\;0.5 \cdot \frac{y}{{z}^{-0.5}}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left|x\right|\\
\end{array}
\end{array}
if x < -5.1e5Initial program 99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around inf 71.3%
if -5.1e5 < x < 1.14999999999999998e36Initial program 99.7%
metadata-eval99.7%
Simplified99.7%
+-commutative99.7%
*-commutative99.7%
add-sqr-sqrt99.3%
associate-*l*99.3%
fma-def99.3%
pow1/299.3%
sqrt-pow199.4%
metadata-eval99.4%
pow1/299.4%
sqrt-pow199.3%
metadata-eval99.3%
Applied egg-rr99.3%
fma-udef99.3%
associate-*r*99.4%
pow-prod-up99.7%
metadata-eval99.7%
pow1/299.7%
*-commutative99.7%
+-commutative99.7%
flip-+61.6%
unpow261.6%
div-sub61.6%
swap-sqr54.0%
unpow254.0%
add-sqr-sqrt54.0%
*-commutative54.0%
div-sub54.0%
clear-num53.9%
Applied egg-rr99.6%
Taylor expanded in y around inf 76.9%
associate-/r*77.1%
clear-num77.1%
associate-/r*77.1%
add-cbrt-cube35.2%
unpow235.2%
cbrt-prod51.1%
times-frac51.0%
unpow251.0%
cbrt-prod75.8%
pow275.7%
inv-pow75.7%
sqrt-pow175.8%
metadata-eval75.8%
Applied egg-rr75.8%
/-rgt-identity75.8%
associate-*r/75.8%
unpow275.8%
rem-3cbrt-lft77.2%
Simplified77.2%
if 1.14999999999999998e36 < x Initial program 99.9%
metadata-eval99.9%
Simplified99.9%
+-commutative99.9%
*-commutative99.9%
add-sqr-sqrt99.9%
associate-*l*99.8%
fma-def99.8%
pow1/299.8%
sqrt-pow199.8%
metadata-eval99.8%
pow1/299.8%
sqrt-pow199.8%
metadata-eval99.8%
Applied egg-rr99.8%
fma-udef99.8%
associate-*r*99.9%
pow-prod-up99.9%
metadata-eval99.9%
pow1/299.9%
*-commutative99.9%
+-commutative99.9%
flip-+40.8%
unpow240.8%
div-sub40.8%
swap-sqr38.3%
unpow238.3%
add-sqr-sqrt38.3%
*-commutative38.3%
div-sub38.3%
clear-num38.1%
Applied egg-rr99.7%
Taylor expanded in y around 0 77.9%
remove-double-div78.1%
add-sqr-sqrt77.5%
sqrt-unprod37.5%
pow237.5%
Applied egg-rr37.5%
unpow237.5%
rem-sqrt-square78.1%
Simplified78.1%
Final simplification76.0%
(FPCore (x y z) :precision binary64 (if (<= x -1e+23) (* 0.5 x) (if (<= x 1.95e+36) (* 0.5 (* y (sqrt z))) (* 0.5 (fabs x)))))
double code(double x, double y, double z) {
double tmp;
if (x <= -1e+23) {
tmp = 0.5 * x;
} else if (x <= 1.95e+36) {
tmp = 0.5 * (y * sqrt(z));
} else {
tmp = 0.5 * fabs(x);
}
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 <= (-1d+23)) then
tmp = 0.5d0 * x
else if (x <= 1.95d+36) then
tmp = 0.5d0 * (y * sqrt(z))
else
tmp = 0.5d0 * abs(x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -1e+23) {
tmp = 0.5 * x;
} else if (x <= 1.95e+36) {
tmp = 0.5 * (y * Math.sqrt(z));
} else {
tmp = 0.5 * Math.abs(x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1e+23: tmp = 0.5 * x elif x <= 1.95e+36: tmp = 0.5 * (y * math.sqrt(z)) else: tmp = 0.5 * math.fabs(x) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1e+23) tmp = Float64(0.5 * x); elseif (x <= 1.95e+36) tmp = Float64(0.5 * Float64(y * sqrt(z))); else tmp = Float64(0.5 * abs(x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1e+23) tmp = 0.5 * x; elseif (x <= 1.95e+36) tmp = 0.5 * (y * sqrt(z)); else tmp = 0.5 * abs(x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1e+23], N[(0.5 * x), $MachinePrecision], If[LessEqual[x, 1.95e+36], N[(0.5 * N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Abs[x], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1 \cdot 10^{+23}:\\
\;\;\;\;0.5 \cdot x\\
\mathbf{elif}\;x \leq 1.95 \cdot 10^{+36}:\\
\;\;\;\;0.5 \cdot \left(y \cdot \sqrt{z}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left|x\right|\\
\end{array}
\end{array}
if x < -9.9999999999999992e22Initial program 99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around inf 72.7%
if -9.9999999999999992e22 < x < 1.9500000000000001e36Initial program 99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around 0 76.4%
if 1.9500000000000001e36 < x Initial program 99.9%
metadata-eval99.9%
Simplified99.9%
+-commutative99.9%
*-commutative99.9%
add-sqr-sqrt99.9%
associate-*l*99.8%
fma-def99.8%
pow1/299.8%
sqrt-pow199.8%
metadata-eval99.8%
pow1/299.8%
sqrt-pow199.8%
metadata-eval99.8%
Applied egg-rr99.8%
fma-udef99.8%
associate-*r*99.9%
pow-prod-up99.9%
metadata-eval99.9%
pow1/299.9%
*-commutative99.9%
+-commutative99.9%
flip-+40.8%
unpow240.8%
div-sub40.8%
swap-sqr38.3%
unpow238.3%
add-sqr-sqrt38.3%
*-commutative38.3%
div-sub38.3%
clear-num38.1%
Applied egg-rr99.7%
Taylor expanded in y around 0 77.9%
remove-double-div78.1%
add-sqr-sqrt77.5%
sqrt-unprod37.5%
pow237.5%
Applied egg-rr37.5%
unpow237.5%
rem-sqrt-square78.1%
Simplified78.1%
Final simplification75.9%
(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 (* 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.1%
Final simplification47.1%
herbie shell --seed 2023318
(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)))))