
(FPCore (x y z) :precision binary64 (/ (+ x y) (- 1.0 (/ y z))))
double code(double x, double y, double z) {
return (x + y) / (1.0 - (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 = (x + y) / (1.0d0 - (y / z))
end function
public static double code(double x, double y, double z) {
return (x + y) / (1.0 - (y / z));
}
def code(x, y, z): return (x + y) / (1.0 - (y / z))
function code(x, y, z) return Float64(Float64(x + y) / Float64(1.0 - Float64(y / z))) end
function tmp = code(x, y, z) tmp = (x + y) / (1.0 - (y / z)); end
code[x_, y_, z_] := N[(N[(x + y), $MachinePrecision] / N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + y}{1 - \frac{y}{z}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (/ (+ x y) (- 1.0 (/ y z))))
double code(double x, double y, double z) {
return (x + y) / (1.0 - (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 = (x + y) / (1.0d0 - (y / z))
end function
public static double code(double x, double y, double z) {
return (x + y) / (1.0 - (y / z));
}
def code(x, y, z): return (x + y) / (1.0 - (y / z))
function code(x, y, z) return Float64(Float64(x + y) / Float64(1.0 - Float64(y / z))) end
function tmp = code(x, y, z) tmp = (x + y) / (1.0 - (y / z)); end
code[x_, y_, z_] := N[(N[(x + y), $MachinePrecision] / N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + y}{1 - \frac{y}{z}}
\end{array}
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (+ y x) (- 1.0 (/ y z)))))
(if (<= t_0 -5e-250)
t_0
(if (<= t_0 0.0) (fma (/ -1.0 y) (* z x) (- z)) t_0))))
double code(double x, double y, double z) {
double t_0 = (y + x) / (1.0 - (y / z));
double tmp;
if (t_0 <= -5e-250) {
tmp = t_0;
} else if (t_0 <= 0.0) {
tmp = fma((-1.0 / y), (z * x), -z);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(y + x) / Float64(1.0 - Float64(y / z))) tmp = 0.0 if (t_0 <= -5e-250) tmp = t_0; elseif (t_0 <= 0.0) tmp = fma(Float64(-1.0 / y), Float64(z * x), Float64(-z)); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(y + x), $MachinePrecision] / N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -5e-250], t$95$0, If[LessEqual[t$95$0, 0.0], N[(N[(-1.0 / y), $MachinePrecision] * N[(z * x), $MachinePrecision] + (-z)), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{y + x}{1 - \frac{y}{z}}\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{-250}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(\frac{-1}{y}, z \cdot x, -z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (+.f64 x y) (-.f64 #s(literal 1 binary64) (/.f64 y z))) < -5.00000000000000027e-250 or -0.0 < (/.f64 (+.f64 x y) (-.f64 #s(literal 1 binary64) (/.f64 y z))) Initial program 99.8%
if -5.00000000000000027e-250 < (/.f64 (+.f64 x y) (-.f64 #s(literal 1 binary64) (/.f64 y z))) < -0.0Initial program 22.1%
Taylor expanded in y around -inf
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
Applied rewrites99.9%
Taylor expanded in z around 0
Applied rewrites99.9%
Applied rewrites100.0%
Final simplification99.9%
(FPCore (x y z) :precision binary64 (fma (/ y (- z y)) z (/ x (- 1.0 (/ y z)))))
double code(double x, double y, double z) {
return fma((y / (z - y)), z, (x / (1.0 - (y / z))));
}
function code(x, y, z) return fma(Float64(y / Float64(z - y)), z, Float64(x / Float64(1.0 - Float64(y / z)))) end
code[x_, y_, z_] := N[(N[(y / N[(z - y), $MachinePrecision]), $MachinePrecision] * z + N[(x / N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{y}{z - y}, z, \frac{x}{1 - \frac{y}{z}}\right)
\end{array}
Initial program 92.3%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6497.8
Applied rewrites97.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- 1.0 (/ y z))))
(if (<= y -1.15e+188)
(- z)
(if (<= y -1200.0)
(/ y t_0)
(if (<= y 1.3e-87)
(/ x t_0)
(if (<= y 1.72e+136) (* (/ z (- z y)) y) (- (fma (/ x y) z z))))))))
double code(double x, double y, double z) {
double t_0 = 1.0 - (y / z);
double tmp;
if (y <= -1.15e+188) {
tmp = -z;
} else if (y <= -1200.0) {
tmp = y / t_0;
} else if (y <= 1.3e-87) {
tmp = x / t_0;
} else if (y <= 1.72e+136) {
tmp = (z / (z - y)) * y;
} else {
tmp = -fma((x / y), z, z);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(1.0 - Float64(y / z)) tmp = 0.0 if (y <= -1.15e+188) tmp = Float64(-z); elseif (y <= -1200.0) tmp = Float64(y / t_0); elseif (y <= 1.3e-87) tmp = Float64(x / t_0); elseif (y <= 1.72e+136) tmp = Float64(Float64(z / Float64(z - y)) * y); else tmp = Float64(-fma(Float64(x / y), z, z)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.15e+188], (-z), If[LessEqual[y, -1200.0], N[(y / t$95$0), $MachinePrecision], If[LessEqual[y, 1.3e-87], N[(x / t$95$0), $MachinePrecision], If[LessEqual[y, 1.72e+136], N[(N[(z / N[(z - y), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], (-N[(N[(x / y), $MachinePrecision] * z + z), $MachinePrecision])]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 - \frac{y}{z}\\
\mathbf{if}\;y \leq -1.15 \cdot 10^{+188}:\\
\;\;\;\;-z\\
\mathbf{elif}\;y \leq -1200:\\
\;\;\;\;\frac{y}{t\_0}\\
\mathbf{elif}\;y \leq 1.3 \cdot 10^{-87}:\\
\;\;\;\;\frac{x}{t\_0}\\
\mathbf{elif}\;y \leq 1.72 \cdot 10^{+136}:\\
\;\;\;\;\frac{z}{z - y} \cdot y\\
\mathbf{else}:\\
\;\;\;\;-\mathsf{fma}\left(\frac{x}{y}, z, z\right)\\
\end{array}
\end{array}
if y < -1.15000000000000006e188Initial program 63.2%
Taylor expanded in y around inf
mul-1-negN/A
lower-neg.f6496.1
Applied rewrites96.1%
if -1.15000000000000006e188 < y < -1200Initial program 93.6%
Taylor expanded in x around 0
lower-/.f64N/A
lower--.f64N/A
lower-/.f6473.1
Applied rewrites73.1%
if -1200 < y < 1.30000000000000001e-87Initial program 99.9%
Taylor expanded in x around inf
lower-/.f64N/A
lower--.f64N/A
lower-/.f6483.0
Applied rewrites83.0%
if 1.30000000000000001e-87 < y < 1.71999999999999989e136Initial program 95.3%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6496.8
Applied rewrites96.8%
Taylor expanded in x around 0
Applied rewrites67.4%
if 1.71999999999999989e136 < y Initial program 74.5%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6491.6
Applied rewrites91.6%
Taylor expanded in z around 0
Applied rewrites91.2%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* (/ z (- z y)) y)))
(if (<= y -1.15e+188)
(- z)
(if (<= y -1200.0)
t_0
(if (<= y 1.3e-87)
(/ x (- 1.0 (/ y z)))
(if (<= y 1.72e+136) t_0 (- (fma (/ x y) z z))))))))
double code(double x, double y, double z) {
double t_0 = (z / (z - y)) * y;
double tmp;
if (y <= -1.15e+188) {
tmp = -z;
} else if (y <= -1200.0) {
tmp = t_0;
} else if (y <= 1.3e-87) {
tmp = x / (1.0 - (y / z));
} else if (y <= 1.72e+136) {
tmp = t_0;
} else {
tmp = -fma((x / y), z, z);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(z / Float64(z - y)) * y) tmp = 0.0 if (y <= -1.15e+188) tmp = Float64(-z); elseif (y <= -1200.0) tmp = t_0; elseif (y <= 1.3e-87) tmp = Float64(x / Float64(1.0 - Float64(y / z))); elseif (y <= 1.72e+136) tmp = t_0; else tmp = Float64(-fma(Float64(x / y), z, z)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(z / N[(z - y), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[y, -1.15e+188], (-z), If[LessEqual[y, -1200.0], t$95$0, If[LessEqual[y, 1.3e-87], N[(x / N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.72e+136], t$95$0, (-N[(N[(x / y), $MachinePrecision] * z + z), $MachinePrecision])]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{z}{z - y} \cdot y\\
\mathbf{if}\;y \leq -1.15 \cdot 10^{+188}:\\
\;\;\;\;-z\\
\mathbf{elif}\;y \leq -1200:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 1.3 \cdot 10^{-87}:\\
\;\;\;\;\frac{x}{1 - \frac{y}{z}}\\
\mathbf{elif}\;y \leq 1.72 \cdot 10^{+136}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;-\mathsf{fma}\left(\frac{x}{y}, z, z\right)\\
\end{array}
\end{array}
if y < -1.15000000000000006e188Initial program 63.2%
Taylor expanded in y around inf
mul-1-negN/A
lower-neg.f6496.1
Applied rewrites96.1%
if -1.15000000000000006e188 < y < -1200 or 1.30000000000000001e-87 < y < 1.71999999999999989e136Initial program 94.4%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6498.4
Applied rewrites98.4%
Taylor expanded in x around 0
Applied rewrites70.3%
if -1200 < y < 1.30000000000000001e-87Initial program 99.9%
Taylor expanded in x around inf
lower-/.f64N/A
lower--.f64N/A
lower-/.f6483.0
Applied rewrites83.0%
if 1.71999999999999989e136 < y Initial program 74.5%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6491.6
Applied rewrites91.6%
Taylor expanded in z around 0
Applied rewrites91.2%
(FPCore (x y z) :precision binary64 (if (<= y -4.7e-29) (- (fma x (/ z y) z)) (if (<= y 1.35e+45) (fma x (/ y z) (+ y x)) (- (fma (/ x y) z z)))))
double code(double x, double y, double z) {
double tmp;
if (y <= -4.7e-29) {
tmp = -fma(x, (z / y), z);
} else if (y <= 1.35e+45) {
tmp = fma(x, (y / z), (y + x));
} else {
tmp = -fma((x / y), z, z);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= -4.7e-29) tmp = Float64(-fma(x, Float64(z / y), z)); elseif (y <= 1.35e+45) tmp = fma(x, Float64(y / z), Float64(y + x)); else tmp = Float64(-fma(Float64(x / y), z, z)); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, -4.7e-29], (-N[(x * N[(z / y), $MachinePrecision] + z), $MachinePrecision]), If[LessEqual[y, 1.35e+45], N[(x * N[(y / z), $MachinePrecision] + N[(y + x), $MachinePrecision]), $MachinePrecision], (-N[(N[(x / y), $MachinePrecision] * z + z), $MachinePrecision])]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.7 \cdot 10^{-29}:\\
\;\;\;\;-\mathsf{fma}\left(x, \frac{z}{y}, z\right)\\
\mathbf{elif}\;y \leq 1.35 \cdot 10^{+45}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{y}{z}, y + x\right)\\
\mathbf{else}:\\
\;\;\;\;-\mathsf{fma}\left(\frac{x}{y}, z, z\right)\\
\end{array}
\end{array}
if y < -4.6999999999999998e-29Initial program 84.0%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Taylor expanded in z around 0
Applied rewrites71.3%
Applied rewrites73.8%
if -4.6999999999999998e-29 < y < 1.34999999999999992e45Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
sub-negN/A
distribute-rgt-inN/A
*-lft-identityN/A
associate-+l+N/A
lower-+.f64N/A
lower-fma.f64N/A
mul-1-negN/A
remove-double-negN/A
lower-/.f6471.7
Applied rewrites71.7%
Applied rewrites76.4%
if 1.34999999999999992e45 < y Initial program 82.1%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6493.2
Applied rewrites93.2%
Taylor expanded in z around 0
Applied rewrites80.4%
(FPCore (x y z) :precision binary64 (if (<= y -4.7e-29) (- (fma x (/ z y) z)) (if (<= y 1.35e+45) (+ y x) (- (fma (/ x y) z z)))))
double code(double x, double y, double z) {
double tmp;
if (y <= -4.7e-29) {
tmp = -fma(x, (z / y), z);
} else if (y <= 1.35e+45) {
tmp = y + x;
} else {
tmp = -fma((x / y), z, z);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= -4.7e-29) tmp = Float64(-fma(x, Float64(z / y), z)); elseif (y <= 1.35e+45) tmp = Float64(y + x); else tmp = Float64(-fma(Float64(x / y), z, z)); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, -4.7e-29], (-N[(x * N[(z / y), $MachinePrecision] + z), $MachinePrecision]), If[LessEqual[y, 1.35e+45], N[(y + x), $MachinePrecision], (-N[(N[(x / y), $MachinePrecision] * z + z), $MachinePrecision])]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.7 \cdot 10^{-29}:\\
\;\;\;\;-\mathsf{fma}\left(x, \frac{z}{y}, z\right)\\
\mathbf{elif}\;y \leq 1.35 \cdot 10^{+45}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;-\mathsf{fma}\left(\frac{x}{y}, z, z\right)\\
\end{array}
\end{array}
if y < -4.6999999999999998e-29Initial program 84.0%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Taylor expanded in z around 0
Applied rewrites71.3%
Applied rewrites73.8%
if -4.6999999999999998e-29 < y < 1.34999999999999992e45Initial program 99.9%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6498.0
Applied rewrites98.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6476.3
Applied rewrites76.3%
if 1.34999999999999992e45 < y Initial program 82.1%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6493.2
Applied rewrites93.2%
Taylor expanded in z around 0
Applied rewrites80.4%
(FPCore (x y z) :precision binary64 (if (<= z -3e+34) (+ y x) (if (<= z 1.85e-62) (- (fma x (/ z y) z)) (+ y x))))
double code(double x, double y, double z) {
double tmp;
if (z <= -3e+34) {
tmp = y + x;
} else if (z <= 1.85e-62) {
tmp = -fma(x, (z / y), z);
} else {
tmp = y + x;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -3e+34) tmp = Float64(y + x); elseif (z <= 1.85e-62) tmp = Float64(-fma(x, Float64(z / y), z)); else tmp = Float64(y + x); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -3e+34], N[(y + x), $MachinePrecision], If[LessEqual[z, 1.85e-62], (-N[(x * N[(z / y), $MachinePrecision] + z), $MachinePrecision]), N[(y + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3 \cdot 10^{+34}:\\
\;\;\;\;y + x\\
\mathbf{elif}\;z \leq 1.85 \cdot 10^{-62}:\\
\;\;\;\;-\mathsf{fma}\left(x, \frac{z}{y}, z\right)\\
\mathbf{else}:\\
\;\;\;\;y + x\\
\end{array}
\end{array}
if z < -3.00000000000000018e34 or 1.8499999999999999e-62 < z Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6497.9
Applied rewrites97.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6479.1
Applied rewrites79.1%
if -3.00000000000000018e34 < z < 1.8499999999999999e-62Initial program 84.5%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6497.6
Applied rewrites97.6%
Taylor expanded in z around 0
Applied rewrites67.9%
Applied rewrites73.3%
(FPCore (x y z) :precision binary64 (if (<= y -4.7e+17) (- z) (if (<= y 1.7e+45) (+ y x) (- z))))
double code(double x, double y, double z) {
double tmp;
if (y <= -4.7e+17) {
tmp = -z;
} else if (y <= 1.7e+45) {
tmp = y + x;
} else {
tmp = -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 (y <= (-4.7d+17)) then
tmp = -z
else if (y <= 1.7d+45) then
tmp = y + x
else
tmp = -z
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= -4.7e+17) {
tmp = -z;
} else if (y <= 1.7e+45) {
tmp = y + x;
} else {
tmp = -z;
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= -4.7e+17: tmp = -z elif y <= 1.7e+45: tmp = y + x else: tmp = -z return tmp
function code(x, y, z) tmp = 0.0 if (y <= -4.7e+17) tmp = Float64(-z); elseif (y <= 1.7e+45) tmp = Float64(y + x); else tmp = Float64(-z); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= -4.7e+17) tmp = -z; elseif (y <= 1.7e+45) tmp = y + x; else tmp = -z; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, -4.7e+17], (-z), If[LessEqual[y, 1.7e+45], N[(y + x), $MachinePrecision], (-z)]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.7 \cdot 10^{+17}:\\
\;\;\;\;-z\\
\mathbf{elif}\;y \leq 1.7 \cdot 10^{+45}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;-z\\
\end{array}
\end{array}
if y < -4.7e17 or 1.7e45 < y Initial program 82.2%
Taylor expanded in y around inf
mul-1-negN/A
lower-neg.f6464.8
Applied rewrites64.8%
if -4.7e17 < y < 1.7e45Initial program 99.8%
Taylor expanded in x around 0
+-commutativeN/A
*-inversesN/A
div-subN/A
associate-/r/N/A
*-rgt-identityN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6498.1
Applied rewrites98.1%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6473.8
Applied rewrites73.8%
(FPCore (x y z) :precision binary64 (- z))
double code(double x, double y, double z) {
return -z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = -z
end function
public static double code(double x, double y, double z) {
return -z;
}
def code(x, y, z): return -z
function code(x, y, z) return Float64(-z) end
function tmp = code(x, y, z) tmp = -z; end
code[x_, y_, z_] := (-z)
\begin{array}{l}
\\
-z
\end{array}
Initial program 92.3%
Taylor expanded in y around inf
mul-1-negN/A
lower-neg.f6433.4
Applied rewrites33.4%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* (/ (+ y x) (- y)) z)))
(if (< y -3.7429310762689856e+171)
t_0
(if (< y 3.5534662456086734e+168) (/ (+ x y) (- 1.0 (/ y z))) t_0))))
double code(double x, double y, double z) {
double t_0 = ((y + x) / -y) * z;
double tmp;
if (y < -3.7429310762689856e+171) {
tmp = t_0;
} else if (y < 3.5534662456086734e+168) {
tmp = (x + y) / (1.0 - (y / z));
} 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 = ((y + x) / -y) * z
if (y < (-3.7429310762689856d+171)) then
tmp = t_0
else if (y < 3.5534662456086734d+168) then
tmp = (x + y) / (1.0d0 - (y / z))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = ((y + x) / -y) * z;
double tmp;
if (y < -3.7429310762689856e+171) {
tmp = t_0;
} else if (y < 3.5534662456086734e+168) {
tmp = (x + y) / (1.0 - (y / z));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = ((y + x) / -y) * z tmp = 0 if y < -3.7429310762689856e+171: tmp = t_0 elif y < 3.5534662456086734e+168: tmp = (x + y) / (1.0 - (y / z)) else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(Float64(Float64(y + x) / Float64(-y)) * z) tmp = 0.0 if (y < -3.7429310762689856e+171) tmp = t_0; elseif (y < 3.5534662456086734e+168) tmp = Float64(Float64(x + y) / Float64(1.0 - Float64(y / z))); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = ((y + x) / -y) * z; tmp = 0.0; if (y < -3.7429310762689856e+171) tmp = t_0; elseif (y < 3.5534662456086734e+168) tmp = (x + y) / (1.0 - (y / z)); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(y + x), $MachinePrecision] / (-y)), $MachinePrecision] * z), $MachinePrecision]}, If[Less[y, -3.7429310762689856e+171], t$95$0, If[Less[y, 3.5534662456086734e+168], N[(N[(x + y), $MachinePrecision] / N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{y + x}{-y} \cdot z\\
\mathbf{if}\;y < -3.7429310762689856 \cdot 10^{+171}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y < 3.5534662456086734 \cdot 10^{+168}:\\
\;\;\;\;\frac{x + y}{1 - \frac{y}{z}}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
herbie shell --seed 2024308
(FPCore (x y z)
:name "Graphics.Rendering.Chart.Backend.Diagrams:calcFontMetrics from Chart-diagrams-1.5.1, A"
:precision binary64
:alt
(! :herbie-platform default (if (< y -3742931076268985600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (* (/ (+ y x) (- y)) z) (if (< y 3553466245608673400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (/ (+ x y) (- 1 (/ y z))) (* (/ (+ y x) (- y)) z))))
(/ (+ x y) (- 1.0 (/ y z))))