
(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 16 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 (fma (/ (- y z) (- a z)) (- t x) x))
(t_2 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (<= t_2 -1e-261)
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-261) {
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-261) 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-261], 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^{-261}:\\
\;\;\;\;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.99999999999999984e-262 or 0.0 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 92.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--.f6495.7
Applied egg-rr95.7%
if -9.99999999999999984e-262 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 0.0Initial program 3.5%
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
Simplified99.7%
Final simplification96.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- y z) (/ t (- a z)))) (t_2 (fma (/ (- t x) z) a t)))
(if (<= z -8e+141)
t_2
(if (<= z -1.15e+52)
t_1
(if (<= z -2.3e-151)
(/ (* y (- t x)) (- a z))
(if (<= z 1.8e-19)
(fma (/ y a) (- t x) x)
(if (<= z 7.2e+170) t_1 t_2)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / (a - z));
double t_2 = fma(((t - x) / z), a, t);
double tmp;
if (z <= -8e+141) {
tmp = t_2;
} else if (z <= -1.15e+52) {
tmp = t_1;
} else if (z <= -2.3e-151) {
tmp = (y * (t - x)) / (a - z);
} else if (z <= 1.8e-19) {
tmp = fma((y / a), (t - x), x);
} else if (z <= 7.2e+170) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(y - z) * Float64(t / Float64(a - z))) t_2 = fma(Float64(Float64(t - x) / z), a, t) tmp = 0.0 if (z <= -8e+141) tmp = t_2; elseif (z <= -1.15e+52) tmp = t_1; elseif (z <= -2.3e-151) tmp = Float64(Float64(y * Float64(t - x)) / Float64(a - z)); elseif (z <= 1.8e-19) tmp = fma(Float64(y / a), Float64(t - x), x); elseif (z <= 7.2e+170) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * a + t), $MachinePrecision]}, If[LessEqual[z, -8e+141], t$95$2, If[LessEqual[z, -1.15e+52], t$95$1, If[LessEqual[z, -2.3e-151], N[(N[(y * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.8e-19], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 7.2e+170], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{t}{a - z}\\
t_2 := \mathsf{fma}\left(\frac{t - x}{z}, a, t\right)\\
\mathbf{if}\;z \leq -8 \cdot 10^{+141}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -1.15 \cdot 10^{+52}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -2.3 \cdot 10^{-151}:\\
\;\;\;\;\frac{y \cdot \left(t - x\right)}{a - z}\\
\mathbf{elif}\;z \leq 1.8 \cdot 10^{-19}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{elif}\;z \leq 7.2 \cdot 10^{+170}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -8.00000000000000014e141 or 7.1999999999999999e170 < z Initial program 47.2%
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
Simplified87.4%
Taylor expanded in y around 0
Simplified71.5%
if -8.00000000000000014e141 < z < -1.15e52 or 1.8000000000000001e-19 < z < 7.1999999999999999e170Initial program 86.8%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6452.9
Simplified52.9%
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--.f6467.7
Applied egg-rr67.7%
if -1.15e52 < z < -2.29999999999999996e-151Initial program 87.9%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6462.8
Simplified62.8%
if -2.29999999999999996e-151 < z < 1.8000000000000001e-19Initial program 93.7%
+-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--.f6497.8
Applied egg-rr97.8%
Taylor expanded in z around 0
/-lowering-/.f6482.5
Simplified82.5%
Final simplification73.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- y z) (/ t (- a z)))) (t_2 (fma (/ (- t x) z) a t)))
(if (<= z -2.3e+141)
t_2
(if (<= z -1.4e-73)
t_1
(if (<= z 1.75e-19)
(fma (/ y a) (- t x) x)
(if (<= z 3.9e+170) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / (a - z));
double t_2 = fma(((t - x) / z), a, t);
double tmp;
if (z <= -2.3e+141) {
tmp = t_2;
} else if (z <= -1.4e-73) {
tmp = t_1;
} else if (z <= 1.75e-19) {
tmp = fma((y / a), (t - x), x);
} else if (z <= 3.9e+170) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(y - z) * Float64(t / Float64(a - z))) t_2 = fma(Float64(Float64(t - x) / z), a, t) tmp = 0.0 if (z <= -2.3e+141) tmp = t_2; elseif (z <= -1.4e-73) tmp = t_1; elseif (z <= 1.75e-19) tmp = fma(Float64(y / a), Float64(t - x), x); elseif (z <= 3.9e+170) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * a + t), $MachinePrecision]}, If[LessEqual[z, -2.3e+141], t$95$2, If[LessEqual[z, -1.4e-73], t$95$1, If[LessEqual[z, 1.75e-19], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 3.9e+170], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{t}{a - z}\\
t_2 := \mathsf{fma}\left(\frac{t - x}{z}, a, t\right)\\
\mathbf{if}\;z \leq -2.3 \cdot 10^{+141}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -1.4 \cdot 10^{-73}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.75 \cdot 10^{-19}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{elif}\;z \leq 3.9 \cdot 10^{+170}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -2.3000000000000002e141 or 3.9000000000000002e170 < z Initial program 47.2%
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
Simplified87.4%
Taylor expanded in y around 0
Simplified71.5%
if -2.3000000000000002e141 < z < -1.40000000000000006e-73 or 1.75000000000000008e-19 < z < 3.9000000000000002e170Initial program 88.3%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6450.0
Simplified50.0%
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--.f6460.5
Applied egg-rr60.5%
if -1.40000000000000006e-73 < z < 1.75000000000000008e-19Initial program 91.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--.f6495.5
Applied egg-rr95.5%
Taylor expanded in z around 0
/-lowering-/.f6478.0
Simplified78.0%
Final simplification70.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- t x) z) (- a y) t)))
(if (<= z -1.7e+76)
t_1
(if (<= z 7.3e-62)
(fma (/ y (- a z)) (- t x) x)
(if (<= z 7e+167) (+ x (* (- y z) (/ t (- 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 <= -1.7e+76) {
tmp = t_1;
} else if (z <= 7.3e-62) {
tmp = fma((y / (a - z)), (t - x), x);
} else if (z <= 7e+167) {
tmp = x + ((y - z) * (t / (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 <= -1.7e+76) tmp = t_1; elseif (z <= 7.3e-62) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); elseif (z <= 7e+167) tmp = Float64(x + Float64(Float64(y - z) * Float64(t / 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, -1.7e+76], t$95$1, If[LessEqual[z, 7.3e-62], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 7e+167], N[(x + N[(N[(y - z), $MachinePrecision] * N[(t / 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 -1.7 \cdot 10^{+76}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 7.3 \cdot 10^{-62}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{elif}\;z \leq 7 \cdot 10^{+167}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.6999999999999999e76 or 6.99999999999999975e167 < z Initial program 54.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
Simplified85.7%
if -1.6999999999999999e76 < z < 7.2999999999999998e-62Initial program 91.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--.f6493.7
Applied egg-rr93.7%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f6482.8
Simplified82.8%
if 7.2999999999999998e-62 < z < 6.99999999999999975e167Initial program 86.2%
Taylor expanded in t around inf
/-lowering-/.f64N/A
--lowering--.f6478.7
Simplified78.7%
Final simplification82.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- a y) z) (- t x) t)))
(if (<= z -6e+72)
t_1
(if (<= z 2.15e-61)
(fma (/ y (- a z)) (- t x) x)
(if (<= z 2.9e+159) (+ x (* (- y z) (/ t (- a z)))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((a - y) / z), (t - x), t);
double tmp;
if (z <= -6e+72) {
tmp = t_1;
} else if (z <= 2.15e-61) {
tmp = fma((y / (a - z)), (t - x), x);
} else if (z <= 2.9e+159) {
tmp = x + ((y - z) * (t / (a - z)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(a - y) / z), Float64(t - x), t) tmp = 0.0 if (z <= -6e+72) tmp = t_1; elseif (z <= 2.15e-61) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); elseif (z <= 2.9e+159) tmp = Float64(x + Float64(Float64(y - z) * Float64(t / Float64(a - z)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] * N[(t - x), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -6e+72], t$95$1, If[LessEqual[z, 2.15e-61], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 2.9e+159], N[(x + N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{a - y}{z}, t - x, t\right)\\
\mathbf{if}\;z \leq -6 \cdot 10^{+72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2.15 \cdot 10^{-61}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{elif}\;z \leq 2.9 \cdot 10^{+159}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -6.00000000000000006e72 or 2.90000000000000014e159 < z Initial program 54.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
Simplified85.7%
Taylor expanded in t around 0
associate--l+N/A
div-subN/A
distribute-lft-inN/A
*-rgt-identityN/A
associate-/l*N/A
+-commutativeN/A
associate-+l+N/A
associate-/l*N/A
associate-*r*N/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-outN/A
+-commutativeN/A
sub-negN/A
accelerator-lowering-fma.f64N/A
Simplified84.3%
if -6.00000000000000006e72 < z < 2.1500000000000002e-61Initial program 91.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--.f6493.7
Applied egg-rr93.7%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f6482.8
Simplified82.8%
if 2.1500000000000002e-61 < z < 2.90000000000000014e159Initial program 86.2%
Taylor expanded in t around inf
/-lowering-/.f64N/A
--lowering--.f6478.7
Simplified78.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- a y) z) (- t x) t)))
(if (<= z -1.7e+73)
t_1
(if (<= z 190.0) (fma (/ y (- a z)) (- t x) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((a - y) / z), (t - x), t);
double tmp;
if (z <= -1.7e+73) {
tmp = t_1;
} else if (z <= 190.0) {
tmp = fma((y / (a - z)), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(a - y) / z), Float64(t - x), t) tmp = 0.0 if (z <= -1.7e+73) tmp = t_1; elseif (z <= 190.0) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] * N[(t - x), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -1.7e+73], t$95$1, If[LessEqual[z, 190.0], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{a - y}{z}, t - x, t\right)\\
\mathbf{if}\;z \leq -1.7 \cdot 10^{+73}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 190:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.7000000000000001e73 or 190 < z Initial program 62.4%
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
Simplified81.1%
Taylor expanded in t around 0
associate--l+N/A
div-subN/A
distribute-lft-inN/A
*-rgt-identityN/A
associate-/l*N/A
+-commutativeN/A
associate-+l+N/A
associate-/l*N/A
associate-*r*N/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-outN/A
+-commutativeN/A
sub-negN/A
accelerator-lowering-fma.f64N/A
Simplified80.1%
if -1.7000000000000001e73 < z < 190Initial program 92.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--.f6493.2
Applied egg-rr93.2%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f6480.4
Simplified80.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- t x) z) (- y) t)))
(if (<= z -1.9e+72)
t_1
(if (<= z 4.4e-8) (fma (/ y (- a z)) (- t x) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((t - x) / z), -y, t);
double tmp;
if (z <= -1.9e+72) {
tmp = t_1;
} else if (z <= 4.4e-8) {
tmp = fma((y / (a - z)), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(t - x) / z), Float64(-y), t) tmp = 0.0 if (z <= -1.9e+72) tmp = t_1; elseif (z <= 4.4e-8) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); 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] * (-y) + t), $MachinePrecision]}, If[LessEqual[z, -1.9e+72], t$95$1, If[LessEqual[z, 4.4e-8], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{t - x}{z}, -y, t\right)\\
\mathbf{if}\;z \leq -1.9 \cdot 10^{+72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 4.4 \cdot 10^{-8}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.90000000000000003e72 or 4.3999999999999997e-8 < z Initial program 64.7%
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
Simplified79.7%
Taylor expanded in y around inf
mul-1-negN/A
neg-lowering-neg.f6468.6
Simplified68.6%
if -1.90000000000000003e72 < z < 4.3999999999999997e-8Initial program 91.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--.f6493.5
Applied egg-rr93.5%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f6482.1
Simplified82.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (- y z) (/ (- t x) a) x)))
(if (<= a -4400.0)
t_1
(if (<= a 3.2e-52) (fma (/ (- t x) z) (- y) t) 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 <= -4400.0) {
tmp = t_1;
} else if (a <= 3.2e-52) {
tmp = fma(((t - x) / z), -y, t);
} 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 <= -4400.0) tmp = t_1; elseif (a <= 3.2e-52) tmp = fma(Float64(Float64(t - x) / z), Float64(-y), t); 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, -4400.0], t$95$1, If[LessEqual[a, 3.2e-52], N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * (-y) + t), $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 -4400:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{-52}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t - x}{z}, -y, t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -4400 or 3.2000000000000001e-52 < a Initial program 86.5%
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--.f6472.4
Simplified72.4%
if -4400 < a < 3.2000000000000001e-52Initial program 72.6%
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
Simplified81.6%
Taylor expanded in y around inf
mul-1-negN/A
neg-lowering-neg.f6477.6
Simplified77.6%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma t (/ (- y z) a) x))) (if (<= a -195.0) t_1 (if (<= a 3.2e-52) (fma (/ (- t x) z) (- y) t) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(t, ((y - z) / a), x);
double tmp;
if (a <= -195.0) {
tmp = t_1;
} else if (a <= 3.2e-52) {
tmp = fma(((t - x) / z), -y, t);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(t, Float64(Float64(y - z) / a), x) tmp = 0.0 if (a <= -195.0) tmp = t_1; elseif (a <= 3.2e-52) tmp = fma(Float64(Float64(t - x) / z), Float64(-y), t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -195.0], t$95$1, If[LessEqual[a, 3.2e-52], N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * (-y) + t), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t, \frac{y - z}{a}, x\right)\\
\mathbf{if}\;a \leq -195:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{-52}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t - x}{z}, -y, t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -195 or 3.2000000000000001e-52 < a Initial program 86.5%
Taylor expanded in t around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6460.4
Simplified60.4%
Taylor expanded in a around inf
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6465.8
Simplified65.8%
if -195 < a < 3.2000000000000001e-52Initial program 72.6%
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
Simplified81.6%
Taylor expanded in y around inf
mul-1-negN/A
neg-lowering-neg.f6477.6
Simplified77.6%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma (/ (- t x) z) a t))) (if (<= z -6.4e+85) t_1 (if (<= z 1.1e+64) (fma (/ y a) (- t x) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((t - x) / z), a, t);
double tmp;
if (z <= -6.4e+85) {
tmp = t_1;
} else if (z <= 1.1e+64) {
tmp = fma((y / a), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(t - x) / z), a, t) tmp = 0.0 if (z <= -6.4e+85) tmp = t_1; elseif (z <= 1.1e+64) 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[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * a + t), $MachinePrecision]}, If[LessEqual[z, -6.4e+85], t$95$1, If[LessEqual[z, 1.1e+64], 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(\frac{t - x}{z}, a, t\right)\\
\mathbf{if}\;z \leq -6.4 \cdot 10^{+85}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+64}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -6.40000000000000037e85 or 1.10000000000000001e64 < z Initial program 60.9%
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
Simplified82.3%
Taylor expanded in y around 0
Simplified62.4%
if -6.40000000000000037e85 < z < 1.10000000000000001e64Initial program 91.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.4
Applied egg-rr92.4%
Taylor expanded in z around 0
/-lowering-/.f6464.9
Simplified64.9%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma t (/ (- y z) a) x))) (if (<= a -64.0) t_1 (if (<= a 7e-36) (fma t (/ (- a y) z) t) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(t, ((y - z) / a), x);
double tmp;
if (a <= -64.0) {
tmp = t_1;
} else if (a <= 7e-36) {
tmp = fma(t, ((a - y) / z), t);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(t, Float64(Float64(y - z) / a), x) tmp = 0.0 if (a <= -64.0) tmp = t_1; elseif (a <= 7e-36) tmp = fma(t, Float64(Float64(a - y) / z), t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -64.0], t$95$1, If[LessEqual[a, 7e-36], N[(t * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t, \frac{y - z}{a}, x\right)\\
\mathbf{if}\;a \leq -64:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 7 \cdot 10^{-36}:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{a - y}{z}, t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -64 or 6.9999999999999999e-36 < a Initial program 86.4%
Taylor expanded in t around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6460.9
Simplified60.9%
Taylor expanded in a around inf
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6466.3
Simplified66.3%
if -64 < a < 6.9999999999999999e-36Initial program 72.8%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6451.9
Simplified51.9%
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--.f6453.2
Applied egg-rr53.2%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
mul-1-negN/A
sub-negN/A
distribute-neg-outN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
associate-/l*N/A
Simplified55.9%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma t (/ y a) x))) (if (<= a -5500.0) t_1 (if (<= a 6.9e-40) (fma t (/ (- a y) z) t) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(t, (y / a), x);
double tmp;
if (a <= -5500.0) {
tmp = t_1;
} else if (a <= 6.9e-40) {
tmp = fma(t, ((a - y) / z), t);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(t, Float64(y / a), x) tmp = 0.0 if (a <= -5500.0) tmp = t_1; elseif (a <= 6.9e-40) tmp = fma(t, Float64(Float64(a - y) / z), t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(y / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -5500.0], t$95$1, If[LessEqual[a, 6.9e-40], N[(t * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t, \frac{y}{a}, x\right)\\
\mathbf{if}\;a \leq -5500:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 6.9 \cdot 10^{-40}:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{a - y}{z}, t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -5500 or 6.8999999999999996e-40 < a Initial program 86.4%
Taylor expanded in t around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6460.9
Simplified60.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6456.7
Simplified56.7%
if -5500 < a < 6.8999999999999996e-40Initial program 72.8%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6451.9
Simplified51.9%
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--.f6453.2
Applied egg-rr53.2%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
mul-1-negN/A
sub-negN/A
distribute-neg-outN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
associate-/l*N/A
Simplified55.9%
(FPCore (x y z t a) :precision binary64 (if (<= z -4e+76) t (if (<= z 1.02e+64) (fma t (/ y a) x) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4e+76) {
tmp = t;
} else if (z <= 1.02e+64) {
tmp = fma(t, (y / a), x);
} else {
tmp = t;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4e+76) tmp = t; elseif (z <= 1.02e+64) tmp = fma(t, Float64(y / a), x); else tmp = t; end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4e+76], t, If[LessEqual[z, 1.02e+64], N[(t * N[(y / a), $MachinePrecision] + x), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4 \cdot 10^{+76}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.02 \cdot 10^{+64}:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{y}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -4.0000000000000002e76 or 1.01999999999999996e64 < z Initial program 60.9%
Taylor expanded in z around inf
Simplified50.1%
if -4.0000000000000002e76 < z < 1.01999999999999996e64Initial program 91.2%
Taylor expanded in t around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6468.6
Simplified68.6%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6454.5
Simplified54.5%
(FPCore (x y z t a) :precision binary64 (if (<= z -4.7e+51) t (if (<= z -1.3e-153) (/ (* x y) z) (if (<= z 1.98e-19) x t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.7e+51) {
tmp = t;
} else if (z <= -1.3e-153) {
tmp = (x * y) / z;
} else if (z <= 1.98e-19) {
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 <= (-4.7d+51)) then
tmp = t
else if (z <= (-1.3d-153)) then
tmp = (x * y) / z
else if (z <= 1.98d-19) 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 <= -4.7e+51) {
tmp = t;
} else if (z <= -1.3e-153) {
tmp = (x * y) / z;
} else if (z <= 1.98e-19) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4.7e+51: tmp = t elif z <= -1.3e-153: tmp = (x * y) / z elif z <= 1.98e-19: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.7e+51) tmp = t; elseif (z <= -1.3e-153) tmp = Float64(Float64(x * y) / z); elseif (z <= 1.98e-19) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4.7e+51) tmp = t; elseif (z <= -1.3e-153) tmp = (x * y) / z; elseif (z <= 1.98e-19) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.7e+51], t, If[LessEqual[z, -1.3e-153], N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 1.98e-19], x, t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.7 \cdot 10^{+51}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{-153}:\\
\;\;\;\;\frac{x \cdot y}{z}\\
\mathbf{elif}\;z \leq 1.98 \cdot 10^{-19}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -4.7000000000000002e51 or 1.98000000000000001e-19 < z Initial program 66.8%
Taylor expanded in z around inf
Simplified45.0%
if -4.7000000000000002e51 < z < -1.3000000000000001e-153Initial program 88.3%
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
Simplified57.0%
Taylor expanded in t around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
neg-lowering-neg.f6435.6
Simplified35.6%
Taylor expanded in a around 0
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6431.2
Simplified31.2%
if -1.3000000000000001e-153 < z < 1.98000000000000001e-19Initial program 93.6%
Taylor expanded in a around inf
Simplified40.7%
Final simplification41.4%
(FPCore (x y z t a) :precision binary64 (if (<= z -7.2e+72) t (if (<= z 1.75e-19) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.2e+72) {
tmp = t;
} else if (z <= 1.75e-19) {
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 <= (-7.2d+72)) then
tmp = t
else if (z <= 1.75d-19) 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 <= -7.2e+72) {
tmp = t;
} else if (z <= 1.75e-19) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -7.2e+72: tmp = t elif z <= 1.75e-19: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -7.2e+72) tmp = t; elseif (z <= 1.75e-19) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -7.2e+72) tmp = t; elseif (z <= 1.75e-19) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -7.2e+72], t, If[LessEqual[z, 1.75e-19], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.2 \cdot 10^{+72}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.75 \cdot 10^{-19}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -7.20000000000000069e72 or 1.75000000000000008e-19 < z Initial program 66.2%
Taylor expanded in z around inf
Simplified46.7%
if -7.20000000000000069e72 < z < 1.75000000000000008e-19Initial program 91.3%
Taylor expanded in a around inf
Simplified32.3%
(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 79.5%
Taylor expanded in z around inf
Simplified25.6%
herbie shell --seed 2024205
(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)))))