
(FPCore (x y z) :precision binary64 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))
double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (((x * x) + (y * y)) - (z * z)) / (y * 2.0d0)
end function
public static double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}
def code(x, y, z): return (((x * x) + (y * y)) - (z * z)) / (y * 2.0)
function code(x, y, z) return Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) end
function tmp = code(x, y, z) tmp = (((x * x) + (y * y)) - (z * z)) / (y * 2.0); end
code[x_, y_, z_] := N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))
double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (((x * x) + (y * y)) - (z * z)) / (y * 2.0d0)
end function
public static double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}
def code(x, y, z): return (((x * x) + (y * y)) - (z * z)) / (y * 2.0)
function code(x, y, z) return Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) end
function tmp = code(x, y, z) tmp = (((x * x) + (y * y)) - (z * z)) / (y * 2.0); end
code[x_, y_, z_] := N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}
\end{array}
(FPCore (x y z) :precision binary64 (* 0.5 (fma (+ z x) (/ (- x z) y) y)))
double code(double x, double y, double z) {
return 0.5 * fma((z + x), ((x - z) / y), y);
}
function code(x, y, z) return Float64(0.5 * fma(Float64(z + x), Float64(Float64(x - z) / y), y)) end
code[x_, y_, z_] := N[(0.5 * N[(N[(z + x), $MachinePrecision] * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \mathsf{fma}\left(z + x, \frac{x - z}{y}, y\right)
\end{array}
Initial program 73.9%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_0 -200.0)
(* z (/ (* z -0.5) y))
(if (<= t_0 1e+148)
(* 0.5 y)
(if (<= t_0 INFINITY) (* x (/ x (* y 2.0))) (* z (* z (/ -0.5 y))))))))
double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else if (t_0 <= 1e+148) {
tmp = 0.5 * y;
} else if (t_0 <= ((double) INFINITY)) {
tmp = x * (x / (y * 2.0));
} else {
tmp = z * (z * (-0.5 / y));
}
return tmp;
}
public static double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else if (t_0 <= 1e+148) {
tmp = 0.5 * y;
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = x * (x / (y * 2.0));
} else {
tmp = z * (z * (-0.5 / y));
}
return tmp;
}
def code(x, y, z): t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0) tmp = 0 if t_0 <= -200.0: tmp = z * ((z * -0.5) / y) elif t_0 <= 1e+148: tmp = 0.5 * y elif t_0 <= math.inf: tmp = x * (x / (y * 2.0)) else: tmp = z * (z * (-0.5 / y)) return tmp
function code(x, y, z) t_0 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -200.0) tmp = Float64(z * Float64(Float64(z * -0.5) / y)); elseif (t_0 <= 1e+148) tmp = Float64(0.5 * y); elseif (t_0 <= Inf) tmp = Float64(x * Float64(x / Float64(y * 2.0))); else tmp = Float64(z * Float64(z * Float64(-0.5 / y))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0); tmp = 0.0; if (t_0 <= -200.0) tmp = z * ((z * -0.5) / y); elseif (t_0 <= 1e+148) tmp = 0.5 * y; elseif (t_0 <= Inf) tmp = x * (x / (y * 2.0)); else tmp = z * (z * (-0.5 / y)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], N[(z * N[(N[(z * -0.5), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 1e+148], N[(0.5 * y), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(x * N[(x / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(z * N[(-0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;z \cdot \frac{z \cdot -0.5}{y}\\
\mathbf{elif}\;t\_0 \leq 10^{+148}:\\
\;\;\;\;0.5 \cdot y\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;x \cdot \frac{x}{y \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(z \cdot \frac{-0.5}{y}\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6427.7
Simplified27.7%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < 1e148Initial program 99.9%
Taylor expanded in y around inf
*-lowering-*.f6459.6
Simplified59.6%
if 1e148 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 68.8%
Taylor expanded in x around inf
unpow2N/A
*-lowering-*.f6440.8
Simplified40.8%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6444.8
Applied egg-rr44.8%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6452.5
Simplified52.5%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6452.5
Applied egg-rr52.5%
Final simplification40.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_0 -200.0)
(* (+ z x) (/ (- x z) (* y 2.0)))
(if (<= t_0 INFINITY)
(* 0.5 (fma x (* x (/ 1.0 y)) y))
(* 0.5 (fma z (/ (- x z) y) y))))))
double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = (z + x) * ((x - z) / (y * 2.0));
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * fma(x, (x * (1.0 / y)), y);
} else {
tmp = 0.5 * fma(z, ((x - z) / y), y);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -200.0) tmp = Float64(Float64(z + x) * Float64(Float64(x - z) / Float64(y * 2.0))); elseif (t_0 <= Inf) tmp = Float64(0.5 * fma(x, Float64(x * Float64(1.0 / y)), y)); else tmp = Float64(0.5 * fma(z, Float64(Float64(x - z) / y), y)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], N[(N[(z + x), $MachinePrecision] * N[(N[(x - z), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * N[(x * N[(x * N[(1.0 / y), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(z * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;\left(z + x\right) \cdot \frac{x - z}{y \cdot 2}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x, x \cdot \frac{1}{y}, y\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(z, \frac{x - z}{y}, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in y around 0
unpow2N/A
unpow2N/A
difference-of-squaresN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
--lowering--.f6462.6
Simplified62.6%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6466.0
Applied egg-rr66.0%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 79.5%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified75.5%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f6475.5
Applied egg-rr75.5%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
Simplified84.1%
Final simplification72.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_0 -200.0)
(* (/ 0.5 y) (* (+ z x) (- x z)))
(if (<= t_0 INFINITY)
(* 0.5 (fma x (* x (/ 1.0 y)) y))
(* 0.5 (fma z (/ (- x z) y) y))))))
double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = (0.5 / y) * ((z + x) * (x - z));
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * fma(x, (x * (1.0 / y)), y);
} else {
tmp = 0.5 * fma(z, ((x - z) / y), y);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -200.0) tmp = Float64(Float64(0.5 / y) * Float64(Float64(z + x) * Float64(x - z))); elseif (t_0 <= Inf) tmp = Float64(0.5 * fma(x, Float64(x * Float64(1.0 / y)), y)); else tmp = Float64(0.5 * fma(z, Float64(Float64(x - z) / y), y)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], N[(N[(0.5 / y), $MachinePrecision] * N[(N[(z + x), $MachinePrecision] * N[(x - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * N[(x * N[(x * N[(1.0 / y), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(z * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;\frac{0.5}{y} \cdot \left(\left(z + x\right) \cdot \left(x - z\right)\right)\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x, x \cdot \frac{1}{y}, y\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(z, \frac{x - z}{y}, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in y around 0
unpow2N/A
unpow2N/A
difference-of-squaresN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
--lowering--.f6462.6
Simplified62.6%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
--lowering--.f6462.5
Applied egg-rr62.5%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 79.5%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified75.5%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f6475.5
Applied egg-rr75.5%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
Simplified84.1%
Final simplification70.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_0 -200.0)
(* z (/ (* z -0.5) y))
(if (<= t_0 INFINITY)
(* 0.5 (fma x (* x (/ 1.0 y)) y))
(* 0.5 (fma z (/ (- x z) y) y))))))
double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * fma(x, (x * (1.0 / y)), y);
} else {
tmp = 0.5 * fma(z, ((x - z) / y), y);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -200.0) tmp = Float64(z * Float64(Float64(z * -0.5) / y)); elseif (t_0 <= Inf) tmp = Float64(0.5 * fma(x, Float64(x * Float64(1.0 / y)), y)); else tmp = Float64(0.5 * fma(z, Float64(Float64(x - z) / y), y)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], N[(z * N[(N[(z * -0.5), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * N[(x * N[(x * N[(1.0 / y), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(z * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;z \cdot \frac{z \cdot -0.5}{y}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x, x \cdot \frac{1}{y}, y\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(z, \frac{x - z}{y}, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6427.7
Simplified27.7%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 79.5%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified75.5%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f6475.5
Applied egg-rr75.5%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
Simplified84.1%
Final simplification55.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_0 -200.0)
(* z (/ (* z -0.5) y))
(if (<= t_0 INFINITY)
(* 0.5 (fma x (/ x y) y))
(* 0.5 (fma z (/ (- x z) y) y))))))
double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * fma(x, (x / y), y);
} else {
tmp = 0.5 * fma(z, ((x - z) / y), y);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -200.0) tmp = Float64(z * Float64(Float64(z * -0.5) / y)); elseif (t_0 <= Inf) tmp = Float64(0.5 * fma(x, Float64(x / y), y)); else tmp = Float64(0.5 * fma(z, Float64(Float64(x - z) / y), y)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], N[(z * N[(N[(z * -0.5), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * N[(x * N[(x / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(z * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;z \cdot \frac{z \cdot -0.5}{y}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x, \frac{x}{y}, y\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(z, \frac{x - z}{y}, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6427.7
Simplified27.7%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 79.5%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified75.5%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
Simplified84.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_0 -200.0)
(* z (/ (* z -0.5) y))
(if (<= t_0 INFINITY)
(* 0.5 (fma x (/ x y) y))
(* 0.5 (- y (* z (/ z y))))))))
double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * fma(x, (x / y), y);
} else {
tmp = 0.5 * (y - (z * (z / y)));
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -200.0) tmp = Float64(z * Float64(Float64(z * -0.5) / y)); elseif (t_0 <= Inf) tmp = Float64(0.5 * fma(x, Float64(x / y), y)); else tmp = Float64(0.5 * Float64(y - Float64(z * Float64(z / y)))); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], N[(z * N[(N[(z * -0.5), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * N[(x * N[(x / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y - N[(z * N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;z \cdot \frac{z \cdot -0.5}{y}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x, \frac{x}{y}, y\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(y - z \cdot \frac{z}{y}\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6427.7
Simplified27.7%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 79.5%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified75.5%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.9
Applied egg-rr99.9%
Taylor expanded in x around 0
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
unpow2N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6478.9
Simplified78.9%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_0 -200.0)
(* z (/ (* z -0.5) y))
(if (<= t_0 INFINITY) (* 0.5 y) (* z (* z (/ -0.5 y)))))))
double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * y;
} else {
tmp = z * (z * (-0.5 / y));
}
return tmp;
}
public static double code(double x, double y, double z) {
double t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_0 <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = 0.5 * y;
} else {
tmp = z * (z * (-0.5 / y));
}
return tmp;
}
def code(x, y, z): t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0) tmp = 0 if t_0 <= -200.0: tmp = z * ((z * -0.5) / y) elif t_0 <= math.inf: tmp = 0.5 * y else: tmp = z * (z * (-0.5 / y)) return tmp
function code(x, y, z) t_0 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -200.0) tmp = Float64(z * Float64(Float64(z * -0.5) / y)); elseif (t_0 <= Inf) tmp = Float64(0.5 * y); else tmp = Float64(z * Float64(z * Float64(-0.5 / y))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0); tmp = 0.0; if (t_0 <= -200.0) tmp = z * ((z * -0.5) / y); elseif (t_0 <= Inf) tmp = 0.5 * y; else tmp = z * (z * (-0.5 / y)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], N[(z * N[(N[(z * -0.5), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * y), $MachinePrecision], N[(z * N[(z * N[(-0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;z \cdot \frac{z \cdot -0.5}{y}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot y\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(z \cdot \frac{-0.5}{y}\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6427.7
Simplified27.7%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 79.5%
Taylor expanded in y around inf
*-lowering-*.f6440.0
Simplified40.0%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6452.5
Simplified52.5%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6452.5
Applied egg-rr52.5%
Final simplification35.7%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* z (* z (/ -0.5 y))))
(t_1 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0))))
(if (<= t_1 -200.0) t_0 (if (<= t_1 INFINITY) (* 0.5 y) t_0))))
double code(double x, double y, double z) {
double t_0 = z * (z * (-0.5 / y));
double t_1 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_1 <= -200.0) {
tmp = t_0;
} else if (t_1 <= ((double) INFINITY)) {
tmp = 0.5 * y;
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double x, double y, double z) {
double t_0 = z * (z * (-0.5 / y));
double t_1 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
double tmp;
if (t_1 <= -200.0) {
tmp = t_0;
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = 0.5 * y;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = z * (z * (-0.5 / y)) t_1 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0) tmp = 0 if t_1 <= -200.0: tmp = t_0 elif t_1 <= math.inf: tmp = 0.5 * y else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(z * Float64(z * Float64(-0.5 / y))) t_1 = Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) tmp = 0.0 if (t_1 <= -200.0) tmp = t_0; elseif (t_1 <= Inf) tmp = Float64(0.5 * y); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = z * (z * (-0.5 / y)); t_1 = (((x * x) + (y * y)) - (z * z)) / (y * 2.0); tmp = 0.0; if (t_1 <= -200.0) tmp = t_0; elseif (t_1 <= Inf) tmp = 0.5 * y; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[(z * N[(-0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -200.0], t$95$0, If[LessEqual[t$95$1, Infinity], N[(0.5 * y), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \left(z \cdot \frac{-0.5}{y}\right)\\
t_1 := \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}\\
\mathbf{if}\;t\_1 \leq -200:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;0.5 \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200 or +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 68.3%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6431.4
Simplified31.4%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6431.3
Applied egg-rr31.3%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 79.5%
Taylor expanded in y around inf
*-lowering-*.f6440.0
Simplified40.0%
Final simplification35.7%
(FPCore (x y z) :precision binary64 (if (<= (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)) -200.0) (* z (/ (* z -0.5) y)) (* 0.5 (fma x (/ x y) y))))
double code(double x, double y, double z) {
double tmp;
if (((((x * x) + (y * y)) - (z * z)) / (y * 2.0)) <= -200.0) {
tmp = z * ((z * -0.5) / y);
} else {
tmp = 0.5 * fma(x, (x / y), y);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) <= -200.0) tmp = Float64(z * Float64(Float64(z * -0.5) / y)); else tmp = Float64(0.5 * fma(x, Float64(x / y), y)); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision], -200.0], N[(z * N[(N[(z * -0.5), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(x * N[(x / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2} \leq -200:\\
\;\;\;\;z \cdot \frac{z \cdot -0.5}{y}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x, \frac{x}{y}, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -200Initial program 80.2%
Taylor expanded in x around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l/N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6427.7
Simplified27.7%
if -200 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 69.2%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified71.6%
(FPCore (x y z) :precision binary64 (* 0.5 y))
double code(double x, double y, double z) {
return 0.5 * y;
}
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 * y
end function
public static double code(double x, double y, double z) {
return 0.5 * y;
}
def code(x, y, z): return 0.5 * y
function code(x, y, z) return Float64(0.5 * y) end
function tmp = code(x, y, z) tmp = 0.5 * y; end
code[x_, y_, z_] := N[(0.5 * y), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot y
\end{array}
Initial program 73.9%
Taylor expanded in y around inf
*-lowering-*.f6437.1
Simplified37.1%
(FPCore (x y z) :precision binary64 (- (* y 0.5) (* (* (/ 0.5 y) (+ z x)) (- z x))))
double code(double x, double y, double z) {
return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (y * 0.5d0) - (((0.5d0 / y) * (z + x)) * (z - x))
end function
public static double code(double x, double y, double z) {
return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x));
}
def code(x, y, z): return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x))
function code(x, y, z) return Float64(Float64(y * 0.5) - Float64(Float64(Float64(0.5 / y) * Float64(z + x)) * Float64(z - x))) end
function tmp = code(x, y, z) tmp = (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x)); end
code[x_, y_, z_] := N[(N[(y * 0.5), $MachinePrecision] - N[(N[(N[(0.5 / y), $MachinePrecision] * N[(z + x), $MachinePrecision]), $MachinePrecision] * N[(z - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
y \cdot 0.5 - \left(\frac{0.5}{y} \cdot \left(z + x\right)\right) \cdot \left(z - x\right)
\end{array}
herbie shell --seed 2024204
(FPCore (x y z)
:name "Diagrams.TwoD.Apollonian:initialConfig from diagrams-contrib-1.3.0.5, A"
:precision binary64
:alt
(! :herbie-platform default (- (* y 1/2) (* (* (/ 1/2 y) (+ z x)) (- z x))))
(/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))