
(FPCore (x y z t a b) :precision binary64 (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))
double code(double x, double y, double z, double t, double a, double b) {
return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}
def code(x, y, z, t, a, b): return ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y)))) end
function tmp = code(x, y, z, t, a, b) tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y))); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))
double code(double x, double y, double z, double t, double a, double b) {
return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}
def code(x, y, z, t, a, b): return ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y)))) end
function tmp = code(x, y, z, t, a, b) tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y))); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}
\end{array}
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1
(-
(/ (- t a) (- b y))
(/ (fma y (/ (- t a) (* (- b y) (- b y))) (* x (/ y (- y b)))) z)))
(t_2 (fma z (- b y) y)))
(if (<= z -1.42e+51)
t_1
(if (<= z 1.22e+15) (fma x (/ y t_2) (/ (* z (- t a)) t_2)) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((t - a) / (b - y)) - (fma(y, ((t - a) / ((b - y) * (b - y))), (x * (y / (y - b)))) / z);
double t_2 = fma(z, (b - y), y);
double tmp;
if (z <= -1.42e+51) {
tmp = t_1;
} else if (z <= 1.22e+15) {
tmp = fma(x, (y / t_2), ((z * (t - a)) / t_2));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(t - a) / Float64(b - y)) - Float64(fma(y, Float64(Float64(t - a) / Float64(Float64(b - y) * Float64(b - y))), Float64(x * Float64(y / Float64(y - b)))) / z)) t_2 = fma(z, Float64(b - y), y) tmp = 0.0 if (z <= -1.42e+51) tmp = t_1; elseif (z <= 1.22e+15) tmp = fma(x, Float64(y / t_2), Float64(Float64(z * Float64(t - a)) / t_2)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision] - N[(N[(y * N[(N[(t - a), $MachinePrecision] / N[(N[(b - y), $MachinePrecision] * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * N[(y / N[(y - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(b - y), $MachinePrecision] + y), $MachinePrecision]}, If[LessEqual[z, -1.42e+51], t$95$1, If[LessEqual[z, 1.22e+15], N[(x * N[(y / t$95$2), $MachinePrecision] + N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y} - \frac{\mathsf{fma}\left(y, \frac{t - a}{\left(b - y\right) \cdot \left(b - y\right)}, x \cdot \frac{y}{y - b}\right)}{z}\\
t_2 := \mathsf{fma}\left(z, b - y, y\right)\\
\mathbf{if}\;z \leq -1.42 \cdot 10^{+51}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.22 \cdot 10^{+15}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{y}{t\_2}, \frac{z \cdot \left(t - a\right)}{t\_2}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.41999999999999998e51 or 1.22e15 < z Initial program 40.1%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6444.0
Simplified44.0%
Taylor expanded in z around -inf
associate--l+N/A
div-subN/A
+-lowering-+.f64N/A
Simplified93.2%
if -1.41999999999999998e51 < z < 1.22e15Initial program 85.4%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.2
Simplified98.2%
Final simplification96.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (- t a) (- b y)))
(t_2 (/ (+ (* z (- t a)) (* y x)) (+ y (* z (- b y)))))
(t_3 (fma z (- b y) y)))
(if (<= t_2 -2e+273)
(fma (- t a) (/ z t_3) x)
(if (<= t_2 -5e-304)
t_2
(if (<= t_2 0.0)
t_1
(if (<= t_2 2e+299)
t_2
(if (<= t_2 INFINITY) (fma (/ (- t a) t_3) z x) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t - a) / (b - y);
double t_2 = ((z * (t - a)) + (y * x)) / (y + (z * (b - y)));
double t_3 = fma(z, (b - y), y);
double tmp;
if (t_2 <= -2e+273) {
tmp = fma((t - a), (z / t_3), x);
} else if (t_2 <= -5e-304) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = t_1;
} else if (t_2 <= 2e+299) {
tmp = t_2;
} else if (t_2 <= ((double) INFINITY)) {
tmp = fma(((t - a) / t_3), z, x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t - a) / Float64(b - y)) t_2 = Float64(Float64(Float64(z * Float64(t - a)) + Float64(y * x)) / Float64(y + Float64(z * Float64(b - y)))) t_3 = fma(z, Float64(b - y), y) tmp = 0.0 if (t_2 <= -2e+273) tmp = fma(Float64(t - a), Float64(z / t_3), x); elseif (t_2 <= -5e-304) tmp = t_2; elseif (t_2 <= 0.0) tmp = t_1; elseif (t_2 <= 2e+299) tmp = t_2; elseif (t_2 <= Inf) tmp = fma(Float64(Float64(t - a) / t_3), z, x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(z * N[(b - y), $MachinePrecision] + y), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+273], N[(N[(t - a), $MachinePrecision] * N[(z / t$95$3), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$2, -5e-304], t$95$2, If[LessEqual[t$95$2, 0.0], t$95$1, If[LessEqual[t$95$2, 2e+299], t$95$2, If[LessEqual[t$95$2, Infinity], N[(N[(N[(t - a), $MachinePrecision] / t$95$3), $MachinePrecision] * z + x), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y}\\
t_2 := \frac{z \cdot \left(t - a\right) + y \cdot x}{y + z \cdot \left(b - y\right)}\\
t_3 := \mathsf{fma}\left(z, b - y, y\right)\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+273}:\\
\;\;\;\;\mathsf{fma}\left(t - a, \frac{z}{t\_3}, x\right)\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{-304}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+299}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\frac{t - a}{t\_3}, z, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < -1.99999999999999989e273Initial program 42.1%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6484.6
Simplified84.6%
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f6457.3
Applied egg-rr57.3%
Taylor expanded in z around 0
Simplified87.2%
if -1.99999999999999989e273 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < -4.99999999999999965e-304 or 0.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 2.0000000000000001e299Initial program 99.3%
if -4.99999999999999965e-304 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 0.0 or +inf.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) Initial program 8.9%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6477.1
Simplified77.1%
if 2.0000000000000001e299 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < +inf.0Initial program 29.2%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6467.4
Simplified67.4%
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f6461.5
Applied egg-rr61.5%
Taylor expanded in z around 0
Simplified77.2%
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
clear-numN/A
/-rgt-identityN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f6477.3
Applied egg-rr77.3%
Final simplification91.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (fma z (- b y) y)) (t_2 (/ (- t a) (- b y))))
(if (<= z -2.75e+51)
t_2
(if (<= z 1.25e+50) (fma x (/ y t_1) (/ (* z (- t a)) t_1)) t_2))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(z, (b - y), y);
double t_2 = (t - a) / (b - y);
double tmp;
if (z <= -2.75e+51) {
tmp = t_2;
} else if (z <= 1.25e+50) {
tmp = fma(x, (y / t_1), ((z * (t - a)) / t_1));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(z, Float64(b - y), y) t_2 = Float64(Float64(t - a) / Float64(b - y)) tmp = 0.0 if (z <= -2.75e+51) tmp = t_2; elseif (z <= 1.25e+50) tmp = fma(x, Float64(y / t_1), Float64(Float64(z * Float64(t - a)) / t_1)); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(b - y), $MachinePrecision] + y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.75e+51], t$95$2, If[LessEqual[z, 1.25e+50], N[(x * N[(y / t$95$1), $MachinePrecision] + N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(z, b - y, y\right)\\
t_2 := \frac{t - a}{b - y}\\
\mathbf{if}\;z \leq -2.75 \cdot 10^{+51}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 1.25 \cdot 10^{+50}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{y}{t\_1}, \frac{z \cdot \left(t - a\right)}{t\_1}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -2.75e51 or 1.25e50 < z Initial program 38.1%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6485.6
Simplified85.6%
if -2.75e51 < z < 1.25e50Initial program 84.3%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6497.7
Simplified97.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (- t a) (- b y))))
(if (<= z -4e+23)
t_1
(if (<= z 1.1e+15) (fma (- t a) (/ z (fma z (- b y) y)) x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t - a) / (b - y);
double tmp;
if (z <= -4e+23) {
tmp = t_1;
} else if (z <= 1.1e+15) {
tmp = fma((t - a), (z / fma(z, (b - y), y)), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t - a) / Float64(b - y)) tmp = 0.0 if (z <= -4e+23) tmp = t_1; elseif (z <= 1.1e+15) tmp = fma(Float64(t - a), Float64(z / fma(z, Float64(b - y), y)), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4e+23], t$95$1, If[LessEqual[z, 1.1e+15], N[(N[(t - a), $MachinePrecision] * N[(z / N[(z * N[(b - y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y}\\
\mathbf{if}\;z \leq -4 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+15}:\\
\;\;\;\;\mathsf{fma}\left(t - a, \frac{z}{\mathsf{fma}\left(z, b - y, y\right)}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.9999999999999997e23 or 1.1e15 < z Initial program 42.0%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6483.7
Simplified83.7%
if -3.9999999999999997e23 < z < 1.1e15Initial program 85.5%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.2
Simplified98.2%
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f6482.9
Applied egg-rr82.9%
Taylor expanded in z around 0
Simplified83.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (- t a) (- b y))))
(if (<= z -0.00195)
t_1
(if (<= z 1.12e-9) (fma (- t a) (/ z (fma z b y)) x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t - a) / (b - y);
double tmp;
if (z <= -0.00195) {
tmp = t_1;
} else if (z <= 1.12e-9) {
tmp = fma((t - a), (z / fma(z, b, y)), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t - a) / Float64(b - y)) tmp = 0.0 if (z <= -0.00195) tmp = t_1; elseif (z <= 1.12e-9) tmp = fma(Float64(t - a), Float64(z / fma(z, b, y)), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.00195], t$95$1, If[LessEqual[z, 1.12e-9], N[(N[(t - a), $MachinePrecision] * N[(z / N[(z * b + y), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y}\\
\mathbf{if}\;z \leq -0.00195:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.12 \cdot 10^{-9}:\\
\;\;\;\;\mathsf{fma}\left(t - a, \frac{z}{\mathsf{fma}\left(z, b, y\right)}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -0.0019499999999999999 or 1.12000000000000006e-9 < z Initial program 44.3%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6483.1
Simplified83.1%
if -0.0019499999999999999 < z < 1.12000000000000006e-9Initial program 85.6%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.1
Simplified98.1%
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f6482.8
Applied egg-rr82.8%
Taylor expanded in z around 0
Simplified83.0%
Taylor expanded in b around inf
Simplified82.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (- t a) (- b y))))
(if (<= z -6e-26)
t_1
(if (<= z 3.1e-201)
(fma z (/ t y) x)
(if (<= z 2.25e-10) (fma z (/ a (- y)) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t - a) / (b - y);
double tmp;
if (z <= -6e-26) {
tmp = t_1;
} else if (z <= 3.1e-201) {
tmp = fma(z, (t / y), x);
} else if (z <= 2.25e-10) {
tmp = fma(z, (a / -y), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t - a) / Float64(b - y)) tmp = 0.0 if (z <= -6e-26) tmp = t_1; elseif (z <= 3.1e-201) tmp = fma(z, Float64(t / y), x); elseif (z <= 2.25e-10) tmp = fma(z, Float64(a / Float64(-y)), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6e-26], t$95$1, If[LessEqual[z, 3.1e-201], N[(z * N[(t / y), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 2.25e-10], N[(z * N[(a / (-y)), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y}\\
\mathbf{if}\;z \leq -6 \cdot 10^{-26}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{-201}:\\
\;\;\;\;\mathsf{fma}\left(z, \frac{t}{y}, x\right)\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(z, \frac{a}{-y}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -6.00000000000000023e-26 or 2.25e-10 < z Initial program 47.0%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6480.9
Simplified80.9%
if -6.00000000000000023e-26 < z < 3.0999999999999999e-201Initial program 86.7%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.3
Simplified98.3%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate--r+N/A
--lowering--.f64N/A
div-subN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6454.6
Simplified54.6%
Taylor expanded in t around inf
/-lowering-/.f6466.2
Simplified66.2%
if 3.0999999999999999e-201 < z < 2.25e-10Initial program 80.9%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6497.4
Simplified97.4%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate--r+N/A
--lowering--.f64N/A
div-subN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6444.2
Simplified44.2%
Taylor expanded in a around inf
associate-*r/N/A
mul-1-negN/A
/-lowering-/.f64N/A
neg-lowering-neg.f6459.7
Simplified59.7%
Final simplification72.0%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ (- t a) (- b y)))) (if (<= z -1.14e-8) t_1 (if (<= z 6.6e-10) (fma (- t a) (/ z y) x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t - a) / (b - y);
double tmp;
if (z <= -1.14e-8) {
tmp = t_1;
} else if (z <= 6.6e-10) {
tmp = fma((t - a), (z / y), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t - a) / Float64(b - y)) tmp = 0.0 if (z <= -1.14e-8) tmp = t_1; elseif (z <= 6.6e-10) tmp = fma(Float64(t - a), Float64(z / y), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.14e-8], t$95$1, If[LessEqual[z, 6.6e-10], N[(N[(t - a), $MachinePrecision] * N[(z / y), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y}\\
\mathbf{if}\;z \leq -1.14 \cdot 10^{-8}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 6.6 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(t - a, \frac{z}{y}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.14e-8 or 6.6e-10 < z Initial program 44.3%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6483.1
Simplified83.1%
if -1.14e-8 < z < 6.6e-10Initial program 85.6%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.1
Simplified98.1%
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
--lowering--.f6482.8
Applied egg-rr82.8%
Taylor expanded in z around 0
Simplified83.0%
Taylor expanded in z around 0
/-lowering-/.f6473.0
Simplified73.0%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ (- t a) (- b y)))) (if (<= z -1.22e-26) t_1 (if (<= z 3.4e-33) (fma z (/ t y) x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t - a) / (b - y);
double tmp;
if (z <= -1.22e-26) {
tmp = t_1;
} else if (z <= 3.4e-33) {
tmp = fma(z, (t / y), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t - a) / Float64(b - y)) tmp = 0.0 if (z <= -1.22e-26) tmp = t_1; elseif (z <= 3.4e-33) tmp = fma(z, Float64(t / y), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.22e-26], t$95$1, If[LessEqual[z, 3.4e-33], N[(z * N[(t / y), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y}\\
\mathbf{if}\;z \leq -1.22 \cdot 10^{-26}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 3.4 \cdot 10^{-33}:\\
\;\;\;\;\mathsf{fma}\left(z, \frac{t}{y}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.22e-26 or 3.4000000000000001e-33 < z Initial program 47.6%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6478.5
Simplified78.5%
if -1.22e-26 < z < 3.4000000000000001e-33Initial program 85.9%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.0
Simplified98.0%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate--r+N/A
--lowering--.f64N/A
div-subN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6451.4
Simplified51.4%
Taylor expanded in t around inf
/-lowering-/.f6461.2
Simplified61.2%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ (- t a) (- b y)))) (if (<= z -1.45e-27) t_1 (if (<= z 3.7e-10) (fma z x x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t - a) / (b - y);
double tmp;
if (z <= -1.45e-27) {
tmp = t_1;
} else if (z <= 3.7e-10) {
tmp = fma(z, x, x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t - a) / Float64(b - y)) tmp = 0.0 if (z <= -1.45e-27) tmp = t_1; elseif (z <= 3.7e-10) tmp = fma(z, x, x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.45e-27], t$95$1, If[LessEqual[z, 3.7e-10], N[(z * x + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - a}{b - y}\\
\mathbf{if}\;z \leq -1.45 \cdot 10^{-27}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 3.7 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(z, x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.45000000000000002e-27 or 3.70000000000000015e-10 < z Initial program 47.0%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6480.9
Simplified80.9%
if -1.45000000000000002e-27 < z < 3.70000000000000015e-10Initial program 85.0%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.1
Simplified98.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate--r+N/A
--lowering--.f64N/A
div-subN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6451.6
Simplified51.6%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6451.3
Simplified51.3%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ x (- 1.0 z)))) (if (<= y -1.7e-69) t_1 (if (<= y 3.3e+53) (/ (- t a) b) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (1.0 - z);
double tmp;
if (y <= -1.7e-69) {
tmp = t_1;
} else if (y <= 3.3e+53) {
tmp = (t - a) / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x / (1.0d0 - z)
if (y <= (-1.7d-69)) then
tmp = t_1
else if (y <= 3.3d+53) then
tmp = (t - a) / b
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (1.0 - z);
double tmp;
if (y <= -1.7e-69) {
tmp = t_1;
} else if (y <= 3.3e+53) {
tmp = (t - a) / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (1.0 - z) tmp = 0 if y <= -1.7e-69: tmp = t_1 elif y <= 3.3e+53: tmp = (t - a) / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(1.0 - z)) tmp = 0.0 if (y <= -1.7e-69) tmp = t_1; elseif (y <= 3.3e+53) tmp = Float64(Float64(t - a) / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (1.0 - z); tmp = 0.0; if (y <= -1.7e-69) tmp = t_1; elseif (y <= 3.3e+53) tmp = (t - a) / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.7e-69], t$95$1, If[LessEqual[y, 3.3e+53], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{1 - z}\\
\mathbf{if}\;y \leq -1.7 \cdot 10^{-69}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+53}:\\
\;\;\;\;\frac{t - a}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.70000000000000004e-69 or 3.3000000000000002e53 < y Initial program 53.9%
Taylor expanded in y around inf
/-lowering-/.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6455.8
Simplified55.8%
if -1.70000000000000004e-69 < y < 3.3000000000000002e53Initial program 80.2%
Taylor expanded in y around 0
/-lowering-/.f64N/A
--lowering--.f6454.4
Simplified54.4%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ t (- b y)))) (if (<= z -1.75e-29) t_1 (if (<= z 8.4e-10) (fma z x x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t / (b - y);
double tmp;
if (z <= -1.75e-29) {
tmp = t_1;
} else if (z <= 8.4e-10) {
tmp = fma(z, x, x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(t / Float64(b - y)) tmp = 0.0 if (z <= -1.75e-29) tmp = t_1; elseif (z <= 8.4e-10) tmp = fma(z, x, x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.75e-29], t$95$1, If[LessEqual[z, 8.4e-10], N[(z * x + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{b - y}\\
\mathbf{if}\;z \leq -1.75 \cdot 10^{-29}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 8.4 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(z, x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.7499999999999999e-29 or 8.3999999999999999e-10 < z Initial program 47.0%
Taylor expanded in t around inf
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6424.0
Simplified24.0%
Taylor expanded in z around inf
/-lowering-/.f64N/A
--lowering--.f6439.6
Simplified39.6%
if -1.7499999999999999e-29 < z < 8.3999999999999999e-10Initial program 85.0%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.1
Simplified98.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate--r+N/A
--lowering--.f64N/A
div-subN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6451.6
Simplified51.6%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6451.3
Simplified51.3%
(FPCore (x y z t a b) :precision binary64 (if (<= z -1.1e-15) (/ t b) (if (<= z 2.15e-10) (fma z x x) (/ t b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= -1.1e-15) {
tmp = t / b;
} else if (z <= 2.15e-10) {
tmp = fma(z, x, x);
} else {
tmp = t / b;
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (z <= -1.1e-15) tmp = Float64(t / b); elseif (z <= 2.15e-10) tmp = fma(z, x, x); else tmp = Float64(t / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -1.1e-15], N[(t / b), $MachinePrecision], If[LessEqual[z, 2.15e-10], N[(z * x + x), $MachinePrecision], N[(t / b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.1 \cdot 10^{-15}:\\
\;\;\;\;\frac{t}{b}\\
\mathbf{elif}\;z \leq 2.15 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(z, x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{b}\\
\end{array}
\end{array}
if z < -1.09999999999999993e-15 or 2.15000000000000007e-10 < z Initial program 45.7%
Taylor expanded in t around inf
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6424.5
Simplified24.5%
Taylor expanded in b around inf
/-lowering-/.f6427.9
Simplified27.9%
if -1.09999999999999993e-15 < z < 2.15000000000000007e-10Initial program 85.3%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6498.1
Simplified98.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate--r+N/A
--lowering--.f64N/A
div-subN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6451.9
Simplified51.9%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6450.3
Simplified50.3%
(FPCore (x y z t a b) :precision binary64 (fma z x x))
double code(double x, double y, double z, double t, double a, double b) {
return fma(z, x, x);
}
function code(x, y, z, t, a, b) return fma(z, x, x) end
code[x_, y_, z_, t_, a_, b_] := N[(z * x + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(z, x, x\right)
\end{array}
Initial program 67.4%
Taylor expanded in x around 0
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6476.6
Simplified76.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate--r+N/A
--lowering--.f64N/A
div-subN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6430.1
Simplified30.1%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6429.1
Simplified29.1%
(FPCore (x y z t a b) :precision binary64 x)
double code(double x, double y, double z, double t, double a, double b) {
return x;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x;
}
def code(x, y, z, t, a, b): return x
function code(x, y, z, t, a, b) return x end
function tmp = code(x, y, z, t, a, b) tmp = x; end
code[x_, y_, z_, t_, a_, b_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 67.4%
Taylor expanded in z around 0
Simplified28.9%
(FPCore (x y z t a b) :precision binary64 (- (/ (+ (* z t) (* y x)) (+ y (* z (- b y)))) (/ a (+ (- b y) (/ y z)))))
double code(double x, double y, double z, double t, double a, double b) {
return (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)));
}
def code(x, y, z, t, a, b): return (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)))
function code(x, y, z, t, a, b) return Float64(Float64(Float64(Float64(z * t) + Float64(y * x)) / Float64(y + Float64(z * Float64(b - y)))) - Float64(a / Float64(Float64(b - y) + Float64(y / z)))) end
function tmp = code(x, y, z, t, a, b) tmp = (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z))); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(N[(z * t), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a / N[(N[(b - y), $MachinePrecision] + N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{z \cdot t + y \cdot x}{y + z \cdot \left(b - y\right)} - \frac{a}{\left(b - y\right) + \frac{y}{z}}
\end{array}
herbie shell --seed 2024199
(FPCore (x y z t a b)
:name "Development.Shake.Progress:decay from shake-0.15.5"
:precision binary64
:alt
(! :herbie-platform default (- (/ (+ (* z t) (* y x)) (+ y (* z (- b y)))) (/ a (+ (- b y) (/ y z)))))
(/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))