
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
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
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
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
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (<= t_1 -1e-232)
t_1
(if (<= t_1 0.0)
(fma (/ (- t x) z) (- a y) t)
(fma (/ (- y z) (- a z)) (- t x) x)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if (t_1 <= -1e-232) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = fma(((t - x) / z), (a - y), t);
} else {
tmp = fma(((y - z) / (a - z)), (t - x), x);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) tmp = 0.0 if (t_1 <= -1e-232) tmp = t_1; elseif (t_1 <= 0.0) tmp = fma(Float64(Float64(t - x) / z), Float64(a - y), t); else tmp = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e-232], t$95$1, If[LessEqual[t$95$1, 0.0], N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * N[(a - y), $MachinePrecision] + t), $MachinePrecision], N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{-232}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(\frac{t - x}{z}, a - y, t\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -1.00000000000000002e-232Initial program 93.7%
if -1.00000000000000002e-232 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 0.0Initial program 3.8%
Taylor expanded in z around inf
+-commutativeN/A
associate--l+N/A
sub-negN/A
mul-1-negN/A
remove-double-negN/A
+-commutativeN/A
associate-+r+N/A
associate-/l*N/A
associate-/l*N/A
associate-*r*N/A
distribute-rgt-outN/A
accelerator-lowering-fma.f64N/A
Simplified94.6%
if 0.0 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 90.2%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6495.7
Applied egg-rr95.7%
Final simplification94.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t x) (- a z))) (t_2 (+ x (* (- y z) t_1))))
(if (<= t_2 -1e-252)
(+ x (* y t_1))
(if (<= t_2 5e-161)
(+ t (/ (* (- t x) (- a y)) z))
(if (<= t_2 4e+237)
(+ x (* (- y z) (/ t (- a z))))
(fma (/ y (- a z)) (- t x) x))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - x) / (a - z);
double t_2 = x + ((y - z) * t_1);
double tmp;
if (t_2 <= -1e-252) {
tmp = x + (y * t_1);
} else if (t_2 <= 5e-161) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_2 <= 4e+237) {
tmp = x + ((y - z) * (t / (a - z)));
} else {
tmp = fma((y / (a - z)), (t - x), x);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - x) / Float64(a - z)) t_2 = Float64(x + Float64(Float64(y - z) * t_1)) tmp = 0.0 if (t_2 <= -1e-252) tmp = Float64(x + Float64(y * t_1)); elseif (t_2 <= 5e-161) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); elseif (t_2 <= 4e+237) tmp = Float64(x + Float64(Float64(y - z) * Float64(t / Float64(a - z)))); else tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - z), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-252], N[(x + N[(y * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e-161], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 4e+237], N[(x + N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - x}{a - z}\\
t_2 := x + \left(y - z\right) \cdot t\_1\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{-252}:\\
\;\;\;\;x + y \cdot t\_1\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-161}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{elif}\;t\_2 \leq 4 \cdot 10^{+237}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -9.99999999999999943e-253Initial program 92.8%
Taylor expanded in y around inf
Simplified73.5%
if -9.99999999999999943e-253 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 4.9999999999999999e-161Initial program 10.6%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6426.7
Applied egg-rr26.7%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified84.6%
if 4.9999999999999999e-161 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 3.99999999999999976e237Initial program 98.1%
Taylor expanded in t around inf
/-lowering-/.f64N/A
--lowering--.f6489.0
Simplified89.0%
if 3.99999999999999976e237 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 89.8%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6496.6
Applied egg-rr96.6%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f6489.5
Simplified89.5%
Final simplification82.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t x) (- a z))) (t_2 (+ x (* (- y z) t_1))))
(if (<= t_2 -1e-232)
(+ x (* y t_1))
(if (<= t_2 5e-161)
(+ t (/ (* y (- x t)) z))
(if (<= t_2 4e+237)
(+ x (* (- y z) (/ t (- a z))))
(fma (/ y (- a z)) (- t x) x))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - x) / (a - z);
double t_2 = x + ((y - z) * t_1);
double tmp;
if (t_2 <= -1e-232) {
tmp = x + (y * t_1);
} else if (t_2 <= 5e-161) {
tmp = t + ((y * (x - t)) / z);
} else if (t_2 <= 4e+237) {
tmp = x + ((y - z) * (t / (a - z)));
} else {
tmp = fma((y / (a - z)), (t - x), x);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - x) / Float64(a - z)) t_2 = Float64(x + Float64(Float64(y - z) * t_1)) tmp = 0.0 if (t_2 <= -1e-232) tmp = Float64(x + Float64(y * t_1)); elseif (t_2 <= 5e-161) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (t_2 <= 4e+237) tmp = Float64(x + Float64(Float64(y - z) * Float64(t / Float64(a - z)))); else tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - z), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-232], N[(x + N[(y * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e-161], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 4e+237], N[(x + N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - x}{a - z}\\
t_2 := x + \left(y - z\right) \cdot t\_1\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{-232}:\\
\;\;\;\;x + y \cdot t\_1\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-161}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;t\_2 \leq 4 \cdot 10^{+237}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -1.00000000000000002e-232Initial program 93.7%
Taylor expanded in y around inf
Simplified74.2%
if -1.00000000000000002e-232 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 4.9999999999999999e-161Initial program 10.4%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6428.3
Applied egg-rr28.3%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified82.8%
Taylor expanded in a around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f6472.3
Simplified72.3%
if 4.9999999999999999e-161 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 3.99999999999999976e237Initial program 98.1%
Taylor expanded in t around inf
/-lowering-/.f64N/A
--lowering--.f6489.0
Simplified89.0%
if 3.99999999999999976e237 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 89.8%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6496.6
Applied egg-rr96.6%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f6489.5
Simplified89.5%
Final simplification80.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- y z) (- a z)) (- t x) x))
(t_2 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (<= t_2 -1e-252)
t_1
(if (<= t_2 0.0) (fma (/ (- t x) z) (- a y) t) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((y - z) / (a - z)), (t - x), x);
double t_2 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if (t_2 <= -1e-252) {
tmp = t_1;
} else if (t_2 <= 0.0) {
tmp = fma(((t - x) / z), (a - y), t);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x) t_2 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) tmp = 0.0 if (t_2 <= -1e-252) tmp = t_1; elseif (t_2 <= 0.0) tmp = fma(Float64(Float64(t - x) / z), Float64(a - y), t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-252], t$95$1, If[LessEqual[t$95$2, 0.0], N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * N[(a - y), $MachinePrecision] + t), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
t_2 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{-252}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(\frac{t - x}{z}, a - y, t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -9.99999999999999943e-253 or 0.0 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 91.4%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6494.1
Applied egg-rr94.1%
if -9.99999999999999943e-253 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 0.0Initial program 3.8%
Taylor expanded in z around inf
+-commutativeN/A
associate--l+N/A
sub-negN/A
mul-1-negN/A
remove-double-negN/A
+-commutativeN/A
associate-+r+N/A
associate-/l*N/A
associate-/l*N/A
associate-*r*N/A
distribute-rgt-outN/A
accelerator-lowering-fma.f64N/A
Simplified97.1%
Final simplification94.5%
(FPCore (x y z t a)
:precision binary64
(if (<= z -8e+80)
t
(if (<= z -7.8e+34)
(* x (/ y z))
(if (<= z 5.2e-96) (fma z (/ x a) x) (if (<= z 8.5) (* y (/ t a)) t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8e+80) {
tmp = t;
} else if (z <= -7.8e+34) {
tmp = x * (y / z);
} else if (z <= 5.2e-96) {
tmp = fma(z, (x / a), x);
} else if (z <= 8.5) {
tmp = y * (t / a);
} else {
tmp = t;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8e+80) tmp = t; elseif (z <= -7.8e+34) tmp = Float64(x * Float64(y / z)); elseif (z <= 5.2e-96) tmp = fma(z, Float64(x / a), x); elseif (z <= 8.5) tmp = Float64(y * Float64(t / a)); else tmp = t; end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8e+80], t, If[LessEqual[z, -7.8e+34], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.2e-96], N[(z * N[(x / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 8.5], N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision], t]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8 \cdot 10^{+80}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -7.8 \cdot 10^{+34}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{-96}:\\
\;\;\;\;\mathsf{fma}\left(z, \frac{x}{a}, x\right)\\
\mathbf{elif}\;z \leq 8.5:\\
\;\;\;\;y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8e80 or 8.5 < z Initial program 63.9%
Taylor expanded in z around inf
Simplified50.3%
if -8e80 < z < -7.80000000000000038e34Initial program 72.6%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
--lowering--.f6456.1
Simplified56.1%
Taylor expanded in y around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.0
Simplified62.0%
Taylor expanded in a around 0
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6447.6
Simplified47.6%
if -7.80000000000000038e34 < z < 5.2000000000000003e-96Initial program 94.9%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
--lowering--.f6457.7
Simplified57.7%
Taylor expanded in y around 0
mul-1-negN/A
neg-lowering-neg.f6438.0
Simplified38.0%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
associate-*r/N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6438.8
Simplified38.8%
if 5.2000000000000003e-96 < z < 8.5Initial program 90.4%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6463.4
Simplified63.4%
Taylor expanded in a around inf
Simplified47.4%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f6456.2
Applied egg-rr56.2%
Taylor expanded in y around inf
Simplified43.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ t a))))
(if (<= z -2.3e+44)
t
(if (<= z -1.52e-277) t_1 (if (<= z 2.5e-99) x (if (<= z 6.4) t_1 t))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * (t / a);
double tmp;
if (z <= -2.3e+44) {
tmp = t;
} else if (z <= -1.52e-277) {
tmp = t_1;
} else if (z <= 2.5e-99) {
tmp = x;
} else if (z <= 6.4) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = y * (t / a)
if (z <= (-2.3d+44)) then
tmp = t
else if (z <= (-1.52d-277)) then
tmp = t_1
else if (z <= 2.5d-99) then
tmp = x
else if (z <= 6.4d0) then
tmp = t_1
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * (t / a);
double tmp;
if (z <= -2.3e+44) {
tmp = t;
} else if (z <= -1.52e-277) {
tmp = t_1;
} else if (z <= 2.5e-99) {
tmp = x;
} else if (z <= 6.4) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * (t / a) tmp = 0 if z <= -2.3e+44: tmp = t elif z <= -1.52e-277: tmp = t_1 elif z <= 2.5e-99: tmp = x elif z <= 6.4: tmp = t_1 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(t / a)) tmp = 0.0 if (z <= -2.3e+44) tmp = t; elseif (z <= -1.52e-277) tmp = t_1; elseif (z <= 2.5e-99) tmp = x; elseif (z <= 6.4) tmp = t_1; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * (t / a); tmp = 0.0; if (z <= -2.3e+44) tmp = t; elseif (z <= -1.52e-277) tmp = t_1; elseif (z <= 2.5e-99) tmp = x; elseif (z <= 6.4) tmp = t_1; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.3e+44], t, If[LessEqual[z, -1.52e-277], t$95$1, If[LessEqual[z, 2.5e-99], x, If[LessEqual[z, 6.4], t$95$1, t]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t}{a}\\
\mathbf{if}\;z \leq -2.3 \cdot 10^{+44}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.52 \cdot 10^{-277}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{-99}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 6.4:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.30000000000000004e44 or 6.4000000000000004 < z Initial program 64.0%
Taylor expanded in z around inf
Simplified47.2%
if -2.30000000000000004e44 < z < -1.5199999999999999e-277 or 2.49999999999999985e-99 < z < 6.4000000000000004Initial program 94.1%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6444.9
Simplified44.9%
Taylor expanded in a around inf
Simplified32.4%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f6439.9
Applied egg-rr39.9%
Taylor expanded in y around inf
Simplified35.5%
if -1.5199999999999999e-277 < z < 2.49999999999999985e-99Initial program 94.6%
Taylor expanded in a around inf
Simplified49.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- t x) z) (- a y) t)))
(if (<= z -5.6e+42)
t_1
(if (<= z 8e+58) (+ x (* y (/ (- t x) (- a z)))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((t - x) / z), (a - y), t);
double tmp;
if (z <= -5.6e+42) {
tmp = t_1;
} else if (z <= 8e+58) {
tmp = x + (y * ((t - x) / (a - z)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(t - x) / z), Float64(a - y), t) tmp = 0.0 if (z <= -5.6e+42) tmp = t_1; elseif (z <= 8e+58) tmp = Float64(x + Float64(y * Float64(Float64(t - x) / Float64(a - z)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * N[(a - y), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -5.6e+42], t$95$1, If[LessEqual[z, 8e+58], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{t - x}{z}, a - y, t\right)\\
\mathbf{if}\;z \leq -5.6 \cdot 10^{+42}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 8 \cdot 10^{+58}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.5999999999999999e42 or 7.99999999999999955e58 < z Initial program 60.8%
Taylor expanded in z around inf
+-commutativeN/A
associate--l+N/A
sub-negN/A
mul-1-negN/A
remove-double-negN/A
+-commutativeN/A
associate-+r+N/A
associate-/l*N/A
associate-/l*N/A
associate-*r*N/A
distribute-rgt-outN/A
accelerator-lowering-fma.f64N/A
Simplified78.9%
if -5.5999999999999999e42 < z < 7.99999999999999955e58Initial program 94.1%
Taylor expanded in y around inf
Simplified87.2%
Final simplification83.7%
(FPCore (x y z t a)
:precision binary64
(if (<= z -5.8e+78)
(fma a (/ (- t x) z) t)
(if (<= z 3.5e+59)
(+ x (* y (/ (- t x) (- a z))))
(+ t (/ (* y (- x t)) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.8e+78) {
tmp = fma(a, ((t - x) / z), t);
} else if (z <= 3.5e+59) {
tmp = x + (y * ((t - x) / (a - z)));
} else {
tmp = t + ((y * (x - t)) / z);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5.8e+78) tmp = fma(a, Float64(Float64(t - x) / z), t); elseif (z <= 3.5e+59) tmp = Float64(x + Float64(y * Float64(Float64(t - x) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.8e+78], N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 3.5e+59], N[(x + N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.8 \cdot 10^{+78}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{elif}\;z \leq 3.5 \cdot 10^{+59}:\\
\;\;\;\;x + y \cdot \frac{t - x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\end{array}
\end{array}
if z < -5.80000000000000034e78Initial program 57.2%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6465.5
Applied egg-rr65.5%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified68.8%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6464.3
Simplified64.3%
if -5.80000000000000034e78 < z < 3.5e59Initial program 92.2%
Taylor expanded in y around inf
Simplified84.6%
if 3.5e59 < z Initial program 64.1%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6469.1
Applied egg-rr69.1%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified74.8%
Taylor expanded in a around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f6472.2
Simplified72.2%
Final simplification78.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.7e+79)
(fma a (/ (- t x) z) t)
(if (<= z 3.35e+59)
(fma (/ y (- a z)) (- t x) x)
(+ t (/ (* y (- x t)) z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.7e+79) {
tmp = fma(a, ((t - x) / z), t);
} else if (z <= 3.35e+59) {
tmp = fma((y / (a - z)), (t - x), x);
} else {
tmp = t + ((y * (x - t)) / z);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.7e+79) tmp = fma(a, Float64(Float64(t - x) / z), t); elseif (z <= 3.35e+59) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); else tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.7e+79], N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 3.35e+59], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.7 \cdot 10^{+79}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{elif}\;z \leq 3.35 \cdot 10^{+59}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\end{array}
\end{array}
if z < -1.70000000000000016e79Initial program 57.2%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6465.5
Applied egg-rr65.5%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified68.8%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6464.3
Simplified64.3%
if -1.70000000000000016e79 < z < 3.3500000000000002e59Initial program 92.2%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6492.2
Applied egg-rr92.2%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f6483.7
Simplified83.7%
if 3.3500000000000002e59 < z Initial program 64.1%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6469.1
Applied egg-rr69.1%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified74.8%
Taylor expanded in a around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f6472.2
Simplified72.2%
Final simplification77.9%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma (- y z) (/ (- t x) a) x))) (if (<= a -7e-19) t_1 (if (<= a 450.0) (+ t (/ (* y (- x t)) z)) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((y - z), ((t - x) / a), x);
double tmp;
if (a <= -7e-19) {
tmp = t_1;
} else if (a <= 450.0) {
tmp = t + ((y * (x - t)) / z);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(y - z), Float64(Float64(t - x) / a), x) tmp = 0.0 if (a <= -7e-19) tmp = t_1; elseif (a <= 450.0) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -7e-19], t$95$1, If[LessEqual[a, 450.0], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y - z, \frac{t - x}{a}, x\right)\\
\mathbf{if}\;a \leq -7 \cdot 10^{-19}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 450:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -7.00000000000000031e-19 or 450 < a Initial program 87.4%
Taylor expanded in a around inf
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f6476.7
Simplified76.7%
if -7.00000000000000031e-19 < a < 450Initial program 72.9%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6474.7
Applied egg-rr74.7%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified73.4%
Taylor expanded in a around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f6470.3
Simplified70.3%
Final simplification73.5%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma (/ y a) (- t x) x))) (if (<= a -5e-21) t_1 (if (<= a 260000.0) (+ t (/ (* y (- x t)) z)) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((y / a), (t - x), x);
double tmp;
if (a <= -5e-21) {
tmp = t_1;
} else if (a <= 260000.0) {
tmp = t + ((y * (x - t)) / z);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(y / a), Float64(t - x), x) tmp = 0.0 if (a <= -5e-21) tmp = t_1; elseif (a <= 260000.0) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -5e-21], t$95$1, If[LessEqual[a, 260000.0], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{if}\;a \leq -5 \cdot 10^{-21}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 260000:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -4.99999999999999973e-21 or 2.6e5 < a Initial program 86.8%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6490.7
Applied egg-rr90.7%
Taylor expanded in z around 0
/-lowering-/.f6471.9
Simplified71.9%
if -4.99999999999999973e-21 < a < 2.6e5Initial program 73.4%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6474.5
Applied egg-rr74.5%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified73.9%
Taylor expanded in a around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f6470.7
Simplified70.7%
Final simplification71.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -4.6e+78) (fma a (/ (- t x) z) t) (if (<= z 2.5e-101) (fma (/ y a) (- t x) x) (* (- y z) (/ t (- a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.6e+78) {
tmp = fma(a, ((t - x) / z), t);
} else if (z <= 2.5e-101) {
tmp = fma((y / a), (t - x), x);
} else {
tmp = (y - z) * (t / (a - z));
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.6e+78) tmp = fma(a, Float64(Float64(t - x) / z), t); elseif (z <= 2.5e-101) tmp = fma(Float64(y / a), Float64(t - x), x); else tmp = Float64(Float64(y - z) * Float64(t / Float64(a - z))); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.6e+78], N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 2.5e-101], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.6 \cdot 10^{+78}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{-101}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a - z}\\
\end{array}
\end{array}
if z < -4.6000000000000004e78Initial program 57.2%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6465.5
Applied egg-rr65.5%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified68.8%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6464.3
Simplified64.3%
if -4.6000000000000004e78 < z < 2.5e-101Initial program 92.4%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6493.1
Applied egg-rr93.1%
Taylor expanded in z around 0
/-lowering-/.f6474.7
Simplified74.7%
if 2.5e-101 < z Initial program 75.0%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6452.7
Simplified52.7%
associate-/l*N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f6462.1
Applied egg-rr62.1%
Final simplification68.5%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.26e+79) (fma a (/ (- t x) z) t) (if (<= z 8e+83) (fma (/ y a) (- t x) x) (* t (/ z (- z a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.26e+79) {
tmp = fma(a, ((t - x) / z), t);
} else if (z <= 8e+83) {
tmp = fma((y / a), (t - x), x);
} else {
tmp = t * (z / (z - a));
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.26e+79) tmp = fma(a, Float64(Float64(t - x) / z), t); elseif (z <= 8e+83) tmp = fma(Float64(y / a), Float64(t - x), x); else tmp = Float64(t * Float64(z / Float64(z - a))); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.26e+79], N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 8e+83], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.26 \cdot 10^{+79}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{elif}\;z \leq 8 \cdot 10^{+83}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{z}{z - a}\\
\end{array}
\end{array}
if z < -1.26e79Initial program 57.2%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6465.5
Applied egg-rr65.5%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified68.8%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6464.3
Simplified64.3%
if -1.26e79 < z < 8.00000000000000025e83Initial program 90.8%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6490.8
Applied egg-rr90.8%
Taylor expanded in z around 0
/-lowering-/.f6468.3
Simplified68.3%
if 8.00000000000000025e83 < z Initial program 64.2%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6444.0
Simplified44.0%
Taylor expanded in y around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.2
Simplified62.2%
Final simplification66.5%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma a (/ (- t x) z) t))) (if (<= z -1.7e+78) t_1 (if (<= z 1.55e+83) (fma (/ y a) (- t x) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(a, ((t - x) / z), t);
double tmp;
if (z <= -1.7e+78) {
tmp = t_1;
} else if (z <= 1.55e+83) {
tmp = fma((y / a), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(a, Float64(Float64(t - x) / z), t) tmp = 0.0 if (z <= -1.7e+78) tmp = t_1; elseif (z <= 1.55e+83) tmp = fma(Float64(y / a), Float64(t - x), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -1.7e+78], t$95$1, If[LessEqual[z, 1.55e+83], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{if}\;z \leq -1.7 \cdot 10^{+78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{+83}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.70000000000000004e78 or 1.54999999999999996e83 < z Initial program 60.0%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6467.1
Applied egg-rr67.1%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified72.0%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.5
Simplified62.5%
if -1.70000000000000004e78 < z < 1.54999999999999996e83Initial program 91.3%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6491.3
Applied egg-rr91.3%
Taylor expanded in z around 0
/-lowering-/.f6468.7
Simplified68.7%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma a (/ (- t x) z) t))) (if (<= z -2e+78) t_1 (if (<= z 1.8e+83) (fma y (/ (- t x) a) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(a, ((t - x) / z), t);
double tmp;
if (z <= -2e+78) {
tmp = t_1;
} else if (z <= 1.8e+83) {
tmp = fma(y, ((t - x) / a), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(a, Float64(Float64(t - x) / z), t) tmp = 0.0 if (z <= -2e+78) tmp = t_1; elseif (z <= 1.8e+83) tmp = fma(y, Float64(Float64(t - x) / a), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -2e+78], t$95$1, If[LessEqual[z, 1.8e+83], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{if}\;z \leq -2 \cdot 10^{+78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.8 \cdot 10^{+83}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.00000000000000002e78 or 1.7999999999999999e83 < z Initial program 60.0%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6467.1
Applied egg-rr67.1%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified72.0%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.5
Simplified62.5%
if -2.00000000000000002e78 < z < 1.7999999999999999e83Initial program 91.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6468.4
Simplified68.4%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma a (/ (- t x) z) t))) (if (<= z -1.3e+48) t_1 (if (<= z 1.7e+83) (fma (/ y a) t x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(a, ((t - x) / z), t);
double tmp;
if (z <= -1.3e+48) {
tmp = t_1;
} else if (z <= 1.7e+83) {
tmp = fma((y / a), t, x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(a, Float64(Float64(t - x) / z), t) tmp = 0.0 if (z <= -1.3e+48) tmp = t_1; elseif (z <= 1.7e+83) tmp = fma(Float64(y / a), t, x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -1.3e+48], t$95$1, If[LessEqual[z, 1.7e+83], N[(N[(y / a), $MachinePrecision] * t + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{if}\;z \leq -1.3 \cdot 10^{+48}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{+83}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.29999999999999998e48 or 1.6999999999999999e83 < z Initial program 60.2%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6467.1
Applied egg-rr67.1%
Taylor expanded in z around inf
associate--l+N/A
associate-*r/N/A
associate-*r/N/A
mul-1-negN/A
div-subN/A
mul-1-negN/A
distribute-lft-out--N/A
associate-*r/N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified71.2%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6458.8
Simplified58.8%
if -1.29999999999999998e48 < z < 1.6999999999999999e83Initial program 92.6%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6492.4
Applied egg-rr92.4%
Taylor expanded in z around 0
/-lowering-/.f6470.1
Simplified70.1%
Taylor expanded in t around inf
Simplified60.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.3e+78) t (if (<= z 1.6e+88) (fma (/ y a) t x) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.3e+78) {
tmp = t;
} else if (z <= 1.6e+88) {
tmp = fma((y / a), t, x);
} else {
tmp = t;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.3e+78) tmp = t; elseif (z <= 1.6e+88) tmp = fma(Float64(y / a), t, x); else tmp = t; end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.3e+78], t, If[LessEqual[z, 1.6e+88], N[(N[(y / a), $MachinePrecision] * t + x), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.3 \cdot 10^{+78}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.6 \cdot 10^{+88}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.3e78 or 1.5999999999999999e88 < z Initial program 60.8%
Taylor expanded in z around inf
Simplified55.9%
if -1.3e78 < z < 1.5999999999999999e88Initial program 90.3%
+-commutativeN/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
flip3--N/A
clear-numN/A
clear-numN/A
flip3--N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
--lowering--.f6490.3
Applied egg-rr90.3%
Taylor expanded in z around 0
/-lowering-/.f6468.1
Simplified68.1%
Taylor expanded in t around inf
Simplified57.6%
(FPCore (x y z t a) :precision binary64 (if (<= z -5.4e+81) t (if (<= z -7.5e+34) (* x (/ y z)) (if (<= z 3.1e+59) x t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.4e+81) {
tmp = t;
} else if (z <= -7.5e+34) {
tmp = x * (y / z);
} else if (z <= 3.1e+59) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (z <= (-5.4d+81)) then
tmp = t
else if (z <= (-7.5d+34)) then
tmp = x * (y / z)
else if (z <= 3.1d+59) then
tmp = x
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.4e+81) {
tmp = t;
} else if (z <= -7.5e+34) {
tmp = x * (y / z);
} else if (z <= 3.1e+59) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -5.4e+81: tmp = t elif z <= -7.5e+34: tmp = x * (y / z) elif z <= 3.1e+59: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5.4e+81) tmp = t; elseif (z <= -7.5e+34) tmp = Float64(x * Float64(y / z)); elseif (z <= 3.1e+59) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -5.4e+81) tmp = t; elseif (z <= -7.5e+34) tmp = x * (y / z); elseif (z <= 3.1e+59) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.4e+81], t, If[LessEqual[z, -7.5e+34], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.1e+59], x, t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.4 \cdot 10^{+81}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -7.5 \cdot 10^{+34}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{+59}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -5.3999999999999999e81 or 3.10000000000000015e59 < z Initial program 60.5%
Taylor expanded in z around inf
Simplified55.0%
if -5.3999999999999999e81 < z < -7.49999999999999976e34Initial program 72.6%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
--lowering--.f6456.1
Simplified56.1%
Taylor expanded in y around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.0
Simplified62.0%
Taylor expanded in a around 0
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6447.6
Simplified47.6%
if -7.49999999999999976e34 < z < 3.10000000000000015e59Initial program 94.0%
Taylor expanded in a around inf
Simplified31.3%
(FPCore (x y z t a) :precision binary64 (if (<= a -1.75e+90) x (if (<= a 3e+71) t x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.75e+90) {
tmp = x;
} else if (a <= 3e+71) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-1.75d+90)) then
tmp = x
else if (a <= 3d+71) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.75e+90) {
tmp = x;
} else if (a <= 3e+71) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.75e+90: tmp = x elif a <= 3e+71: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.75e+90) tmp = x; elseif (a <= 3e+71) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.75e+90) tmp = x; elseif (a <= 3e+71) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.75e+90], x, If[LessEqual[a, 3e+71], t, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.75 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 3 \cdot 10^{+71}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.7499999999999999e90 or 3.00000000000000013e71 < a Initial program 92.0%
Taylor expanded in a around inf
Simplified48.5%
if -1.7499999999999999e90 < a < 3.00000000000000013e71Initial program 74.4%
Taylor expanded in z around inf
Simplified35.0%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
real(8) function code(x, y, z, t, a)
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
code = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 80.1%
Taylor expanded in z around inf
Simplified26.0%
(FPCore (x y z t a) :precision binary64 0.0)
double code(double x, double y, double z, double t, double a) {
return 0.0;
}
real(8) function code(x, y, z, t, a)
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
code = 0.0d0
end function
public static double code(double x, double y, double z, double t, double a) {
return 0.0;
}
def code(x, y, z, t, a): return 0.0
function code(x, y, z, t, a) return 0.0 end
function tmp = code(x, y, z, t, a) tmp = 0.0; end
code[x_, y_, z_, t_, a_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 80.1%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
--lowering--.f64N/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
--lowering--.f6439.6
Simplified39.6%
Taylor expanded in z around inf
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lft2.8
Simplified2.8%
herbie shell --seed 2024199
(FPCore (x y z t a)
:name "Numeric.Signal:interpolate from hsignal-0.2.7.1"
:precision binary64
(+ x (* (- y z) (/ (- t x) (- a z)))))