
(FPCore (x y z t a b) :precision binary64 (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((x - ((y - 1.0d0) * z)) - ((t - 1.0d0) * a)) + (((y + t) - 2.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
def code(x, y, z, t, a, b): return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a)) + Float64(Float64(Float64(y + t) - 2.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x - N[(N[(y - 1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[(t - 1.0), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 23 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((x - ((y - 1.0d0) * z)) - ((t - 1.0d0) * a)) + (((y + t) - 2.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
def code(x, y, z, t, a, b): return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a)) + Float64(Float64(Float64(y + t) - 2.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x - N[(N[(y - 1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[(t - 1.0), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b
\end{array}
(FPCore (x y z t a b) :precision binary64 (- x (fma (+ y -1.0) z (fma (+ -1.0 t) a (* (- b) (+ y (+ t -2.0)))))))
double code(double x, double y, double z, double t, double a, double b) {
return x - fma((y + -1.0), z, fma((-1.0 + t), a, (-b * (y + (t + -2.0)))));
}
function code(x, y, z, t, a, b) return Float64(x - fma(Float64(y + -1.0), z, fma(Float64(-1.0 + t), a, Float64(Float64(-b) * Float64(y + Float64(t + -2.0)))))) end
code[x_, y_, z_, t_, a_, b_] := N[(x - N[(N[(y + -1.0), $MachinePrecision] * z + N[(N[(-1.0 + t), $MachinePrecision] * a + N[((-b) * N[(y + N[(t + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \mathsf{fma}\left(y + -1, z, \mathsf{fma}\left(-1 + t, a, \left(-b\right) \cdot \left(y + \left(t + -2\right)\right)\right)\right)
\end{array}
Initial program 96.9%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval99.6
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2e+195)
(* b (+ y (+ t -2.0)))
(if (<= b -2.6e-109)
(- x (fma (+ y -1.0) z (* t (- a b))))
(if (<= b 7e+79)
(fma a (- 1.0 t) (fma z (- 1.0 y) x))
(+ x (* b (- (+ y t) 2.0)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2e+195) {
tmp = b * (y + (t + -2.0));
} else if (b <= -2.6e-109) {
tmp = x - fma((y + -1.0), z, (t * (a - b)));
} else if (b <= 7e+79) {
tmp = fma(a, (1.0 - t), fma(z, (1.0 - y), x));
} else {
tmp = x + (b * ((y + t) - 2.0));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2e+195) tmp = Float64(b * Float64(y + Float64(t + -2.0))); elseif (b <= -2.6e-109) tmp = Float64(x - fma(Float64(y + -1.0), z, Float64(t * Float64(a - b)))); elseif (b <= 7e+79) tmp = fma(a, Float64(1.0 - t), fma(z, Float64(1.0 - y), x)); else tmp = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2e+195], N[(b * N[(y + N[(t + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -2.6e-109], N[(x - N[(N[(y + -1.0), $MachinePrecision] * z + N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7e+79], N[(a * N[(1.0 - t), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2 \cdot 10^{+195}:\\
\;\;\;\;b \cdot \left(y + \left(t + -2\right)\right)\\
\mathbf{elif}\;b \leq -2.6 \cdot 10^{-109}:\\
\;\;\;\;x - \mathsf{fma}\left(y + -1, z, t \cdot \left(a - b\right)\right)\\
\mathbf{elif}\;b \leq 7 \cdot 10^{+79}:\\
\;\;\;\;\mathsf{fma}\left(a, 1 - t, \mathsf{fma}\left(z, 1 - y, x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\
\end{array}
\end{array}
if b < -1.99999999999999995e195Initial program 96.0%
Taylor expanded in b around inf
*-lowering-*.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval96.0
Simplified96.0%
if -1.99999999999999995e195 < b < -2.5999999999999998e-109Initial program 94.6%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval100.0
Applied egg-rr100.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6476.4
Simplified76.4%
if -2.5999999999999998e-109 < b < 6.99999999999999961e79Initial program 99.3%
Taylor expanded in b around 0
associate--r+N/A
sub-negN/A
+-commutativeN/A
associate-+r-N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
Simplified92.6%
if 6.99999999999999961e79 < b Initial program 92.7%
Taylor expanded in x around inf
Simplified87.8%
Final simplification88.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (fma z (- 1.0 y) x)) (t_2 (* b (+ y (+ t -2.0)))))
(if (<= b -1.2e+54)
t_2
(if (<= b 1.9e-274)
t_1
(if (<= b 0.055) (fma a (- 1.0 t) x) (if (<= b 1.9e+71) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(z, (1.0 - y), x);
double t_2 = b * (y + (t + -2.0));
double tmp;
if (b <= -1.2e+54) {
tmp = t_2;
} else if (b <= 1.9e-274) {
tmp = t_1;
} else if (b <= 0.055) {
tmp = fma(a, (1.0 - t), x);
} else if (b <= 1.9e+71) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(z, Float64(1.0 - y), x) t_2 = Float64(b * Float64(y + Float64(t + -2.0))) tmp = 0.0 if (b <= -1.2e+54) tmp = t_2; elseif (b <= 1.9e-274) tmp = t_1; elseif (b <= 0.055) tmp = fma(a, Float64(1.0 - t), x); elseif (b <= 1.9e+71) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(y + N[(t + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.2e+54], t$95$2, If[LessEqual[b, 1.9e-274], t$95$1, If[LessEqual[b, 0.055], N[(a * N[(1.0 - t), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[b, 1.9e+71], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(z, 1 - y, x\right)\\
t_2 := b \cdot \left(y + \left(t + -2\right)\right)\\
\mathbf{if}\;b \leq -1.2 \cdot 10^{+54}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 1.9 \cdot 10^{-274}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 0.055:\\
\;\;\;\;\mathsf{fma}\left(a, 1 - t, x\right)\\
\mathbf{elif}\;b \leq 1.9 \cdot 10^{+71}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -1.19999999999999999e54 or 1.9e71 < b Initial program 95.7%
Taylor expanded in b around inf
*-lowering-*.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval79.0
Simplified79.0%
if -1.19999999999999999e54 < b < 1.89999999999999992e-274 or 0.0550000000000000003 < b < 1.9e71Initial program 96.9%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval100.0
Applied egg-rr100.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6486.2
Simplified86.2%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
--lowering--.f6464.2
Simplified64.2%
if 1.89999999999999992e-274 < b < 0.0550000000000000003Initial program 98.5%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6474.0
Simplified74.0%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6466.6
Simplified66.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (fma (+ y -1.0) z (* t (- a b))))))
(if (<= t -1350000000.0)
t_1
(if (<= t 370000.0) (+ x (fma z (- 1.0 y) (fma b (+ y -2.0) a))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - fma((y + -1.0), z, (t * (a - b)));
double tmp;
if (t <= -1350000000.0) {
tmp = t_1;
} else if (t <= 370000.0) {
tmp = x + fma(z, (1.0 - y), fma(b, (y + -2.0), a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x - fma(Float64(y + -1.0), z, Float64(t * Float64(a - b)))) tmp = 0.0 if (t <= -1350000000.0) tmp = t_1; elseif (t <= 370000.0) tmp = Float64(x + fma(z, Float64(1.0 - y), fma(b, Float64(y + -2.0), a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x - N[(N[(y + -1.0), $MachinePrecision] * z + N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1350000000.0], t$95$1, If[LessEqual[t, 370000.0], N[(x + N[(z * N[(1.0 - y), $MachinePrecision] + N[(b * N[(y + -2.0), $MachinePrecision] + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \mathsf{fma}\left(y + -1, z, t \cdot \left(a - b\right)\right)\\
\mathbf{if}\;t \leq -1350000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 370000:\\
\;\;\;\;x + \mathsf{fma}\left(z, 1 - y, \mathsf{fma}\left(b, y + -2, a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.35e9 or 3.7e5 < t Initial program 95.1%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval99.2
Applied egg-rr99.2%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6496.5
Simplified96.5%
if -1.35e9 < t < 3.7e5Initial program 98.5%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval100.0
Applied egg-rr100.0%
Taylor expanded in t around 0
sub-negN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-commutativeN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-outN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f64N/A
Simplified99.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (fma (+ y -1.0) z (* t (- a b))))))
(if (<= t -1.45)
t_1
(if (<= t 70000.0) (+ x (fma b (+ y -2.0) (fma z (- 1.0 y) a))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - fma((y + -1.0), z, (t * (a - b)));
double tmp;
if (t <= -1.45) {
tmp = t_1;
} else if (t <= 70000.0) {
tmp = x + fma(b, (y + -2.0), fma(z, (1.0 - y), a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x - fma(Float64(y + -1.0), z, Float64(t * Float64(a - b)))) tmp = 0.0 if (t <= -1.45) tmp = t_1; elseif (t <= 70000.0) tmp = Float64(x + fma(b, Float64(y + -2.0), fma(z, Float64(1.0 - y), a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x - N[(N[(y + -1.0), $MachinePrecision] * z + N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.45], t$95$1, If[LessEqual[t, 70000.0], N[(x + N[(b * N[(y + -2.0), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision] + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \mathsf{fma}\left(y + -1, z, t \cdot \left(a - b\right)\right)\\
\mathbf{if}\;t \leq -1.45:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 70000:\\
\;\;\;\;x + \mathsf{fma}\left(b, y + -2, \mathsf{fma}\left(z, 1 - y, a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.44999999999999996 or 7e4 < t Initial program 94.3%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval99.2
Applied egg-rr99.2%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6495.8
Simplified95.8%
if -1.44999999999999996 < t < 7e4Initial program 99.2%
Taylor expanded in t around 0
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6498.3
Simplified98.3%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -5.8e+64)
(+ x (fma y b (* b (+ t -2.0))))
(if (<= b 1.6e+80)
(fma a (- 1.0 t) (fma z (- 1.0 y) x))
(+ x (* b (- (+ y t) 2.0))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -5.8e+64) {
tmp = x + fma(y, b, (b * (t + -2.0)));
} else if (b <= 1.6e+80) {
tmp = fma(a, (1.0 - t), fma(z, (1.0 - y), x));
} else {
tmp = x + (b * ((y + t) - 2.0));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -5.8e+64) tmp = Float64(x + fma(y, b, Float64(b * Float64(t + -2.0)))); elseif (b <= 1.6e+80) tmp = fma(a, Float64(1.0 - t), fma(z, Float64(1.0 - y), x)); else tmp = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -5.8e+64], N[(x + N[(y * b + N[(b * N[(t + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.6e+80], N[(a * N[(1.0 - t), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -5.8 \cdot 10^{+64}:\\
\;\;\;\;x + \mathsf{fma}\left(y, b, b \cdot \left(t + -2\right)\right)\\
\mathbf{elif}\;b \leq 1.6 \cdot 10^{+80}:\\
\;\;\;\;\mathsf{fma}\left(a, 1 - t, \mathsf{fma}\left(z, 1 - y, x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\
\end{array}
\end{array}
if b < -5.79999999999999986e64Initial program 97.9%
Taylor expanded in x around inf
Simplified80.4%
sub-negN/A
metadata-evalN/A
associate-+r+N/A
*-commutativeN/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6480.5
Applied egg-rr80.5%
if -5.79999999999999986e64 < b < 1.59999999999999995e80Initial program 97.6%
Taylor expanded in b around 0
associate--r+N/A
sub-negN/A
+-commutativeN/A
associate-+r-N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
Simplified88.2%
if 1.59999999999999995e80 < b Initial program 92.7%
Taylor expanded in x around inf
Simplified87.8%
Final simplification86.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -4.1e+39)
t_1
(if (<= t 5.8e-34)
(+ a (fma b (+ y -2.0) x))
(if (<= t 3.6e+50) (fma z (- 1.0 y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -4.1e+39) {
tmp = t_1;
} else if (t <= 5.8e-34) {
tmp = a + fma(b, (y + -2.0), x);
} else if (t <= 3.6e+50) {
tmp = fma(z, (1.0 - y), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -4.1e+39) tmp = t_1; elseif (t <= 5.8e-34) tmp = Float64(a + fma(b, Float64(y + -2.0), x)); elseif (t <= 3.6e+50) tmp = fma(z, Float64(1.0 - y), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.1e+39], t$95$1, If[LessEqual[t, 5.8e-34], N[(a + N[(b * N[(y + -2.0), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.6e+50], N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -4.1 \cdot 10^{+39}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 5.8 \cdot 10^{-34}:\\
\;\;\;\;a + \mathsf{fma}\left(b, y + -2, x\right)\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{+50}:\\
\;\;\;\;\mathsf{fma}\left(z, 1 - y, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -4.10000000000000004e39 or 3.59999999999999986e50 < t Initial program 94.4%
Taylor expanded in t around inf
*-lowering-*.f64N/A
--lowering--.f6475.1
Simplified75.1%
if -4.10000000000000004e39 < t < 5.8000000000000004e-34Initial program 98.5%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6470.1
Simplified70.1%
Taylor expanded in t around 0
+-lowering-+.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f6468.1
Simplified68.1%
if 5.8000000000000004e-34 < t < 3.59999999999999986e50Initial program 100.0%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval100.0
Applied egg-rr100.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6490.1
Simplified90.1%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
--lowering--.f6471.8
Simplified71.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -2.9e+16)
t_1
(if (<= t -8e-47)
(fma b (+ y -2.0) x)
(if (<= t 1.35e+51) (fma z (- 1.0 y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -2.9e+16) {
tmp = t_1;
} else if (t <= -8e-47) {
tmp = fma(b, (y + -2.0), x);
} else if (t <= 1.35e+51) {
tmp = fma(z, (1.0 - y), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -2.9e+16) tmp = t_1; elseif (t <= -8e-47) tmp = fma(b, Float64(y + -2.0), x); elseif (t <= 1.35e+51) tmp = fma(z, Float64(1.0 - y), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.9e+16], t$95$1, If[LessEqual[t, -8e-47], N[(b * N[(y + -2.0), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t, 1.35e+51], N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.9 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -8 \cdot 10^{-47}:\\
\;\;\;\;\mathsf{fma}\left(b, y + -2, x\right)\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{+51}:\\
\;\;\;\;\mathsf{fma}\left(z, 1 - y, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.9e16 or 1.34999999999999996e51 < t Initial program 94.7%
Taylor expanded in t around inf
*-lowering-*.f64N/A
--lowering--.f6474.5
Simplified74.5%
if -2.9e16 < t < -7.9999999999999998e-47Initial program 92.9%
Taylor expanded in x around inf
Simplified68.8%
Taylor expanded in t around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval68.8
Simplified68.8%
if -7.9999999999999998e-47 < t < 1.34999999999999996e51Initial program 99.2%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval100.0
Applied egg-rr100.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6458.2
Simplified58.2%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
--lowering--.f6456.1
Simplified56.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -7.6e+22)
t_1
(if (<= t 5.6e-180)
(fma b (+ y -2.0) x)
(if (<= t 32000000000000.0) (fma a (- 1.0 t) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -7.6e+22) {
tmp = t_1;
} else if (t <= 5.6e-180) {
tmp = fma(b, (y + -2.0), x);
} else if (t <= 32000000000000.0) {
tmp = fma(a, (1.0 - t), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -7.6e+22) tmp = t_1; elseif (t <= 5.6e-180) tmp = fma(b, Float64(y + -2.0), x); elseif (t <= 32000000000000.0) tmp = fma(a, Float64(1.0 - t), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.6e+22], t$95$1, If[LessEqual[t, 5.6e-180], N[(b * N[(y + -2.0), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t, 32000000000000.0], N[(a * N[(1.0 - t), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -7.6 \cdot 10^{+22}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 5.6 \cdot 10^{-180}:\\
\;\;\;\;\mathsf{fma}\left(b, y + -2, x\right)\\
\mathbf{elif}\;t \leq 32000000000000:\\
\;\;\;\;\mathsf{fma}\left(a, 1 - t, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -7.6000000000000008e22 or 3.2e13 < t Initial program 94.9%
Taylor expanded in t around inf
*-lowering-*.f64N/A
--lowering--.f6472.5
Simplified72.5%
if -7.6000000000000008e22 < t < 5.59999999999999994e-180Initial program 99.0%
Taylor expanded in x around inf
Simplified52.8%
Taylor expanded in t around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval52.8
Simplified52.8%
if 5.59999999999999994e-180 < t < 3.2e13Initial program 97.5%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6468.9
Simplified68.9%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6451.7
Simplified51.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (fma b y (fma a (- 1.0 t) x))))
(if (<= a -5.2e+75)
t_1
(if (<= a 5.4e+57) (fma z (- 1.0 y) (fma t b x)) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(b, y, fma(a, (1.0 - t), x));
double tmp;
if (a <= -5.2e+75) {
tmp = t_1;
} else if (a <= 5.4e+57) {
tmp = fma(z, (1.0 - y), fma(t, b, x));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(b, y, fma(a, Float64(1.0 - t), x)) tmp = 0.0 if (a <= -5.2e+75) tmp = t_1; elseif (a <= 5.4e+57) tmp = fma(z, Float64(1.0 - y), fma(t, b, x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * y + N[(a * N[(1.0 - t), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -5.2e+75], t$95$1, If[LessEqual[a, 5.4e+57], N[(z * N[(1.0 - y), $MachinePrecision] + N[(t * b + x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(b, y, \mathsf{fma}\left(a, 1 - t, x\right)\right)\\
\mathbf{if}\;a \leq -5.2 \cdot 10^{+75}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.4 \cdot 10^{+57}:\\
\;\;\;\;\mathsf{fma}\left(z, 1 - y, \mathsf{fma}\left(t, b, x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -5.1999999999999997e75 or 5.3999999999999997e57 < a Initial program 93.3%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6492.1
Simplified92.1%
Taylor expanded in y around inf
Simplified80.3%
if -5.1999999999999997e75 < a < 5.3999999999999997e57Initial program 99.3%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval100.0
Applied egg-rr100.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6482.0
Simplified82.0%
Taylor expanded in a around 0
sub-negN/A
+-commutativeN/A
+-commutativeN/A
distribute-neg-inN/A
mul-1-negN/A
remove-double-negN/A
associate-+l+N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
--lowering--.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6479.2
Simplified79.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -1250000000.0)
t_1
(if (<= t 7.6e-280) (* y (- b z)) (if (<= t 7.8e+15) (+ x a) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1250000000.0) {
tmp = t_1;
} else if (t <= 7.6e-280) {
tmp = y * (b - z);
} else if (t <= 7.8e+15) {
tmp = x + a;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-1250000000.0d0)) then
tmp = t_1
else if (t <= 7.6d-280) then
tmp = y * (b - z)
else if (t <= 7.8d+15) then
tmp = x + a
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1250000000.0) {
tmp = t_1;
} else if (t <= 7.6e-280) {
tmp = y * (b - z);
} else if (t <= 7.8e+15) {
tmp = x + a;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -1250000000.0: tmp = t_1 elif t <= 7.6e-280: tmp = y * (b - z) elif t <= 7.8e+15: tmp = x + a else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1250000000.0) tmp = t_1; elseif (t <= 7.6e-280) tmp = Float64(y * Float64(b - z)); elseif (t <= 7.8e+15) tmp = Float64(x + a); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -1250000000.0) tmp = t_1; elseif (t <= 7.6e-280) tmp = y * (b - z); elseif (t <= 7.8e+15) tmp = x + a; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1250000000.0], t$95$1, If[LessEqual[t, 7.6e-280], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.8e+15], N[(x + a), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1250000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 7.6 \cdot 10^{-280}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq 7.8 \cdot 10^{+15}:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.25e9 or 7.8e15 < t Initial program 95.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
--lowering--.f6472.0
Simplified72.0%
if -1.25e9 < t < 7.6000000000000003e-280Initial program 98.6%
Taylor expanded in y around inf
*-lowering-*.f64N/A
--lowering--.f6445.8
Simplified45.8%
if 7.6000000000000003e-280 < t < 7.8e15Initial program 98.4%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6472.6
Simplified72.6%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6452.3
Simplified52.3%
Taylor expanded in t around 0
+-lowering-+.f6449.9
Simplified49.9%
Final simplification59.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -40000000.0)
t_1
(if (<= t 6.4e-279) (* b (+ y -2.0)) (if (<= t 9.5e+15) (+ x a) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -40000000.0) {
tmp = t_1;
} else if (t <= 6.4e-279) {
tmp = b * (y + -2.0);
} else if (t <= 9.5e+15) {
tmp = x + a;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-40000000.0d0)) then
tmp = t_1
else if (t <= 6.4d-279) then
tmp = b * (y + (-2.0d0))
else if (t <= 9.5d+15) then
tmp = x + a
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -40000000.0) {
tmp = t_1;
} else if (t <= 6.4e-279) {
tmp = b * (y + -2.0);
} else if (t <= 9.5e+15) {
tmp = x + a;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -40000000.0: tmp = t_1 elif t <= 6.4e-279: tmp = b * (y + -2.0) elif t <= 9.5e+15: tmp = x + a else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -40000000.0) tmp = t_1; elseif (t <= 6.4e-279) tmp = Float64(b * Float64(y + -2.0)); elseif (t <= 9.5e+15) tmp = Float64(x + a); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -40000000.0) tmp = t_1; elseif (t <= 6.4e-279) tmp = b * (y + -2.0); elseif (t <= 9.5e+15) tmp = x + a; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -40000000.0], t$95$1, If[LessEqual[t, 6.4e-279], N[(b * N[(y + -2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.5e+15], N[(x + a), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -40000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 6.4 \cdot 10^{-279}:\\
\;\;\;\;b \cdot \left(y + -2\right)\\
\mathbf{elif}\;t \leq 9.5 \cdot 10^{+15}:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -4e7 or 9.5e15 < t Initial program 95.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
--lowering--.f6472.0
Simplified72.0%
if -4e7 < t < 6.3999999999999997e-279Initial program 98.6%
Taylor expanded in x around inf
Simplified49.3%
Taylor expanded in t around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval49.3
Simplified49.3%
Taylor expanded in b around inf
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f6438.1
Simplified38.1%
if 6.3999999999999997e-279 < t < 9.5e15Initial program 98.4%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6472.6
Simplified72.6%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6452.3
Simplified52.3%
Taylor expanded in t around 0
+-lowering-+.f6449.9
Simplified49.9%
Final simplification56.9%
(FPCore (x y z t a b) :precision binary64 (if (<= t -5.4e-17) (fma t b x) (if (<= t 1.4e-277) (* b (+ y -2.0)) (if (<= t 1.0) (+ x a) (fma t b x)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -5.4e-17) {
tmp = fma(t, b, x);
} else if (t <= 1.4e-277) {
tmp = b * (y + -2.0);
} else if (t <= 1.0) {
tmp = x + a;
} else {
tmp = fma(t, b, x);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -5.4e-17) tmp = fma(t, b, x); elseif (t <= 1.4e-277) tmp = Float64(b * Float64(y + -2.0)); elseif (t <= 1.0) tmp = Float64(x + a); else tmp = fma(t, b, x); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -5.4e-17], N[(t * b + x), $MachinePrecision], If[LessEqual[t, 1.4e-277], N[(b * N[(y + -2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.0], N[(x + a), $MachinePrecision], N[(t * b + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5.4 \cdot 10^{-17}:\\
\;\;\;\;\mathsf{fma}\left(t, b, x\right)\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{-277}:\\
\;\;\;\;b \cdot \left(y + -2\right)\\
\mathbf{elif}\;t \leq 1:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t, b, x\right)\\
\end{array}
\end{array}
if t < -5.4000000000000002e-17 or 1 < t Initial program 94.5%
Taylor expanded in x around inf
Simplified53.7%
sub-negN/A
metadata-evalN/A
associate-+r+N/A
*-commutativeN/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6453.7
Applied egg-rr53.7%
Taylor expanded in t around inf
Simplified53.7%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6450.1
Simplified50.1%
if -5.4000000000000002e-17 < t < 1.39999999999999988e-277Initial program 100.0%
Taylor expanded in x around inf
Simplified49.1%
Taylor expanded in t around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval49.1
Simplified49.1%
Taylor expanded in b around inf
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f6438.8
Simplified38.8%
if 1.39999999999999988e-277 < t < 1Initial program 98.3%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6473.3
Simplified73.3%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6452.0
Simplified52.0%
Taylor expanded in t around 0
+-lowering-+.f6451.3
Simplified51.3%
Final simplification47.3%
(FPCore (x y z t a b) :precision binary64 (if (<= t -5e+24) (fma t b x) (if (<= t 1.25e-252) (fma b -2.0 x) (if (<= t 1.0) (+ x a) (fma t b x)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -5e+24) {
tmp = fma(t, b, x);
} else if (t <= 1.25e-252) {
tmp = fma(b, -2.0, x);
} else if (t <= 1.0) {
tmp = x + a;
} else {
tmp = fma(t, b, x);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -5e+24) tmp = fma(t, b, x); elseif (t <= 1.25e-252) tmp = fma(b, -2.0, x); elseif (t <= 1.0) tmp = Float64(x + a); else tmp = fma(t, b, x); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -5e+24], N[(t * b + x), $MachinePrecision], If[LessEqual[t, 1.25e-252], N[(b * -2.0 + x), $MachinePrecision], If[LessEqual[t, 1.0], N[(x + a), $MachinePrecision], N[(t * b + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5 \cdot 10^{+24}:\\
\;\;\;\;\mathsf{fma}\left(t, b, x\right)\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{-252}:\\
\;\;\;\;\mathsf{fma}\left(b, -2, x\right)\\
\mathbf{elif}\;t \leq 1:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t, b, x\right)\\
\end{array}
\end{array}
if t < -5.00000000000000045e24 or 1 < t Initial program 95.0%
Taylor expanded in x around inf
Simplified53.8%
sub-negN/A
metadata-evalN/A
associate-+r+N/A
*-commutativeN/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6453.9
Applied egg-rr53.9%
Taylor expanded in t around inf
Simplified53.9%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6450.8
Simplified50.8%
if -5.00000000000000045e24 < t < 1.25000000000000002e-252Initial program 98.7%
Taylor expanded in x around inf
Simplified49.5%
Taylor expanded in t around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval49.5
Simplified49.5%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6433.4
Simplified33.4%
if 1.25000000000000002e-252 < t < 1Initial program 98.1%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6475.6
Simplified75.6%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6453.8
Simplified53.8%
Taylor expanded in t around 0
+-lowering-+.f6453.0
Simplified53.0%
Final simplification45.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (fma t (- b a) z))))
(if (<= t -1400000000.0)
t_1
(if (<= t 2e-31) (+ a (fma b (+ y -2.0) x)) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + fma(t, (b - a), z);
double tmp;
if (t <= -1400000000.0) {
tmp = t_1;
} else if (t <= 2e-31) {
tmp = a + fma(b, (y + -2.0), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x + fma(t, Float64(b - a), z)) tmp = 0.0 if (t <= -1400000000.0) tmp = t_1; elseif (t <= 2e-31) tmp = Float64(a + fma(b, Float64(y + -2.0), x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(t * N[(b - a), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1400000000.0], t$95$1, If[LessEqual[t, 2e-31], N[(a + N[(b * N[(y + -2.0), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \mathsf{fma}\left(t, b - a, z\right)\\
\mathbf{if}\;t \leq -1400000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-31}:\\
\;\;\;\;a + \mathsf{fma}\left(b, y + -2, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.4e9 or 2e-31 < t Initial program 95.3%
associate-+l-N/A
associate--l-N/A
--lowering--.f64N/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-commutativeN/A
cancel-sign-sub-invN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
neg-lowering-neg.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval99.2
Applied egg-rr99.2%
Taylor expanded in t around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f6495.9
Simplified95.9%
Taylor expanded in y around 0
sub-negN/A
+-lowering-+.f64N/A
+-commutativeN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
associate-+l-N/A
neg-sub0N/A
mul-1-negN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
--lowering--.f6490.8
Simplified90.8%
if -1.4e9 < t < 2e-31Initial program 98.4%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6468.9
Simplified68.9%
Taylor expanded in t around 0
+-lowering-+.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f6468.3
Simplified68.3%
(FPCore (x y z t a b) :precision binary64 (if (<= t -4.8e+102) (* t b) (if (<= t 7e-253) (fma b -2.0 x) (if (<= t 4.8e+17) (+ x a) (* t b)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.8e+102) {
tmp = t * b;
} else if (t <= 7e-253) {
tmp = fma(b, -2.0, x);
} else if (t <= 4.8e+17) {
tmp = x + a;
} else {
tmp = t * b;
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4.8e+102) tmp = Float64(t * b); elseif (t <= 7e-253) tmp = fma(b, -2.0, x); elseif (t <= 4.8e+17) tmp = Float64(x + a); else tmp = Float64(t * b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4.8e+102], N[(t * b), $MachinePrecision], If[LessEqual[t, 7e-253], N[(b * -2.0 + x), $MachinePrecision], If[LessEqual[t, 4.8e+17], N[(x + a), $MachinePrecision], N[(t * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.8 \cdot 10^{+102}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;t \leq 7 \cdot 10^{-253}:\\
\;\;\;\;\mathsf{fma}\left(b, -2, x\right)\\
\mathbf{elif}\;t \leq 4.8 \cdot 10^{+17}:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;t \cdot b\\
\end{array}
\end{array}
if t < -4.79999999999999989e102 or 4.8e17 < t Initial program 94.0%
Taylor expanded in x around inf
Simplified53.7%
Taylor expanded in t around inf
*-lowering-*.f6441.3
Simplified41.3%
if -4.79999999999999989e102 < t < 7.00000000000000045e-253Initial program 99.0%
Taylor expanded in x around inf
Simplified51.3%
Taylor expanded in t around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval48.1
Simplified48.1%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6432.9
Simplified32.9%
if 7.00000000000000045e-253 < t < 4.8e17Initial program 98.2%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6474.7
Simplified74.7%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6454.0
Simplified54.0%
Taylor expanded in t around 0
+-lowering-+.f6451.4
Simplified51.4%
Final simplification40.3%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (* b (+ y t)))) (if (<= b -1.32e+162) t_1 (if (<= b 9.2e+185) (fma a (- 1.0 t) x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = b * (y + t);
double tmp;
if (b <= -1.32e+162) {
tmp = t_1;
} else if (b <= 9.2e+185) {
tmp = fma(a, (1.0 - t), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(b * Float64(y + t)) tmp = 0.0 if (b <= -1.32e+162) tmp = t_1; elseif (b <= 9.2e+185) tmp = fma(a, Float64(1.0 - t), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(y + t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.32e+162], t$95$1, If[LessEqual[b, 9.2e+185], N[(a * N[(1.0 - t), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(y + t\right)\\
\mathbf{if}\;b \leq -1.32 \cdot 10^{+162}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 9.2 \cdot 10^{+185}:\\
\;\;\;\;\mathsf{fma}\left(a, 1 - t, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.31999999999999999e162 or 9.2000000000000005e185 < b Initial program 94.6%
Taylor expanded in x around inf
Simplified95.1%
sub-negN/A
metadata-evalN/A
associate-+r+N/A
*-commutativeN/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6495.1
Applied egg-rr95.1%
Taylor expanded in t around inf
Simplified74.0%
Taylor expanded in x around 0
distribute-lft-inN/A
*-lowering-*.f64N/A
+-lowering-+.f6474.1
Simplified74.1%
if -1.31999999999999999e162 < b < 9.2000000000000005e185Initial program 97.5%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6471.7
Simplified71.7%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6455.2
Simplified55.2%
Final simplification59.3%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (* t (- a)))) (if (<= a -4.3e+154) t_1 (if (<= a 1.6e+194) (fma t b x) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * -a;
double tmp;
if (a <= -4.3e+154) {
tmp = t_1;
} else if (a <= 1.6e+194) {
tmp = fma(t, b, x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(-a)) tmp = 0.0 if (a <= -4.3e+154) tmp = t_1; elseif (a <= 1.6e+194) tmp = fma(t, b, x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * (-a)), $MachinePrecision]}, If[LessEqual[a, -4.3e+154], t$95$1, If[LessEqual[a, 1.6e+194], N[(t * b + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(-a\right)\\
\mathbf{if}\;a \leq -4.3 \cdot 10^{+154}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.6 \cdot 10^{+194}:\\
\;\;\;\;\mathsf{fma}\left(t, b, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -4.2999999999999998e154 or 1.60000000000000011e194 < a Initial program 89.1%
Taylor expanded in a around inf
sub-negN/A
neg-mul-1N/A
+-commutativeN/A
distribute-rgt-inN/A
neg-mul-1N/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-lowering-neg.f6478.9
Simplified78.9%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-lowering-neg.f6449.2
Simplified49.2%
if -4.2999999999999998e154 < a < 1.60000000000000011e194Initial program 99.5%
Taylor expanded in x around inf
Simplified61.1%
sub-negN/A
metadata-evalN/A
associate-+r+N/A
*-commutativeN/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6461.1
Applied egg-rr61.1%
Taylor expanded in t around inf
Simplified52.3%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6443.2
Simplified43.2%
Final simplification44.7%
(FPCore (x y z t a b) :precision binary64 (if (<= t -4e+144) (* t b) (if (<= t 3.4e+15) (+ x a) (* t b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4e+144) {
tmp = t * b;
} else if (t <= 3.4e+15) {
tmp = x + a;
} else {
tmp = t * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-4d+144)) then
tmp = t * b
else if (t <= 3.4d+15) then
tmp = x + a
else
tmp = t * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4e+144) {
tmp = t * b;
} else if (t <= 3.4e+15) {
tmp = x + a;
} else {
tmp = t * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -4e+144: tmp = t * b elif t <= 3.4e+15: tmp = x + a else: tmp = t * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4e+144) tmp = Float64(t * b); elseif (t <= 3.4e+15) tmp = Float64(x + a); else tmp = Float64(t * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -4e+144) tmp = t * b; elseif (t <= 3.4e+15) tmp = x + a; else tmp = t * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4e+144], N[(t * b), $MachinePrecision], If[LessEqual[t, 3.4e+15], N[(x + a), $MachinePrecision], N[(t * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4 \cdot 10^{+144}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;t \leq 3.4 \cdot 10^{+15}:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;t \cdot b\\
\end{array}
\end{array}
if t < -4.00000000000000009e144 or 3.4e15 < t Initial program 94.7%
Taylor expanded in x around inf
Simplified55.4%
Taylor expanded in t around inf
*-lowering-*.f6443.1
Simplified43.1%
if -4.00000000000000009e144 < t < 3.4e15Initial program 98.1%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6470.9
Simplified70.9%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6442.9
Simplified42.9%
Taylor expanded in t around 0
+-lowering-+.f6435.8
Simplified35.8%
Final simplification38.5%
(FPCore (x y z t a b) :precision binary64 (if (<= b -2.1e+204) (* b -2.0) (if (<= b 2.2e+146) (+ x a) (* b -2.0))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.1e+204) {
tmp = b * -2.0;
} else if (b <= 2.2e+146) {
tmp = x + a;
} else {
tmp = b * -2.0;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-2.1d+204)) then
tmp = b * (-2.0d0)
else if (b <= 2.2d+146) then
tmp = x + a
else
tmp = b * (-2.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.1e+204) {
tmp = b * -2.0;
} else if (b <= 2.2e+146) {
tmp = x + a;
} else {
tmp = b * -2.0;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.1e+204: tmp = b * -2.0 elif b <= 2.2e+146: tmp = x + a else: tmp = b * -2.0 return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.1e+204) tmp = Float64(b * -2.0); elseif (b <= 2.2e+146) tmp = Float64(x + a); else tmp = Float64(b * -2.0); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.1e+204) tmp = b * -2.0; elseif (b <= 2.2e+146) tmp = x + a; else tmp = b * -2.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.1e+204], N[(b * -2.0), $MachinePrecision], If[LessEqual[b, 2.2e+146], N[(x + a), $MachinePrecision], N[(b * -2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.1 \cdot 10^{+204}:\\
\;\;\;\;b \cdot -2\\
\mathbf{elif}\;b \leq 2.2 \cdot 10^{+146}:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;b \cdot -2\\
\end{array}
\end{array}
if b < -2.1e204 or 2.1999999999999998e146 < b Initial program 92.3%
Taylor expanded in x around inf
Simplified94.5%
Taylor expanded in t around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-eval60.8
Simplified60.8%
Taylor expanded in b around inf
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f6458.9
Simplified58.9%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6429.4
Simplified29.4%
if -2.1e204 < b < 2.1999999999999998e146Initial program 98.0%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6471.8
Simplified71.8%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6453.2
Simplified53.2%
Taylor expanded in t around 0
+-lowering-+.f6432.7
Simplified32.7%
Final simplification32.0%
(FPCore (x y z t a b) :precision binary64 (if (<= a -6.5e+140) a (if (<= a 1.12e+192) x a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -6.5e+140) {
tmp = a;
} else if (a <= 1.12e+192) {
tmp = x;
} else {
tmp = a;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= (-6.5d+140)) then
tmp = a
else if (a <= 1.12d+192) then
tmp = x
else
tmp = a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -6.5e+140) {
tmp = a;
} else if (a <= 1.12e+192) {
tmp = x;
} else {
tmp = a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -6.5e+140: tmp = a elif a <= 1.12e+192: tmp = x else: tmp = a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -6.5e+140) tmp = a; elseif (a <= 1.12e+192) tmp = x; else tmp = a; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -6.5e+140) tmp = a; elseif (a <= 1.12e+192) tmp = x; else tmp = a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -6.5e+140], a, If[LessEqual[a, 1.12e+192], x, a]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6.5 \cdot 10^{+140}:\\
\;\;\;\;a\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{+192}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;a\\
\end{array}
\end{array}
if a < -6.4999999999999999e140 or 1.12e192 < a Initial program 89.6%
Taylor expanded in a around inf
sub-negN/A
neg-mul-1N/A
+-commutativeN/A
distribute-rgt-inN/A
neg-mul-1N/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-lowering-neg.f6476.8
Simplified76.8%
Taylor expanded in t around 0
Simplified30.4%
if -6.4999999999999999e140 < a < 1.12e192Initial program 99.5%
Taylor expanded in x around inf
Simplified22.9%
(FPCore (x y z t a b) :precision binary64 (+ x a))
double code(double x, double y, double z, double t, double a, double b) {
return x + a;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x + a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x + a;
}
def code(x, y, z, t, a, b): return x + a
function code(x, y, z, t, a, b) return Float64(x + a) end
function tmp = code(x, y, z, t, a, b) tmp = x + a; end
code[x_, y_, z_, t_, a_, b_] := N[(x + a), $MachinePrecision]
\begin{array}{l}
\\
x + a
\end{array}
Initial program 96.9%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
associate-+r-N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
metadata-evalN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
--lowering--.f6477.1
Simplified77.1%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
--lowering--.f6444.2
Simplified44.2%
Taylor expanded in t around 0
+-lowering-+.f6427.1
Simplified27.1%
Final simplification27.1%
(FPCore (x y z t a b) :precision binary64 a)
double code(double x, double y, double z, double t, double a, double b) {
return a;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return a;
}
def code(x, y, z, t, a, b): return a
function code(x, y, z, t, a, b) return a end
function tmp = code(x, y, z, t, a, b) tmp = a; end
code[x_, y_, z_, t_, a_, b_] := a
\begin{array}{l}
\\
a
\end{array}
Initial program 96.9%
Taylor expanded in a around inf
sub-negN/A
neg-mul-1N/A
+-commutativeN/A
distribute-rgt-inN/A
neg-mul-1N/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-lowering-neg.f6428.6
Simplified28.6%
Taylor expanded in t around 0
Simplified11.4%
herbie shell --seed 2024204
(FPCore (x y z t a b)
:name "Statistics.Distribution.Beta:$centropy from math-functions-0.1.5.2"
:precision binary64
(+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))