
(FPCore (x y z t) :precision binary64 (- x (/ (* (* y 2.0) z) (- (* (* z 2.0) z) (* y t)))))
double code(double x, double y, double z, double t) {
return x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t)));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x - (((y * 2.0d0) * z) / (((z * 2.0d0) * z) - (y * t)))
end function
public static double code(double x, double y, double z, double t) {
return x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t)));
}
def code(x, y, z, t): return x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t)))
function code(x, y, z, t) return Float64(x - Float64(Float64(Float64(y * 2.0) * z) / Float64(Float64(Float64(z * 2.0) * z) - Float64(y * t)))) end
function tmp = code(x, y, z, t) tmp = x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t))); end
code[x_, y_, z_, t_] := N[(x - N[(N[(N[(y * 2.0), $MachinePrecision] * z), $MachinePrecision] / N[(N[(N[(z * 2.0), $MachinePrecision] * z), $MachinePrecision] - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{\left(y \cdot 2\right) \cdot z}{\left(z \cdot 2\right) \cdot z - y \cdot t}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (- x (/ (* (* y 2.0) z) (- (* (* z 2.0) z) (* y t)))))
double code(double x, double y, double z, double t) {
return x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t)));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x - (((y * 2.0d0) * z) / (((z * 2.0d0) * z) - (y * t)))
end function
public static double code(double x, double y, double z, double t) {
return x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t)));
}
def code(x, y, z, t): return x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t)))
function code(x, y, z, t) return Float64(x - Float64(Float64(Float64(y * 2.0) * z) / Float64(Float64(Float64(z * 2.0) * z) - Float64(y * t)))) end
function tmp = code(x, y, z, t) tmp = x - (((y * 2.0) * z) / (((z * 2.0) * z) - (y * t))); end
code[x_, y_, z_, t_] := N[(x - N[(N[(N[(y * 2.0), $MachinePrecision] * z), $MachinePrecision] / N[(N[(N[(z * 2.0), $MachinePrecision] * z), $MachinePrecision] - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{\left(y \cdot 2\right) \cdot z}{\left(z \cdot 2\right) \cdot z - y \cdot t}
\end{array}
(FPCore (x y z t) :precision binary64 (+ x (/ -2.0 (- (* z (/ 2.0 y)) (/ t z)))))
double code(double x, double y, double z, double t) {
return x + (-2.0 / ((z * (2.0 / y)) - (t / z)));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x + ((-2.0d0) / ((z * (2.0d0 / y)) - (t / z)))
end function
public static double code(double x, double y, double z, double t) {
return x + (-2.0 / ((z * (2.0 / y)) - (t / z)));
}
def code(x, y, z, t): return x + (-2.0 / ((z * (2.0 / y)) - (t / z)))
function code(x, y, z, t) return Float64(x + Float64(-2.0 / Float64(Float64(z * Float64(2.0 / y)) - Float64(t / z)))) end
function tmp = code(x, y, z, t) tmp = x + (-2.0 / ((z * (2.0 / y)) - (t / z))); end
code[x_, y_, z_, t_] := N[(x + N[(-2.0 / N[(N[(z * N[(2.0 / y), $MachinePrecision]), $MachinePrecision] - N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{-2}{z \cdot \frac{2}{y} - \frac{t}{z}}
\end{array}
Initial program 84.7%
sub-neg84.7%
associate-/l*92.8%
*-commutative92.8%
associate-/l*92.8%
distribute-neg-frac92.8%
metadata-eval92.8%
associate-/l/84.5%
div-sub76.0%
times-frac90.6%
*-inverses90.6%
*-rgt-identity90.6%
*-commutative90.6%
associate-*l/90.6%
*-commutative90.6%
times-frac99.7%
*-inverses99.7%
*-lft-identity99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (x y z t) :precision binary64 (if (or (<= z -4.5e-11) (not (<= z 1500000.0))) (- x (/ y z)) (- x (* -2.0 (/ z t)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -4.5e-11) || !(z <= 1500000.0)) {
tmp = x - (y / z);
} else {
tmp = x - (-2.0 * (z / t));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((z <= (-4.5d-11)) .or. (.not. (z <= 1500000.0d0))) then
tmp = x - (y / z)
else
tmp = x - ((-2.0d0) * (z / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -4.5e-11) || !(z <= 1500000.0)) {
tmp = x - (y / z);
} else {
tmp = x - (-2.0 * (z / t));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z <= -4.5e-11) or not (z <= 1500000.0): tmp = x - (y / z) else: tmp = x - (-2.0 * (z / t)) return tmp
function code(x, y, z, t) tmp = 0.0 if ((z <= -4.5e-11) || !(z <= 1500000.0)) tmp = Float64(x - Float64(y / z)); else tmp = Float64(x - Float64(-2.0 * Float64(z / t))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z <= -4.5e-11) || ~((z <= 1500000.0))) tmp = x - (y / z); else tmp = x - (-2.0 * (z / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[z, -4.5e-11], N[Not[LessEqual[z, 1500000.0]], $MachinePrecision]], N[(x - N[(y / z), $MachinePrecision]), $MachinePrecision], N[(x - N[(-2.0 * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.5 \cdot 10^{-11} \lor \neg \left(z \leq 1500000\right):\\
\;\;\;\;x - \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x - -2 \cdot \frac{z}{t}\\
\end{array}
\end{array}
if z < -4.5e-11 or 1.5e6 < z Initial program 75.6%
sub-neg75.6%
associate-/l*91.3%
*-commutative91.3%
associate-/l*91.3%
distribute-neg-frac91.3%
metadata-eval91.3%
associate-/l/75.6%
div-sub75.7%
times-frac91.2%
*-inverses91.2%
*-rgt-identity91.2%
*-commutative91.2%
associate-*l/91.2%
*-commutative91.2%
times-frac99.9%
*-inverses99.9%
*-lft-identity99.9%
Simplified99.9%
Taylor expanded in z around inf 92.3%
+-commutative92.3%
mul-1-neg92.3%
sub-neg92.3%
Simplified92.3%
if -4.5e-11 < z < 1.5e6Initial program 92.0%
associate-/l*94.0%
*-commutative94.0%
associate-*r/94.0%
div-sub94.0%
*-commutative94.0%
associate-/l*96.1%
associate-/r*96.1%
*-inverses96.1%
metadata-eval96.1%
*-commutative96.1%
associate-*l/98.9%
Simplified98.9%
Taylor expanded in y around inf 95.1%
*-commutative95.1%
Simplified95.1%
Final simplification93.8%
(FPCore (x y z t) :precision binary64 (if (or (<= z -7.8e-10) (not (<= z 980000000.0))) (- x (/ y z)) x))
double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -7.8e-10) || !(z <= 980000000.0)) {
tmp = x - (y / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((z <= (-7.8d-10)) .or. (.not. (z <= 980000000.0d0))) then
tmp = x - (y / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -7.8e-10) || !(z <= 980000000.0)) {
tmp = x - (y / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z <= -7.8e-10) or not (z <= 980000000.0): tmp = x - (y / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if ((z <= -7.8e-10) || !(z <= 980000000.0)) tmp = Float64(x - Float64(y / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z <= -7.8e-10) || ~((z <= 980000000.0))) tmp = x - (y / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[z, -7.8e-10], N[Not[LessEqual[z, 980000000.0]], $MachinePrecision]], N[(x - N[(y / z), $MachinePrecision]), $MachinePrecision], x]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.8 \cdot 10^{-10} \lor \neg \left(z \leq 980000000\right):\\
\;\;\;\;x - \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -7.7999999999999999e-10 or 9.8e8 < z Initial program 75.6%
sub-neg75.6%
associate-/l*91.3%
*-commutative91.3%
associate-/l*91.3%
distribute-neg-frac91.3%
metadata-eval91.3%
associate-/l/75.6%
div-sub75.7%
times-frac91.2%
*-inverses91.2%
*-rgt-identity91.2%
*-commutative91.2%
associate-*l/91.2%
*-commutative91.2%
times-frac99.9%
*-inverses99.9%
*-lft-identity99.9%
Simplified99.9%
Taylor expanded in z around inf 92.3%
+-commutative92.3%
mul-1-neg92.3%
sub-neg92.3%
Simplified92.3%
if -7.7999999999999999e-10 < z < 9.8e8Initial program 92.0%
sub-neg92.0%
associate-/l*94.0%
*-commutative94.0%
associate-/l*94.0%
distribute-neg-frac94.0%
metadata-eval94.0%
associate-/l/91.7%
div-sub76.3%
times-frac90.2%
*-inverses90.2%
*-rgt-identity90.2%
*-commutative90.2%
associate-*l/90.2%
*-commutative90.2%
times-frac99.5%
*-inverses99.5%
*-lft-identity99.5%
Simplified99.5%
Taylor expanded in x around inf 74.0%
Final simplification82.1%
(FPCore (x y z t) :precision binary64 (if (<= x -7.8e-187) x (if (<= x 7.2e-266) (* z (/ 2.0 t)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -7.8e-187) {
tmp = x;
} else if (x <= 7.2e-266) {
tmp = z * (2.0 / t);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-7.8d-187)) then
tmp = x
else if (x <= 7.2d-266) then
tmp = z * (2.0d0 / t)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -7.8e-187) {
tmp = x;
} else if (x <= 7.2e-266) {
tmp = z * (2.0 / t);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -7.8e-187: tmp = x elif x <= 7.2e-266: tmp = z * (2.0 / t) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -7.8e-187) tmp = x; elseif (x <= 7.2e-266) tmp = Float64(z * Float64(2.0 / t)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -7.8e-187) tmp = x; elseif (x <= 7.2e-266) tmp = z * (2.0 / t); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -7.8e-187], x, If[LessEqual[x, 7.2e-266], N[(z * N[(2.0 / t), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -7.8 \cdot 10^{-187}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 7.2 \cdot 10^{-266}:\\
\;\;\;\;z \cdot \frac{2}{t}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -7.7999999999999998e-187 or 7.1999999999999999e-266 < x Initial program 86.6%
sub-neg86.6%
associate-/l*94.3%
*-commutative94.3%
associate-/l*94.3%
distribute-neg-frac94.3%
metadata-eval94.3%
associate-/l/86.6%
div-sub77.1%
times-frac92.7%
*-inverses92.7%
*-rgt-identity92.7%
*-commutative92.7%
associate-*l/92.7%
*-commutative92.7%
times-frac99.9%
*-inverses99.9%
*-lft-identity99.9%
Simplified99.9%
Taylor expanded in x around inf 82.0%
if -7.7999999999999998e-187 < x < 7.1999999999999999e-266Initial program 70.5%
associate-/l*81.7%
*-commutative81.7%
associate-*r/81.7%
div-sub81.8%
*-commutative81.8%
associate-/l*82.0%
associate-/r*82.0%
*-inverses82.0%
metadata-eval82.0%
*-commutative82.0%
associate-*l/94.9%
Simplified94.9%
Taylor expanded in y around inf 67.2%
*-commutative67.2%
Simplified67.2%
Taylor expanded in x around 0 53.3%
*-commutative53.3%
associate-*l/53.3%
associate-*r/52.9%
Simplified52.9%
Final simplification78.6%
(FPCore (x y z t) :precision binary64 x)
double code(double x, double y, double z, double t) {
return x;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x
end function
public static double code(double x, double y, double z, double t) {
return x;
}
def code(x, y, z, t): return x
function code(x, y, z, t) return x end
function tmp = code(x, y, z, t) tmp = x; end
code[x_, y_, z_, t_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 84.7%
sub-neg84.7%
associate-/l*92.8%
*-commutative92.8%
associate-/l*92.8%
distribute-neg-frac92.8%
metadata-eval92.8%
associate-/l/84.5%
div-sub76.0%
times-frac90.6%
*-inverses90.6%
*-rgt-identity90.6%
*-commutative90.6%
associate-*l/90.6%
*-commutative90.6%
times-frac99.7%
*-inverses99.7%
*-lft-identity99.7%
Simplified99.7%
Taylor expanded in x around inf 75.4%
Final simplification75.4%
(FPCore (x y z t) :precision binary64 (- x (/ 1.0 (- (/ z y) (/ (/ t 2.0) z)))))
double code(double x, double y, double z, double t) {
return x - (1.0 / ((z / y) - ((t / 2.0) / z)));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x - (1.0d0 / ((z / y) - ((t / 2.0d0) / z)))
end function
public static double code(double x, double y, double z, double t) {
return x - (1.0 / ((z / y) - ((t / 2.0) / z)));
}
def code(x, y, z, t): return x - (1.0 / ((z / y) - ((t / 2.0) / z)))
function code(x, y, z, t) return Float64(x - Float64(1.0 / Float64(Float64(z / y) - Float64(Float64(t / 2.0) / z)))) end
function tmp = code(x, y, z, t) tmp = x - (1.0 / ((z / y) - ((t / 2.0) / z))); end
code[x_, y_, z_, t_] := N[(x - N[(1.0 / N[(N[(z / y), $MachinePrecision] - N[(N[(t / 2.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{1}{\frac{z}{y} - \frac{\frac{t}{2}}{z}}
\end{array}
herbie shell --seed 2023214
(FPCore (x y z t)
:name "Numeric.AD.Rank1.Halley:findZero from ad-4.2.4"
:precision binary64
:herbie-target
(- x (/ 1.0 (- (/ z y) (/ (/ t 2.0) z))))
(- x (/ (* (* y 2.0) z) (- (* (* z 2.0) z) (* y t)))))