
(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 27 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 (fma (+ t (- y 2.0)) b (- x (fma (+ y -1.0) z (* a (+ t -1.0))))))
double code(double x, double y, double z, double t, double a, double b) {
return fma((t + (y - 2.0)), b, (x - fma((y + -1.0), z, (a * (t + -1.0)))));
}
function code(x, y, z, t, a, b) return fma(Float64(t + Float64(y - 2.0)), b, Float64(x - fma(Float64(y + -1.0), z, Float64(a * Float64(t + -1.0))))) end
code[x_, y_, z_, t_, a_, b_] := N[(N[(t + N[(y - 2.0), $MachinePrecision]), $MachinePrecision] * b + N[(x - N[(N[(y + -1.0), $MachinePrecision] * z + N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(t + \left(y - 2\right), b, x - \mathsf{fma}\left(y + -1, z, a \cdot \left(t + -1\right)\right)\right)
\end{array}
Initial program 95.7%
+-commutative95.7%
fma-def98.0%
+-commutative98.0%
associate--l+98.0%
sub-neg98.0%
associate-+l-98.0%
fma-neg98.4%
sub-neg98.4%
metadata-eval98.4%
distribute-lft-neg-in98.4%
distribute-lft-neg-in98.4%
remove-double-neg98.4%
sub-neg98.4%
metadata-eval98.4%
Simplified98.4%
Final simplification98.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y))))
(t_2 (+ (+ t_1 (* a (- 1.0 t))) (* b (- (+ t y) 2.0)))))
(if (<= t_2 INFINITY) t_2 (+ t_1 (* t (- b a))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = (t_1 + (a * (1.0 - t))) + (b * ((t + y) - 2.0));
double tmp;
if (t_2 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = t_1 + (t * (b - a));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = (t_1 + (a * (1.0 - t))) + (b * ((t + y) - 2.0));
double tmp;
if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = t_2;
} else {
tmp = t_1 + (t * (b - a));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = (t_1 + (a * (1.0 - t))) + (b * ((t + y) - 2.0)) tmp = 0 if t_2 <= math.inf: tmp = t_2 else: tmp = t_1 + (t * (b - a)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z * Float64(1.0 - y))) t_2 = Float64(Float64(t_1 + Float64(a * Float64(1.0 - t))) + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (t_2 <= Inf) tmp = t_2; else tmp = Float64(t_1 + Float64(t * Float64(b - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z * (1.0 - y)); t_2 = (t_1 + (a * (1.0 - t))) + (b * ((t + y) - 2.0)); tmp = 0.0; if (t_2 <= Inf) tmp = t_2; else tmp = t_1 + (t * (b - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t$95$1 + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, Infinity], t$95$2, N[(t$95$1 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := \left(t_1 + a \cdot \left(1 - t\right)\right) + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;t_2 \leq \infty:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1 + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) < +inf.0Initial program 100.0%
if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) Initial program 0.0%
associate-+l-0.0%
*-commutative0.0%
*-commutative0.0%
sub-neg0.0%
metadata-eval0.0%
remove-double-neg0.0%
remove-double-neg0.0%
sub-neg0.0%
metadata-eval0.0%
associate--l+0.0%
Simplified0.0%
Taylor expanded in t around inf 63.6%
Final simplification98.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t)))
(t_2 (+ (* t b) t_1))
(t_3 (* y (- b z)))
(t_4 (+ (+ x (* t b)) t_1))
(t_5 (- (+ x z) (* b (- 2.0 t)))))
(if (<= y -2.7e+145)
t_3
(if (<= y -3.6e+126)
t_2
(if (<= y -8e+107)
t_3
(if (<= y -1.25e-67)
t_4
(if (<= y -1.8e-137)
(+ a (+ (* b -2.0) (+ x z)))
(if (<= y -1.2e-193)
t_2
(if (<= y 8.8e-303)
t_5
(if (<= y 3.1e-118)
t_4
(if (<= y 1.15e-9)
t_5
(if (<= y 4e+170)
(- (* t (- b a)) (* y z))
t_3))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double t_2 = (t * b) + t_1;
double t_3 = y * (b - z);
double t_4 = (x + (t * b)) + t_1;
double t_5 = (x + z) - (b * (2.0 - t));
double tmp;
if (y <= -2.7e+145) {
tmp = t_3;
} else if (y <= -3.6e+126) {
tmp = t_2;
} else if (y <= -8e+107) {
tmp = t_3;
} else if (y <= -1.25e-67) {
tmp = t_4;
} else if (y <= -1.8e-137) {
tmp = a + ((b * -2.0) + (x + z));
} else if (y <= -1.2e-193) {
tmp = t_2;
} else if (y <= 8.8e-303) {
tmp = t_5;
} else if (y <= 3.1e-118) {
tmp = t_4;
} else if (y <= 1.15e-9) {
tmp = t_5;
} else if (y <= 4e+170) {
tmp = (t * (b - a)) - (y * z);
} else {
tmp = t_3;
}
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) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: tmp
t_1 = a * (1.0d0 - t)
t_2 = (t * b) + t_1
t_3 = y * (b - z)
t_4 = (x + (t * b)) + t_1
t_5 = (x + z) - (b * (2.0d0 - t))
if (y <= (-2.7d+145)) then
tmp = t_3
else if (y <= (-3.6d+126)) then
tmp = t_2
else if (y <= (-8d+107)) then
tmp = t_3
else if (y <= (-1.25d-67)) then
tmp = t_4
else if (y <= (-1.8d-137)) then
tmp = a + ((b * (-2.0d0)) + (x + z))
else if (y <= (-1.2d-193)) then
tmp = t_2
else if (y <= 8.8d-303) then
tmp = t_5
else if (y <= 3.1d-118) then
tmp = t_4
else if (y <= 1.15d-9) then
tmp = t_5
else if (y <= 4d+170) then
tmp = (t * (b - a)) - (y * z)
else
tmp = t_3
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 = a * (1.0 - t);
double t_2 = (t * b) + t_1;
double t_3 = y * (b - z);
double t_4 = (x + (t * b)) + t_1;
double t_5 = (x + z) - (b * (2.0 - t));
double tmp;
if (y <= -2.7e+145) {
tmp = t_3;
} else if (y <= -3.6e+126) {
tmp = t_2;
} else if (y <= -8e+107) {
tmp = t_3;
} else if (y <= -1.25e-67) {
tmp = t_4;
} else if (y <= -1.8e-137) {
tmp = a + ((b * -2.0) + (x + z));
} else if (y <= -1.2e-193) {
tmp = t_2;
} else if (y <= 8.8e-303) {
tmp = t_5;
} else if (y <= 3.1e-118) {
tmp = t_4;
} else if (y <= 1.15e-9) {
tmp = t_5;
} else if (y <= 4e+170) {
tmp = (t * (b - a)) - (y * z);
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) t_2 = (t * b) + t_1 t_3 = y * (b - z) t_4 = (x + (t * b)) + t_1 t_5 = (x + z) - (b * (2.0 - t)) tmp = 0 if y <= -2.7e+145: tmp = t_3 elif y <= -3.6e+126: tmp = t_2 elif y <= -8e+107: tmp = t_3 elif y <= -1.25e-67: tmp = t_4 elif y <= -1.8e-137: tmp = a + ((b * -2.0) + (x + z)) elif y <= -1.2e-193: tmp = t_2 elif y <= 8.8e-303: tmp = t_5 elif y <= 3.1e-118: tmp = t_4 elif y <= 1.15e-9: tmp = t_5 elif y <= 4e+170: tmp = (t * (b - a)) - (y * z) else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(1.0 - t)) t_2 = Float64(Float64(t * b) + t_1) t_3 = Float64(y * Float64(b - z)) t_4 = Float64(Float64(x + Float64(t * b)) + t_1) t_5 = Float64(Float64(x + z) - Float64(b * Float64(2.0 - t))) tmp = 0.0 if (y <= -2.7e+145) tmp = t_3; elseif (y <= -3.6e+126) tmp = t_2; elseif (y <= -8e+107) tmp = t_3; elseif (y <= -1.25e-67) tmp = t_4; elseif (y <= -1.8e-137) tmp = Float64(a + Float64(Float64(b * -2.0) + Float64(x + z))); elseif (y <= -1.2e-193) tmp = t_2; elseif (y <= 8.8e-303) tmp = t_5; elseif (y <= 3.1e-118) tmp = t_4; elseif (y <= 1.15e-9) tmp = t_5; elseif (y <= 4e+170) tmp = Float64(Float64(t * Float64(b - a)) - Float64(y * z)); else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (1.0 - t); t_2 = (t * b) + t_1; t_3 = y * (b - z); t_4 = (x + (t * b)) + t_1; t_5 = (x + z) - (b * (2.0 - t)); tmp = 0.0; if (y <= -2.7e+145) tmp = t_3; elseif (y <= -3.6e+126) tmp = t_2; elseif (y <= -8e+107) tmp = t_3; elseif (y <= -1.25e-67) tmp = t_4; elseif (y <= -1.8e-137) tmp = a + ((b * -2.0) + (x + z)); elseif (y <= -1.2e-193) tmp = t_2; elseif (y <= 8.8e-303) tmp = t_5; elseif (y <= 3.1e-118) tmp = t_4; elseif (y <= 1.15e-9) tmp = t_5; elseif (y <= 4e+170) tmp = (t * (b - a)) - (y * z); else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * b), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(x + N[(t * b), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$5 = N[(N[(x + z), $MachinePrecision] - N[(b * N[(2.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.7e+145], t$95$3, If[LessEqual[y, -3.6e+126], t$95$2, If[LessEqual[y, -8e+107], t$95$3, If[LessEqual[y, -1.25e-67], t$95$4, If[LessEqual[y, -1.8e-137], N[(a + N[(N[(b * -2.0), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.2e-193], t$95$2, If[LessEqual[y, 8.8e-303], t$95$5, If[LessEqual[y, 3.1e-118], t$95$4, If[LessEqual[y, 1.15e-9], t$95$5, If[LessEqual[y, 4e+170], N[(N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
t_2 := t \cdot b + t_1\\
t_3 := y \cdot \left(b - z\right)\\
t_4 := \left(x + t \cdot b\right) + t_1\\
t_5 := \left(x + z\right) - b \cdot \left(2 - t\right)\\
\mathbf{if}\;y \leq -2.7 \cdot 10^{+145}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq -3.6 \cdot 10^{+126}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -8 \cdot 10^{+107}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq -1.25 \cdot 10^{-67}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;y \leq -1.8 \cdot 10^{-137}:\\
\;\;\;\;a + \left(b \cdot -2 + \left(x + z\right)\right)\\
\mathbf{elif}\;y \leq -1.2 \cdot 10^{-193}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 8.8 \cdot 10^{-303}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;y \leq 3.1 \cdot 10^{-118}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{-9}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;y \leq 4 \cdot 10^{+170}:\\
\;\;\;\;t \cdot \left(b - a\right) - y \cdot z\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if y < -2.70000000000000022e145 or -3.6e126 < y < -7.9999999999999998e107 or 4.00000000000000014e170 < y Initial program 92.5%
associate-+l-92.5%
*-commutative92.5%
*-commutative92.5%
sub-neg92.5%
metadata-eval92.5%
remove-double-neg92.5%
remove-double-neg92.5%
sub-neg92.5%
metadata-eval92.5%
associate--l+92.5%
Simplified92.5%
Taylor expanded in y around inf 84.8%
if -2.70000000000000022e145 < y < -3.6e126 or -1.80000000000000003e-137 < y < -1.2e-193Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around 0 94.0%
Taylor expanded in t around inf 87.6%
Taylor expanded in x around 0 87.6%
if -7.9999999999999998e107 < y < -1.25e-67 or 8.80000000000000055e-303 < y < 3.1000000000000001e-118Initial program 96.9%
associate-+l-96.9%
*-commutative96.9%
*-commutative96.9%
sub-neg96.9%
metadata-eval96.9%
remove-double-neg96.9%
remove-double-neg96.9%
sub-neg96.9%
metadata-eval96.9%
associate--l+96.9%
Simplified96.9%
Taylor expanded in z around 0 88.1%
Taylor expanded in t around inf 81.9%
if -1.25e-67 < y < -1.80000000000000003e-137Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 88.2%
if -1.2e-193 < y < 8.80000000000000055e-303 or 3.1000000000000001e-118 < y < 1.15e-9Initial program 95.6%
sub-neg95.6%
+-commutative95.6%
associate-+l+95.6%
*-commutative95.6%
distribute-rgt-neg-in95.6%
+-commutative95.6%
fma-def97.8%
neg-sub097.8%
associate--r-97.8%
neg-sub097.8%
+-commutative97.8%
sub-neg97.8%
fma-def97.8%
sub-neg97.8%
associate-+l+97.8%
metadata-eval97.8%
sub-neg97.8%
+-commutative97.8%
Simplified97.8%
Taylor expanded in y around 0 94.8%
Taylor expanded in a around 0 82.7%
if 1.15e-9 < y < 4.00000000000000014e170Initial program 94.2%
associate-+l-94.2%
*-commutative94.2%
*-commutative94.2%
sub-neg94.2%
metadata-eval94.2%
remove-double-neg94.2%
remove-double-neg94.2%
sub-neg94.2%
metadata-eval94.2%
associate--l+94.2%
Simplified94.2%
Taylor expanded in t around inf 72.1%
Taylor expanded in y around inf 66.5%
mul-1-neg66.5%
distribute-rgt-neg-in66.5%
Simplified66.5%
Final simplification81.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ x (* z (- 1.0 y))) (* y b)))
(t_2 (- (* t (- b a)) (* y z))))
(if (<= t -1.08e+117)
t_2
(if (<= t -2.9e+97)
t_1
(if (<= t -2.45e+14)
t_2
(if (<= t 1.25e-238)
(+ a (+ x (* (- y 2.0) b)))
(if (<= t 8.4e-17)
t_1
(if (<= t 3.8e+53)
(+ (+ x (* t b)) (* a (- 1.0 t)))
(if (<= t 1.25e+93) t_1 t_2)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + (z * (1.0 - y))) + (y * b);
double t_2 = (t * (b - a)) - (y * z);
double tmp;
if (t <= -1.08e+117) {
tmp = t_2;
} else if (t <= -2.9e+97) {
tmp = t_1;
} else if (t <= -2.45e+14) {
tmp = t_2;
} else if (t <= 1.25e-238) {
tmp = a + (x + ((y - 2.0) * b));
} else if (t <= 8.4e-17) {
tmp = t_1;
} else if (t <= 3.8e+53) {
tmp = (x + (t * b)) + (a * (1.0 - t));
} else if (t <= 1.25e+93) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = (x + (z * (1.0d0 - y))) + (y * b)
t_2 = (t * (b - a)) - (y * z)
if (t <= (-1.08d+117)) then
tmp = t_2
else if (t <= (-2.9d+97)) then
tmp = t_1
else if (t <= (-2.45d+14)) then
tmp = t_2
else if (t <= 1.25d-238) then
tmp = a + (x + ((y - 2.0d0) * b))
else if (t <= 8.4d-17) then
tmp = t_1
else if (t <= 3.8d+53) then
tmp = (x + (t * b)) + (a * (1.0d0 - t))
else if (t <= 1.25d+93) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + (z * (1.0 - y))) + (y * b);
double t_2 = (t * (b - a)) - (y * z);
double tmp;
if (t <= -1.08e+117) {
tmp = t_2;
} else if (t <= -2.9e+97) {
tmp = t_1;
} else if (t <= -2.45e+14) {
tmp = t_2;
} else if (t <= 1.25e-238) {
tmp = a + (x + ((y - 2.0) * b));
} else if (t <= 8.4e-17) {
tmp = t_1;
} else if (t <= 3.8e+53) {
tmp = (x + (t * b)) + (a * (1.0 - t));
} else if (t <= 1.25e+93) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + (z * (1.0 - y))) + (y * b) t_2 = (t * (b - a)) - (y * z) tmp = 0 if t <= -1.08e+117: tmp = t_2 elif t <= -2.9e+97: tmp = t_1 elif t <= -2.45e+14: tmp = t_2 elif t <= 1.25e-238: tmp = a + (x + ((y - 2.0) * b)) elif t <= 8.4e-17: tmp = t_1 elif t <= 3.8e+53: tmp = (x + (t * b)) + (a * (1.0 - t)) elif t <= 1.25e+93: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(y * b)) t_2 = Float64(Float64(t * Float64(b - a)) - Float64(y * z)) tmp = 0.0 if (t <= -1.08e+117) tmp = t_2; elseif (t <= -2.9e+97) tmp = t_1; elseif (t <= -2.45e+14) tmp = t_2; elseif (t <= 1.25e-238) tmp = Float64(a + Float64(x + Float64(Float64(y - 2.0) * b))); elseif (t <= 8.4e-17) tmp = t_1; elseif (t <= 3.8e+53) tmp = Float64(Float64(x + Float64(t * b)) + Float64(a * Float64(1.0 - t))); elseif (t <= 1.25e+93) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + (z * (1.0 - y))) + (y * b); t_2 = (t * (b - a)) - (y * z); tmp = 0.0; if (t <= -1.08e+117) tmp = t_2; elseif (t <= -2.9e+97) tmp = t_1; elseif (t <= -2.45e+14) tmp = t_2; elseif (t <= 1.25e-238) tmp = a + (x + ((y - 2.0) * b)); elseif (t <= 8.4e-17) tmp = t_1; elseif (t <= 3.8e+53) tmp = (x + (t * b)) + (a * (1.0 - t)); elseif (t <= 1.25e+93) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.08e+117], t$95$2, If[LessEqual[t, -2.9e+97], t$95$1, If[LessEqual[t, -2.45e+14], t$95$2, If[LessEqual[t, 1.25e-238], N[(a + N[(x + N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.4e-17], t$95$1, If[LessEqual[t, 3.8e+53], N[(N[(x + N[(t * b), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e+93], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + z \cdot \left(1 - y\right)\right) + y \cdot b\\
t_2 := t \cdot \left(b - a\right) - y \cdot z\\
\mathbf{if}\;t \leq -1.08 \cdot 10^{+117}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -2.9 \cdot 10^{+97}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2.45 \cdot 10^{+14}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{-238}:\\
\;\;\;\;a + \left(x + \left(y - 2\right) \cdot b\right)\\
\mathbf{elif}\;t \leq 8.4 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{+53}:\\
\;\;\;\;\left(x + t \cdot b\right) + a \cdot \left(1 - t\right)\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{+93}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.08e117 or -2.89999999999999987e97 < t < -2.45e14 or 1.25e93 < t Initial program 91.4%
associate-+l-91.4%
*-commutative91.4%
*-commutative91.4%
sub-neg91.4%
metadata-eval91.4%
remove-double-neg91.4%
remove-double-neg91.4%
sub-neg91.4%
metadata-eval91.4%
associate--l+91.4%
Simplified91.4%
Taylor expanded in t around inf 89.7%
Taylor expanded in y around inf 82.3%
mul-1-neg82.3%
distribute-rgt-neg-in82.3%
Simplified82.3%
if -1.08e117 < t < -2.89999999999999987e97 or 1.25e-238 < t < 8.39999999999999968e-17 or 3.79999999999999997e53 < t < 1.25e93Initial program 98.4%
associate-+l-98.4%
*-commutative98.4%
*-commutative98.4%
sub-neg98.4%
metadata-eval98.4%
remove-double-neg98.4%
remove-double-neg98.4%
sub-neg98.4%
metadata-eval98.4%
associate--l+98.4%
Simplified98.4%
Taylor expanded in y around inf 75.3%
mul-1-neg75.3%
*-commutative75.3%
distribute-rgt-neg-in75.3%
Simplified75.3%
if -2.45e14 < t < 1.25e-238Initial program 98.6%
associate-+l-98.6%
*-commutative98.6%
*-commutative98.6%
sub-neg98.6%
metadata-eval98.6%
remove-double-neg98.6%
remove-double-neg98.6%
sub-neg98.6%
metadata-eval98.6%
associate--l+98.6%
Simplified98.6%
Taylor expanded in z around 0 79.3%
Taylor expanded in t around 0 76.5%
if 8.39999999999999968e-17 < t < 3.79999999999999997e53Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in z around 0 86.0%
Taylor expanded in t around inf 76.7%
Final simplification78.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t)))
(t_2 (+ (* t b) t_1))
(t_3 (* y (- b z)))
(t_4 (+ x t_1)))
(if (<= y -8e+143)
t_3
(if (<= y -5e+125)
t_2
(if (<= y -3.3e+105)
t_3
(if (<= y -4e-67)
t_4
(if (<= y -1.26e-135)
(+ a (+ (* b -2.0) (+ x z)))
(if (<= y -2e-193)
t_2
(if (<= y 3.4e-9)
(- (+ x z) (* b (- 2.0 t)))
(if (<= y 5.4e+111) t_4 t_3))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double t_2 = (t * b) + t_1;
double t_3 = y * (b - z);
double t_4 = x + t_1;
double tmp;
if (y <= -8e+143) {
tmp = t_3;
} else if (y <= -5e+125) {
tmp = t_2;
} else if (y <= -3.3e+105) {
tmp = t_3;
} else if (y <= -4e-67) {
tmp = t_4;
} else if (y <= -1.26e-135) {
tmp = a + ((b * -2.0) + (x + z));
} else if (y <= -2e-193) {
tmp = t_2;
} else if (y <= 3.4e-9) {
tmp = (x + z) - (b * (2.0 - t));
} else if (y <= 5.4e+111) {
tmp = t_4;
} else {
tmp = t_3;
}
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) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: tmp
t_1 = a * (1.0d0 - t)
t_2 = (t * b) + t_1
t_3 = y * (b - z)
t_4 = x + t_1
if (y <= (-8d+143)) then
tmp = t_3
else if (y <= (-5d+125)) then
tmp = t_2
else if (y <= (-3.3d+105)) then
tmp = t_3
else if (y <= (-4d-67)) then
tmp = t_4
else if (y <= (-1.26d-135)) then
tmp = a + ((b * (-2.0d0)) + (x + z))
else if (y <= (-2d-193)) then
tmp = t_2
else if (y <= 3.4d-9) then
tmp = (x + z) - (b * (2.0d0 - t))
else if (y <= 5.4d+111) then
tmp = t_4
else
tmp = t_3
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 = a * (1.0 - t);
double t_2 = (t * b) + t_1;
double t_3 = y * (b - z);
double t_4 = x + t_1;
double tmp;
if (y <= -8e+143) {
tmp = t_3;
} else if (y <= -5e+125) {
tmp = t_2;
} else if (y <= -3.3e+105) {
tmp = t_3;
} else if (y <= -4e-67) {
tmp = t_4;
} else if (y <= -1.26e-135) {
tmp = a + ((b * -2.0) + (x + z));
} else if (y <= -2e-193) {
tmp = t_2;
} else if (y <= 3.4e-9) {
tmp = (x + z) - (b * (2.0 - t));
} else if (y <= 5.4e+111) {
tmp = t_4;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) t_2 = (t * b) + t_1 t_3 = y * (b - z) t_4 = x + t_1 tmp = 0 if y <= -8e+143: tmp = t_3 elif y <= -5e+125: tmp = t_2 elif y <= -3.3e+105: tmp = t_3 elif y <= -4e-67: tmp = t_4 elif y <= -1.26e-135: tmp = a + ((b * -2.0) + (x + z)) elif y <= -2e-193: tmp = t_2 elif y <= 3.4e-9: tmp = (x + z) - (b * (2.0 - t)) elif y <= 5.4e+111: tmp = t_4 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(1.0 - t)) t_2 = Float64(Float64(t * b) + t_1) t_3 = Float64(y * Float64(b - z)) t_4 = Float64(x + t_1) tmp = 0.0 if (y <= -8e+143) tmp = t_3; elseif (y <= -5e+125) tmp = t_2; elseif (y <= -3.3e+105) tmp = t_3; elseif (y <= -4e-67) tmp = t_4; elseif (y <= -1.26e-135) tmp = Float64(a + Float64(Float64(b * -2.0) + Float64(x + z))); elseif (y <= -2e-193) tmp = t_2; elseif (y <= 3.4e-9) tmp = Float64(Float64(x + z) - Float64(b * Float64(2.0 - t))); elseif (y <= 5.4e+111) tmp = t_4; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (1.0 - t); t_2 = (t * b) + t_1; t_3 = y * (b - z); t_4 = x + t_1; tmp = 0.0; if (y <= -8e+143) tmp = t_3; elseif (y <= -5e+125) tmp = t_2; elseif (y <= -3.3e+105) tmp = t_3; elseif (y <= -4e-67) tmp = t_4; elseif (y <= -1.26e-135) tmp = a + ((b * -2.0) + (x + z)); elseif (y <= -2e-193) tmp = t_2; elseif (y <= 3.4e-9) tmp = (x + z) - (b * (2.0 - t)); elseif (y <= 5.4e+111) tmp = t_4; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * b), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(x + t$95$1), $MachinePrecision]}, If[LessEqual[y, -8e+143], t$95$3, If[LessEqual[y, -5e+125], t$95$2, If[LessEqual[y, -3.3e+105], t$95$3, If[LessEqual[y, -4e-67], t$95$4, If[LessEqual[y, -1.26e-135], N[(a + N[(N[(b * -2.0), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2e-193], t$95$2, If[LessEqual[y, 3.4e-9], N[(N[(x + z), $MachinePrecision] - N[(b * N[(2.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.4e+111], t$95$4, t$95$3]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
t_2 := t \cdot b + t_1\\
t_3 := y \cdot \left(b - z\right)\\
t_4 := x + t_1\\
\mathbf{if}\;y \leq -8 \cdot 10^{+143}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq -5 \cdot 10^{+125}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -3.3 \cdot 10^{+105}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq -4 \cdot 10^{-67}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;y \leq -1.26 \cdot 10^{-135}:\\
\;\;\;\;a + \left(b \cdot -2 + \left(x + z\right)\right)\\
\mathbf{elif}\;y \leq -2 \cdot 10^{-193}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 3.4 \cdot 10^{-9}:\\
\;\;\;\;\left(x + z\right) - b \cdot \left(2 - t\right)\\
\mathbf{elif}\;y \leq 5.4 \cdot 10^{+111}:\\
\;\;\;\;t_4\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if y < -8.0000000000000002e143 or -4.99999999999999962e125 < y < -3.29999999999999997e105 or 5.3999999999999998e111 < y Initial program 93.7%
associate-+l-93.7%
*-commutative93.7%
*-commutative93.7%
sub-neg93.7%
metadata-eval93.7%
remove-double-neg93.7%
remove-double-neg93.7%
sub-neg93.7%
metadata-eval93.7%
associate--l+93.7%
Simplified93.7%
Taylor expanded in y around inf 79.6%
if -8.0000000000000002e143 < y < -4.99999999999999962e125 or -1.2600000000000001e-135 < y < -2.0000000000000001e-193Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around 0 94.0%
Taylor expanded in t around inf 87.6%
Taylor expanded in x around 0 87.6%
if -3.29999999999999997e105 < y < -3.99999999999999977e-67 or 3.3999999999999998e-9 < y < 5.3999999999999998e111Initial program 94.6%
associate-+l-94.6%
*-commutative94.6%
*-commutative94.6%
sub-neg94.6%
metadata-eval94.6%
remove-double-neg94.6%
remove-double-neg94.6%
sub-neg94.6%
metadata-eval94.6%
associate--l+94.6%
Simplified94.6%
Taylor expanded in z around 0 86.5%
Taylor expanded in b around 0 64.4%
if -3.99999999999999977e-67 < y < -1.2600000000000001e-135Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 88.2%
if -2.0000000000000001e-193 < y < 3.3999999999999998e-9Initial program 96.1%
sub-neg96.1%
+-commutative96.1%
associate-+l+96.1%
*-commutative96.1%
distribute-rgt-neg-in96.1%
+-commutative96.1%
fma-def97.4%
neg-sub097.4%
associate--r-97.4%
neg-sub097.4%
+-commutative97.4%
sub-neg97.4%
fma-def97.4%
sub-neg97.4%
associate-+l+97.4%
metadata-eval97.4%
sub-neg97.4%
+-commutative97.4%
Simplified97.4%
Taylor expanded in y around 0 95.6%
Taylor expanded in a around 0 74.8%
Final simplification76.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ z (+ x (* b (- t 2.0)))) (* a (- 1.0 t))))
(t_2 (* y (- b z))))
(if (<= y -3.5e+145)
t_2
(if (<= y -2.2e+126)
t_1
(if (<= y -2.7e+95)
(+ (+ x (* z (- 1.0 y))) (* y b))
(if (<= y 2.1e+164) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t));
double t_2 = y * (b - z);
double tmp;
if (y <= -3.5e+145) {
tmp = t_2;
} else if (y <= -2.2e+126) {
tmp = t_1;
} else if (y <= -2.7e+95) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (y <= 2.1e+164) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = (z + (x + (b * (t - 2.0d0)))) + (a * (1.0d0 - t))
t_2 = y * (b - z)
if (y <= (-3.5d+145)) then
tmp = t_2
else if (y <= (-2.2d+126)) then
tmp = t_1
else if (y <= (-2.7d+95)) then
tmp = (x + (z * (1.0d0 - y))) + (y * b)
else if (y <= 2.1d+164) then
tmp = t_1
else
tmp = t_2
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 = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t));
double t_2 = y * (b - z);
double tmp;
if (y <= -3.5e+145) {
tmp = t_2;
} else if (y <= -2.2e+126) {
tmp = t_1;
} else if (y <= -2.7e+95) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (y <= 2.1e+164) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t)) t_2 = y * (b - z) tmp = 0 if y <= -3.5e+145: tmp = t_2 elif y <= -2.2e+126: tmp = t_1 elif y <= -2.7e+95: tmp = (x + (z * (1.0 - y))) + (y * b) elif y <= 2.1e+164: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + Float64(x + Float64(b * Float64(t - 2.0)))) + Float64(a * Float64(1.0 - t))) t_2 = Float64(y * Float64(b - z)) tmp = 0.0 if (y <= -3.5e+145) tmp = t_2; elseif (y <= -2.2e+126) tmp = t_1; elseif (y <= -2.7e+95) tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(y * b)); elseif (y <= 2.1e+164) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t)); t_2 = y * (b - z); tmp = 0.0; if (y <= -3.5e+145) tmp = t_2; elseif (y <= -2.2e+126) tmp = t_1; elseif (y <= -2.7e+95) tmp = (x + (z * (1.0 - y))) + (y * b); elseif (y <= 2.1e+164) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + N[(x + N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.5e+145], t$95$2, If[LessEqual[y, -2.2e+126], t$95$1, If[LessEqual[y, -2.7e+95], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.1e+164], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + \left(x + b \cdot \left(t - 2\right)\right)\right) + a \cdot \left(1 - t\right)\\
t_2 := y \cdot \left(b - z\right)\\
\mathbf{if}\;y \leq -3.5 \cdot 10^{+145}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -2.2 \cdot 10^{+126}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -2.7 \cdot 10^{+95}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + y \cdot b\\
\mathbf{elif}\;y \leq 2.1 \cdot 10^{+164}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -3.5000000000000001e145 or 2.0999999999999999e164 < y Initial program 91.8%
associate-+l-91.8%
*-commutative91.8%
*-commutative91.8%
sub-neg91.8%
metadata-eval91.8%
remove-double-neg91.8%
remove-double-neg91.8%
sub-neg91.8%
metadata-eval91.8%
associate--l+91.8%
Simplified91.8%
Taylor expanded in y around inf 83.3%
if -3.5000000000000001e145 < y < -2.19999999999999999e126 or -2.7e95 < y < 2.0999999999999999e164Initial program 97.3%
sub-neg97.3%
+-commutative97.3%
associate-+l+97.3%
*-commutative97.3%
distribute-rgt-neg-in97.3%
+-commutative97.3%
fma-def98.4%
neg-sub098.4%
associate--r-98.4%
neg-sub098.4%
+-commutative98.4%
sub-neg98.4%
fma-def98.4%
sub-neg98.4%
associate-+l+98.4%
metadata-eval98.4%
sub-neg98.4%
+-commutative98.4%
Simplified98.4%
Taylor expanded in y around 0 87.6%
if -2.19999999999999999e126 < y < -2.7e95Initial program 88.9%
associate-+l-88.9%
*-commutative88.9%
*-commutative88.9%
sub-neg88.9%
metadata-eval88.9%
remove-double-neg88.9%
remove-double-neg88.9%
sub-neg88.9%
metadata-eval88.9%
associate--l+88.9%
Simplified88.9%
Taylor expanded in y around inf 100.0%
mul-1-neg100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
Simplified100.0%
Final simplification87.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (+ z a))) (t_2 (* y (- b z))) (t_3 (* t (- b a))))
(if (<= t -23000000000000.0)
t_3
(if (<= t -3.05e-120)
t_1
(if (<= t -1.85e-171)
(* (- y 2.0) b)
(if (<= t 2.25e-188)
t_1
(if (<= t 8.3e-156)
t_2
(if (<= t 4.4e-88)
t_1
(if (<= t 4.1e-18) t_2 (if (<= t 2600000.0) t_1 t_3))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z + a);
double t_2 = y * (b - z);
double t_3 = t * (b - a);
double tmp;
if (t <= -23000000000000.0) {
tmp = t_3;
} else if (t <= -3.05e-120) {
tmp = t_1;
} else if (t <= -1.85e-171) {
tmp = (y - 2.0) * b;
} else if (t <= 2.25e-188) {
tmp = t_1;
} else if (t <= 8.3e-156) {
tmp = t_2;
} else if (t <= 4.4e-88) {
tmp = t_1;
} else if (t <= 4.1e-18) {
tmp = t_2;
} else if (t <= 2600000.0) {
tmp = t_1;
} else {
tmp = t_3;
}
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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (z + a)
t_2 = y * (b - z)
t_3 = t * (b - a)
if (t <= (-23000000000000.0d0)) then
tmp = t_3
else if (t <= (-3.05d-120)) then
tmp = t_1
else if (t <= (-1.85d-171)) then
tmp = (y - 2.0d0) * b
else if (t <= 2.25d-188) then
tmp = t_1
else if (t <= 8.3d-156) then
tmp = t_2
else if (t <= 4.4d-88) then
tmp = t_1
else if (t <= 4.1d-18) then
tmp = t_2
else if (t <= 2600000.0d0) then
tmp = t_1
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z + a);
double t_2 = y * (b - z);
double t_3 = t * (b - a);
double tmp;
if (t <= -23000000000000.0) {
tmp = t_3;
} else if (t <= -3.05e-120) {
tmp = t_1;
} else if (t <= -1.85e-171) {
tmp = (y - 2.0) * b;
} else if (t <= 2.25e-188) {
tmp = t_1;
} else if (t <= 8.3e-156) {
tmp = t_2;
} else if (t <= 4.4e-88) {
tmp = t_1;
} else if (t <= 4.1e-18) {
tmp = t_2;
} else if (t <= 2600000.0) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z + a) t_2 = y * (b - z) t_3 = t * (b - a) tmp = 0 if t <= -23000000000000.0: tmp = t_3 elif t <= -3.05e-120: tmp = t_1 elif t <= -1.85e-171: tmp = (y - 2.0) * b elif t <= 2.25e-188: tmp = t_1 elif t <= 8.3e-156: tmp = t_2 elif t <= 4.4e-88: tmp = t_1 elif t <= 4.1e-18: tmp = t_2 elif t <= 2600000.0: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z + a)) t_2 = Float64(y * Float64(b - z)) t_3 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -23000000000000.0) tmp = t_3; elseif (t <= -3.05e-120) tmp = t_1; elseif (t <= -1.85e-171) tmp = Float64(Float64(y - 2.0) * b); elseif (t <= 2.25e-188) tmp = t_1; elseif (t <= 8.3e-156) tmp = t_2; elseif (t <= 4.4e-88) tmp = t_1; elseif (t <= 4.1e-18) tmp = t_2; elseif (t <= 2600000.0) tmp = t_1; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z + a); t_2 = y * (b - z); t_3 = t * (b - a); tmp = 0.0; if (t <= -23000000000000.0) tmp = t_3; elseif (t <= -3.05e-120) tmp = t_1; elseif (t <= -1.85e-171) tmp = (y - 2.0) * b; elseif (t <= 2.25e-188) tmp = t_1; elseif (t <= 8.3e-156) tmp = t_2; elseif (t <= 4.4e-88) tmp = t_1; elseif (t <= 4.1e-18) tmp = t_2; elseif (t <= 2600000.0) tmp = t_1; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z + a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -23000000000000.0], t$95$3, If[LessEqual[t, -3.05e-120], t$95$1, If[LessEqual[t, -1.85e-171], N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[t, 2.25e-188], t$95$1, If[LessEqual[t, 8.3e-156], t$95$2, If[LessEqual[t, 4.4e-88], t$95$1, If[LessEqual[t, 4.1e-18], t$95$2, If[LessEqual[t, 2600000.0], t$95$1, t$95$3]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(z + a\right)\\
t_2 := y \cdot \left(b - z\right)\\
t_3 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -23000000000000:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq -3.05 \cdot 10^{-120}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.85 \cdot 10^{-171}:\\
\;\;\;\;\left(y - 2\right) \cdot b\\
\mathbf{elif}\;t \leq 2.25 \cdot 10^{-188}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 8.3 \cdot 10^{-156}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{-88}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 4.1 \cdot 10^{-18}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 2600000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if t < -2.3e13 or 2.6e6 < t Initial program 92.9%
associate-+l-92.9%
*-commutative92.9%
*-commutative92.9%
sub-neg92.9%
metadata-eval92.9%
remove-double-neg92.9%
remove-double-neg92.9%
sub-neg92.9%
metadata-eval92.9%
associate--l+92.9%
Simplified92.9%
Taylor expanded in t around inf 69.9%
if -2.3e13 < t < -3.05e-120 or -1.85000000000000006e-171 < t < 2.24999999999999997e-188 or 8.29999999999999993e-156 < t < 4.4000000000000001e-88 or 4.0999999999999998e-18 < t < 2.6e6Initial program 99.0%
sub-neg99.0%
+-commutative99.0%
associate-+l+99.0%
*-commutative99.0%
distribute-rgt-neg-in99.0%
+-commutative99.0%
fma-def99.0%
neg-sub099.0%
associate--r-99.0%
neg-sub099.0%
+-commutative99.0%
sub-neg99.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 73.0%
Taylor expanded in b around 0 61.8%
associate-+r+61.8%
fma-udef61.8%
Simplified61.8%
Taylor expanded in t around 0 60.3%
+-commutative60.3%
Simplified60.3%
if -3.05e-120 < t < -1.85000000000000006e-171Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 99.3%
Taylor expanded in t around 0 99.3%
if 2.24999999999999997e-188 < t < 8.29999999999999993e-156 or 4.4000000000000001e-88 < t < 4.0999999999999998e-18Initial program 95.8%
associate-+l-95.8%
*-commutative95.8%
*-commutative95.8%
sub-neg95.8%
metadata-eval95.8%
remove-double-neg95.8%
remove-double-neg95.8%
sub-neg95.8%
metadata-eval95.8%
associate--l+95.8%
Simplified95.8%
Taylor expanded in y around inf 63.3%
Final simplification66.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y))))
(t_2 (- x (* t a)))
(t_3 (* b (- (+ t y) 2.0))))
(if (<= b -460.0)
t_3
(if (<= b -5.8e-167)
t_1
(if (<= b -1.06e-232)
(* a (- 1.0 t))
(if (<= b -2.2e-296)
t_1
(if (<= b 8.2e-266)
t_2
(if (<= b 7e-124) t_1 (if (<= b 8e-25) t_2 t_3)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = x - (t * a);
double t_3 = b * ((t + y) - 2.0);
double tmp;
if (b <= -460.0) {
tmp = t_3;
} else if (b <= -5.8e-167) {
tmp = t_1;
} else if (b <= -1.06e-232) {
tmp = a * (1.0 - t);
} else if (b <= -2.2e-296) {
tmp = t_1;
} else if (b <= 8.2e-266) {
tmp = t_2;
} else if (b <= 7e-124) {
tmp = t_1;
} else if (b <= 8e-25) {
tmp = t_2;
} else {
tmp = t_3;
}
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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (z * (1.0d0 - y))
t_2 = x - (t * a)
t_3 = b * ((t + y) - 2.0d0)
if (b <= (-460.0d0)) then
tmp = t_3
else if (b <= (-5.8d-167)) then
tmp = t_1
else if (b <= (-1.06d-232)) then
tmp = a * (1.0d0 - t)
else if (b <= (-2.2d-296)) then
tmp = t_1
else if (b <= 8.2d-266) then
tmp = t_2
else if (b <= 7d-124) then
tmp = t_1
else if (b <= 8d-25) then
tmp = t_2
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = x - (t * a);
double t_3 = b * ((t + y) - 2.0);
double tmp;
if (b <= -460.0) {
tmp = t_3;
} else if (b <= -5.8e-167) {
tmp = t_1;
} else if (b <= -1.06e-232) {
tmp = a * (1.0 - t);
} else if (b <= -2.2e-296) {
tmp = t_1;
} else if (b <= 8.2e-266) {
tmp = t_2;
} else if (b <= 7e-124) {
tmp = t_1;
} else if (b <= 8e-25) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = x - (t * a) t_3 = b * ((t + y) - 2.0) tmp = 0 if b <= -460.0: tmp = t_3 elif b <= -5.8e-167: tmp = t_1 elif b <= -1.06e-232: tmp = a * (1.0 - t) elif b <= -2.2e-296: tmp = t_1 elif b <= 8.2e-266: tmp = t_2 elif b <= 7e-124: tmp = t_1 elif b <= 8e-25: tmp = t_2 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z * Float64(1.0 - y))) t_2 = Float64(x - Float64(t * a)) t_3 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -460.0) tmp = t_3; elseif (b <= -5.8e-167) tmp = t_1; elseif (b <= -1.06e-232) tmp = Float64(a * Float64(1.0 - t)); elseif (b <= -2.2e-296) tmp = t_1; elseif (b <= 8.2e-266) tmp = t_2; elseif (b <= 7e-124) tmp = t_1; elseif (b <= 8e-25) tmp = t_2; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z * (1.0 - y)); t_2 = x - (t * a); t_3 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -460.0) tmp = t_3; elseif (b <= -5.8e-167) tmp = t_1; elseif (b <= -1.06e-232) tmp = a * (1.0 - t); elseif (b <= -2.2e-296) tmp = t_1; elseif (b <= 8.2e-266) tmp = t_2; elseif (b <= 7e-124) tmp = t_1; elseif (b <= 8e-25) tmp = t_2; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -460.0], t$95$3, If[LessEqual[b, -5.8e-167], t$95$1, If[LessEqual[b, -1.06e-232], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -2.2e-296], t$95$1, If[LessEqual[b, 8.2e-266], t$95$2, If[LessEqual[b, 7e-124], t$95$1, If[LessEqual[b, 8e-25], t$95$2, t$95$3]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := x - t \cdot a\\
t_3 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -460:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq -5.8 \cdot 10^{-167}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -1.06 \cdot 10^{-232}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;b \leq -2.2 \cdot 10^{-296}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 8.2 \cdot 10^{-266}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq 7 \cdot 10^{-124}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 8 \cdot 10^{-25}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if b < -460 or 8.00000000000000031e-25 < b Initial program 91.7%
associate-+l-91.7%
*-commutative91.7%
*-commutative91.7%
sub-neg91.7%
metadata-eval91.7%
remove-double-neg91.7%
remove-double-neg91.7%
sub-neg91.7%
metadata-eval91.7%
associate--l+91.7%
Simplified91.7%
Taylor expanded in b around inf 67.9%
if -460 < b < -5.80000000000000005e-167 or -1.05999999999999994e-232 < b < -2.20000000000000012e-296 or 8.2000000000000006e-266 < b < 6.9999999999999997e-124Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 87.1%
Taylor expanded in t around 0 71.1%
if -5.80000000000000005e-167 < b < -1.05999999999999994e-232Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in a around inf 75.7%
if -2.20000000000000012e-296 < b < 8.2000000000000006e-266 or 6.9999999999999997e-124 < b < 8.00000000000000031e-25Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 91.4%
Taylor expanded in b around 0 84.0%
associate-+r+84.0%
fma-udef84.0%
Simplified84.0%
Taylor expanded in t around inf 73.2%
mul-1-neg73.2%
*-commutative73.2%
distribute-rgt-neg-in73.2%
Simplified73.2%
Final simplification69.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t))))
(if (<= a -6.2e+22)
t_1
(if (<= a -3.5e-49)
(* y b)
(if (<= a -1.55e-239)
(+ x z)
(if (<= a -4.4e-281)
(* z (- y))
(if (<= a 6.4e-172)
(+ x z)
(if (<= a 25000000.0)
(* y b)
(if (<= a 6.6e+146) (+ x z) t_1)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double tmp;
if (a <= -6.2e+22) {
tmp = t_1;
} else if (a <= -3.5e-49) {
tmp = y * b;
} else if (a <= -1.55e-239) {
tmp = x + z;
} else if (a <= -4.4e-281) {
tmp = z * -y;
} else if (a <= 6.4e-172) {
tmp = x + z;
} else if (a <= 25000000.0) {
tmp = y * b;
} else if (a <= 6.6e+146) {
tmp = x + z;
} 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 = a * (1.0d0 - t)
if (a <= (-6.2d+22)) then
tmp = t_1
else if (a <= (-3.5d-49)) then
tmp = y * b
else if (a <= (-1.55d-239)) then
tmp = x + z
else if (a <= (-4.4d-281)) then
tmp = z * -y
else if (a <= 6.4d-172) then
tmp = x + z
else if (a <= 25000000.0d0) then
tmp = y * b
else if (a <= 6.6d+146) then
tmp = x + z
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 = a * (1.0 - t);
double tmp;
if (a <= -6.2e+22) {
tmp = t_1;
} else if (a <= -3.5e-49) {
tmp = y * b;
} else if (a <= -1.55e-239) {
tmp = x + z;
} else if (a <= -4.4e-281) {
tmp = z * -y;
} else if (a <= 6.4e-172) {
tmp = x + z;
} else if (a <= 25000000.0) {
tmp = y * b;
} else if (a <= 6.6e+146) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) tmp = 0 if a <= -6.2e+22: tmp = t_1 elif a <= -3.5e-49: tmp = y * b elif a <= -1.55e-239: tmp = x + z elif a <= -4.4e-281: tmp = z * -y elif a <= 6.4e-172: tmp = x + z elif a <= 25000000.0: tmp = y * b elif a <= 6.6e+146: tmp = x + z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(1.0 - t)) tmp = 0.0 if (a <= -6.2e+22) tmp = t_1; elseif (a <= -3.5e-49) tmp = Float64(y * b); elseif (a <= -1.55e-239) tmp = Float64(x + z); elseif (a <= -4.4e-281) tmp = Float64(z * Float64(-y)); elseif (a <= 6.4e-172) tmp = Float64(x + z); elseif (a <= 25000000.0) tmp = Float64(y * b); elseif (a <= 6.6e+146) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (1.0 - t); tmp = 0.0; if (a <= -6.2e+22) tmp = t_1; elseif (a <= -3.5e-49) tmp = y * b; elseif (a <= -1.55e-239) tmp = x + z; elseif (a <= -4.4e-281) tmp = z * -y; elseif (a <= 6.4e-172) tmp = x + z; elseif (a <= 25000000.0) tmp = y * b; elseif (a <= 6.6e+146) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6.2e+22], t$95$1, If[LessEqual[a, -3.5e-49], N[(y * b), $MachinePrecision], If[LessEqual[a, -1.55e-239], N[(x + z), $MachinePrecision], If[LessEqual[a, -4.4e-281], N[(z * (-y)), $MachinePrecision], If[LessEqual[a, 6.4e-172], N[(x + z), $MachinePrecision], If[LessEqual[a, 25000000.0], N[(y * b), $MachinePrecision], If[LessEqual[a, 6.6e+146], N[(x + z), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;a \leq -6.2 \cdot 10^{+22}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -3.5 \cdot 10^{-49}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;a \leq -1.55 \cdot 10^{-239}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;a \leq -4.4 \cdot 10^{-281}:\\
\;\;\;\;z \cdot \left(-y\right)\\
\mathbf{elif}\;a \leq 6.4 \cdot 10^{-172}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;a \leq 25000000:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;a \leq 6.6 \cdot 10^{+146}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -6.2000000000000004e22 or 6.60000000000000032e146 < a Initial program 92.4%
associate-+l-92.4%
*-commutative92.4%
*-commutative92.4%
sub-neg92.4%
metadata-eval92.4%
remove-double-neg92.4%
remove-double-neg92.4%
sub-neg92.4%
metadata-eval92.4%
associate--l+92.4%
Simplified92.4%
Taylor expanded in a around inf 69.9%
if -6.2000000000000004e22 < a < -3.50000000000000006e-49 or 6.4000000000000003e-172 < a < 2.5e7Initial program 98.3%
associate-+l-98.3%
*-commutative98.3%
*-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
remove-double-neg98.3%
remove-double-neg98.3%
sub-neg98.3%
metadata-eval98.3%
associate--l+98.3%
Simplified98.3%
Taylor expanded in z around 0 75.1%
Taylor expanded in y around inf 39.2%
if -3.50000000000000006e-49 < a < -1.54999999999999993e-239 or -4.40000000000000008e-281 < a < 6.4000000000000003e-172 or 2.5e7 < a < 6.60000000000000032e146Initial program 97.9%
sub-neg97.9%
+-commutative97.9%
associate-+l+97.9%
*-commutative97.9%
distribute-rgt-neg-in97.9%
+-commutative97.9%
fma-def97.9%
neg-sub097.9%
associate--r-97.9%
neg-sub097.9%
+-commutative97.9%
sub-neg97.9%
fma-def98.9%
sub-neg98.9%
associate-+l+98.9%
metadata-eval98.9%
sub-neg98.9%
+-commutative98.9%
Simplified98.9%
Taylor expanded in y around 0 78.7%
Taylor expanded in b around 0 49.5%
associate-+r+49.5%
fma-udef49.5%
Simplified49.5%
Taylor expanded in a around 0 42.7%
if -1.54999999999999993e-239 < a < -4.40000000000000008e-281Initial program 88.9%
associate-+l-88.9%
*-commutative88.9%
*-commutative88.9%
sub-neg88.9%
metadata-eval88.9%
remove-double-neg88.9%
remove-double-neg88.9%
sub-neg88.9%
metadata-eval88.9%
associate--l+88.9%
Simplified88.9%
Taylor expanded in z around inf 68.2%
Taylor expanded in y around inf 57.9%
mul-1-neg57.9%
distribute-rgt-neg-in57.9%
Simplified57.9%
Final simplification52.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (+ z a))) (t_2 (* t (- b a))))
(if (<= t -3400000000000.0)
t_2
(if (<= t -3.9e-82)
(+ a (+ x (* b -2.0)))
(if (<= t 1.8e-188)
t_1
(if (<= t 5.7e-157)
(* y (- b z))
(if (<= t 4.2e-86)
t_1
(if (<= t 7.2e-63)
(* b (- (+ t y) 2.0))
(if (<= t 3000000.0) t_1 t_2)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z + a);
double t_2 = t * (b - a);
double tmp;
if (t <= -3400000000000.0) {
tmp = t_2;
} else if (t <= -3.9e-82) {
tmp = a + (x + (b * -2.0));
} else if (t <= 1.8e-188) {
tmp = t_1;
} else if (t <= 5.7e-157) {
tmp = y * (b - z);
} else if (t <= 4.2e-86) {
tmp = t_1;
} else if (t <= 7.2e-63) {
tmp = b * ((t + y) - 2.0);
} else if (t <= 3000000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = x + (z + a)
t_2 = t * (b - a)
if (t <= (-3400000000000.0d0)) then
tmp = t_2
else if (t <= (-3.9d-82)) then
tmp = a + (x + (b * (-2.0d0)))
else if (t <= 1.8d-188) then
tmp = t_1
else if (t <= 5.7d-157) then
tmp = y * (b - z)
else if (t <= 4.2d-86) then
tmp = t_1
else if (t <= 7.2d-63) then
tmp = b * ((t + y) - 2.0d0)
else if (t <= 3000000.0d0) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z + a);
double t_2 = t * (b - a);
double tmp;
if (t <= -3400000000000.0) {
tmp = t_2;
} else if (t <= -3.9e-82) {
tmp = a + (x + (b * -2.0));
} else if (t <= 1.8e-188) {
tmp = t_1;
} else if (t <= 5.7e-157) {
tmp = y * (b - z);
} else if (t <= 4.2e-86) {
tmp = t_1;
} else if (t <= 7.2e-63) {
tmp = b * ((t + y) - 2.0);
} else if (t <= 3000000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z + a) t_2 = t * (b - a) tmp = 0 if t <= -3400000000000.0: tmp = t_2 elif t <= -3.9e-82: tmp = a + (x + (b * -2.0)) elif t <= 1.8e-188: tmp = t_1 elif t <= 5.7e-157: tmp = y * (b - z) elif t <= 4.2e-86: tmp = t_1 elif t <= 7.2e-63: tmp = b * ((t + y) - 2.0) elif t <= 3000000.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z + a)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -3400000000000.0) tmp = t_2; elseif (t <= -3.9e-82) tmp = Float64(a + Float64(x + Float64(b * -2.0))); elseif (t <= 1.8e-188) tmp = t_1; elseif (t <= 5.7e-157) tmp = Float64(y * Float64(b - z)); elseif (t <= 4.2e-86) tmp = t_1; elseif (t <= 7.2e-63) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); elseif (t <= 3000000.0) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z + a); t_2 = t * (b - a); tmp = 0.0; if (t <= -3400000000000.0) tmp = t_2; elseif (t <= -3.9e-82) tmp = a + (x + (b * -2.0)); elseif (t <= 1.8e-188) tmp = t_1; elseif (t <= 5.7e-157) tmp = y * (b - z); elseif (t <= 4.2e-86) tmp = t_1; elseif (t <= 7.2e-63) tmp = b * ((t + y) - 2.0); elseif (t <= 3000000.0) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z + a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3400000000000.0], t$95$2, If[LessEqual[t, -3.9e-82], N[(a + N[(x + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.8e-188], t$95$1, If[LessEqual[t, 5.7e-157], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.2e-86], t$95$1, If[LessEqual[t, 7.2e-63], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3000000.0], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(z + a\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -3400000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -3.9 \cdot 10^{-82}:\\
\;\;\;\;a + \left(x + b \cdot -2\right)\\
\mathbf{elif}\;t \leq 1.8 \cdot 10^{-188}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 5.7 \cdot 10^{-157}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq 4.2 \cdot 10^{-86}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 7.2 \cdot 10^{-63}:\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{elif}\;t \leq 3000000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -3.4e12 or 3e6 < t Initial program 92.9%
associate-+l-92.9%
*-commutative92.9%
*-commutative92.9%
sub-neg92.9%
metadata-eval92.9%
remove-double-neg92.9%
remove-double-neg92.9%
sub-neg92.9%
metadata-eval92.9%
associate--l+92.9%
Simplified92.9%
Taylor expanded in t around inf 69.9%
if -3.4e12 < t < -3.89999999999999973e-82Initial program 96.4%
sub-neg96.4%
+-commutative96.4%
associate-+l+96.4%
*-commutative96.4%
distribute-rgt-neg-in96.4%
+-commutative96.4%
fma-def96.4%
neg-sub096.4%
associate--r-96.4%
neg-sub096.4%
+-commutative96.4%
sub-neg96.4%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 72.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in z around 0 59.5%
if -3.89999999999999973e-82 < t < 1.7999999999999998e-188 or 5.69999999999999998e-157 < t < 4.2e-86 or 7.20000000000000016e-63 < t < 3e6Initial program 98.8%
sub-neg98.8%
+-commutative98.8%
associate-+l+98.8%
*-commutative98.8%
distribute-rgt-neg-in98.8%
+-commutative98.8%
fma-def98.8%
neg-sub098.8%
associate--r-98.8%
neg-sub098.8%
+-commutative98.8%
sub-neg98.8%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 67.8%
Taylor expanded in b around 0 60.7%
associate-+r+60.7%
fma-udef60.7%
Simplified60.7%
Taylor expanded in t around 0 60.6%
+-commutative60.6%
Simplified60.6%
if 1.7999999999999998e-188 < t < 5.69999999999999998e-157Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in y around inf 67.2%
if 4.2e-86 < t < 7.20000000000000016e-63Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 68.5%
Final simplification65.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (+ z a))) (t_2 (* t (- b a))) (t_3 (* y (- b z))))
(if (<= t -8400000000000.0)
t_2
(if (<= t -1.6e-79)
(+ a (+ x (* b -2.0)))
(if (<= t 1.15e-188)
t_1
(if (<= t 2.4e-157)
t_3
(if (<= t 8.8e-79)
(+ a (+ z (* b -2.0)))
(if (<= t 5.9e-18) t_3 (if (<= t 5000000.0) t_1 t_2)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z + a);
double t_2 = t * (b - a);
double t_3 = y * (b - z);
double tmp;
if (t <= -8400000000000.0) {
tmp = t_2;
} else if (t <= -1.6e-79) {
tmp = a + (x + (b * -2.0));
} else if (t <= 1.15e-188) {
tmp = t_1;
} else if (t <= 2.4e-157) {
tmp = t_3;
} else if (t <= 8.8e-79) {
tmp = a + (z + (b * -2.0));
} else if (t <= 5.9e-18) {
tmp = t_3;
} else if (t <= 5000000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (z + a)
t_2 = t * (b - a)
t_3 = y * (b - z)
if (t <= (-8400000000000.0d0)) then
tmp = t_2
else if (t <= (-1.6d-79)) then
tmp = a + (x + (b * (-2.0d0)))
else if (t <= 1.15d-188) then
tmp = t_1
else if (t <= 2.4d-157) then
tmp = t_3
else if (t <= 8.8d-79) then
tmp = a + (z + (b * (-2.0d0)))
else if (t <= 5.9d-18) then
tmp = t_3
else if (t <= 5000000.0d0) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z + a);
double t_2 = t * (b - a);
double t_3 = y * (b - z);
double tmp;
if (t <= -8400000000000.0) {
tmp = t_2;
} else if (t <= -1.6e-79) {
tmp = a + (x + (b * -2.0));
} else if (t <= 1.15e-188) {
tmp = t_1;
} else if (t <= 2.4e-157) {
tmp = t_3;
} else if (t <= 8.8e-79) {
tmp = a + (z + (b * -2.0));
} else if (t <= 5.9e-18) {
tmp = t_3;
} else if (t <= 5000000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z + a) t_2 = t * (b - a) t_3 = y * (b - z) tmp = 0 if t <= -8400000000000.0: tmp = t_2 elif t <= -1.6e-79: tmp = a + (x + (b * -2.0)) elif t <= 1.15e-188: tmp = t_1 elif t <= 2.4e-157: tmp = t_3 elif t <= 8.8e-79: tmp = a + (z + (b * -2.0)) elif t <= 5.9e-18: tmp = t_3 elif t <= 5000000.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z + a)) t_2 = Float64(t * Float64(b - a)) t_3 = Float64(y * Float64(b - z)) tmp = 0.0 if (t <= -8400000000000.0) tmp = t_2; elseif (t <= -1.6e-79) tmp = Float64(a + Float64(x + Float64(b * -2.0))); elseif (t <= 1.15e-188) tmp = t_1; elseif (t <= 2.4e-157) tmp = t_3; elseif (t <= 8.8e-79) tmp = Float64(a + Float64(z + Float64(b * -2.0))); elseif (t <= 5.9e-18) tmp = t_3; elseif (t <= 5000000.0) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z + a); t_2 = t * (b - a); t_3 = y * (b - z); tmp = 0.0; if (t <= -8400000000000.0) tmp = t_2; elseif (t <= -1.6e-79) tmp = a + (x + (b * -2.0)); elseif (t <= 1.15e-188) tmp = t_1; elseif (t <= 2.4e-157) tmp = t_3; elseif (t <= 8.8e-79) tmp = a + (z + (b * -2.0)); elseif (t <= 5.9e-18) tmp = t_3; elseif (t <= 5000000.0) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z + a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8400000000000.0], t$95$2, If[LessEqual[t, -1.6e-79], N[(a + N[(x + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.15e-188], t$95$1, If[LessEqual[t, 2.4e-157], t$95$3, If[LessEqual[t, 8.8e-79], N[(a + N[(z + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.9e-18], t$95$3, If[LessEqual[t, 5000000.0], t$95$1, t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(z + a\right)\\
t_2 := t \cdot \left(b - a\right)\\
t_3 := y \cdot \left(b - z\right)\\
\mathbf{if}\;t \leq -8400000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.6 \cdot 10^{-79}:\\
\;\;\;\;a + \left(x + b \cdot -2\right)\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-188}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-157}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 8.8 \cdot 10^{-79}:\\
\;\;\;\;a + \left(z + b \cdot -2\right)\\
\mathbf{elif}\;t \leq 5.9 \cdot 10^{-18}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 5000000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -8.4e12 or 5e6 < t Initial program 92.9%
associate-+l-92.9%
*-commutative92.9%
*-commutative92.9%
sub-neg92.9%
metadata-eval92.9%
remove-double-neg92.9%
remove-double-neg92.9%
sub-neg92.9%
metadata-eval92.9%
associate--l+92.9%
Simplified92.9%
Taylor expanded in t around inf 69.9%
if -8.4e12 < t < -1.59999999999999994e-79Initial program 96.4%
sub-neg96.4%
+-commutative96.4%
associate-+l+96.4%
*-commutative96.4%
distribute-rgt-neg-in96.4%
+-commutative96.4%
fma-def96.4%
neg-sub096.4%
associate--r-96.4%
neg-sub096.4%
+-commutative96.4%
sub-neg96.4%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 72.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in z around 0 59.5%
if -1.59999999999999994e-79 < t < 1.15e-188 or 5.90000000000000019e-18 < t < 5e6Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 68.9%
Taylor expanded in b around 0 62.6%
associate-+r+62.6%
fma-udef62.6%
Simplified62.6%
Taylor expanded in t around 0 62.5%
+-commutative62.5%
Simplified62.5%
if 1.15e-188 < t < 2.4e-157 or 8.7999999999999995e-79 < t < 5.90000000000000019e-18Initial program 95.5%
associate-+l-95.5%
*-commutative95.5%
*-commutative95.5%
sub-neg95.5%
metadata-eval95.5%
remove-double-neg95.5%
remove-double-neg95.5%
sub-neg95.5%
metadata-eval95.5%
associate--l+95.5%
Simplified95.5%
Taylor expanded in y around inf 68.7%
if 2.4e-157 < t < 8.7999999999999995e-79Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 78.4%
Taylor expanded in t around 0 78.4%
Taylor expanded in x around 0 71.5%
Final simplification66.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* a (- 1.0 t))))
(t_2 (* b (- (+ t y) 2.0)))
(t_3 (+ x (* z (- 1.0 y)))))
(if (<= b -4.9e-11)
t_2
(if (<= b -8.5e-237)
t_1
(if (<= b -5.6e-295)
t_3
(if (<= b 8.5e-266)
t_1
(if (<= b 2.6e-128) t_3 (if (<= b 1e-24) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * (1.0 - t));
double t_2 = b * ((t + y) - 2.0);
double t_3 = x + (z * (1.0 - y));
double tmp;
if (b <= -4.9e-11) {
tmp = t_2;
} else if (b <= -8.5e-237) {
tmp = t_1;
} else if (b <= -5.6e-295) {
tmp = t_3;
} else if (b <= 8.5e-266) {
tmp = t_1;
} else if (b <= 2.6e-128) {
tmp = t_3;
} else if (b <= 1e-24) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (a * (1.0d0 - t))
t_2 = b * ((t + y) - 2.0d0)
t_3 = x + (z * (1.0d0 - y))
if (b <= (-4.9d-11)) then
tmp = t_2
else if (b <= (-8.5d-237)) then
tmp = t_1
else if (b <= (-5.6d-295)) then
tmp = t_3
else if (b <= 8.5d-266) then
tmp = t_1
else if (b <= 2.6d-128) then
tmp = t_3
else if (b <= 1d-24) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * (1.0 - t));
double t_2 = b * ((t + y) - 2.0);
double t_3 = x + (z * (1.0 - y));
double tmp;
if (b <= -4.9e-11) {
tmp = t_2;
} else if (b <= -8.5e-237) {
tmp = t_1;
} else if (b <= -5.6e-295) {
tmp = t_3;
} else if (b <= 8.5e-266) {
tmp = t_1;
} else if (b <= 2.6e-128) {
tmp = t_3;
} else if (b <= 1e-24) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (a * (1.0 - t)) t_2 = b * ((t + y) - 2.0) t_3 = x + (z * (1.0 - y)) tmp = 0 if b <= -4.9e-11: tmp = t_2 elif b <= -8.5e-237: tmp = t_1 elif b <= -5.6e-295: tmp = t_3 elif b <= 8.5e-266: tmp = t_1 elif b <= 2.6e-128: tmp = t_3 elif b <= 1e-24: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(a * Float64(1.0 - t))) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) t_3 = Float64(x + Float64(z * Float64(1.0 - y))) tmp = 0.0 if (b <= -4.9e-11) tmp = t_2; elseif (b <= -8.5e-237) tmp = t_1; elseif (b <= -5.6e-295) tmp = t_3; elseif (b <= 8.5e-266) tmp = t_1; elseif (b <= 2.6e-128) tmp = t_3; elseif (b <= 1e-24) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (a * (1.0 - t)); t_2 = b * ((t + y) - 2.0); t_3 = x + (z * (1.0 - y)); tmp = 0.0; if (b <= -4.9e-11) tmp = t_2; elseif (b <= -8.5e-237) tmp = t_1; elseif (b <= -5.6e-295) tmp = t_3; elseif (b <= 8.5e-266) tmp = t_1; elseif (b <= 2.6e-128) tmp = t_3; elseif (b <= 1e-24) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.9e-11], t$95$2, If[LessEqual[b, -8.5e-237], t$95$1, If[LessEqual[b, -5.6e-295], t$95$3, If[LessEqual[b, 8.5e-266], t$95$1, If[LessEqual[b, 2.6e-128], t$95$3, If[LessEqual[b, 1e-24], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + a \cdot \left(1 - t\right)\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
t_3 := x + z \cdot \left(1 - y\right)\\
\mathbf{if}\;b \leq -4.9 \cdot 10^{-11}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -8.5 \cdot 10^{-237}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -5.6 \cdot 10^{-295}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 8.5 \cdot 10^{-266}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 2.6 \cdot 10^{-128}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 10^{-24}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -4.8999999999999999e-11 or 9.99999999999999924e-25 < b Initial program 91.8%
associate-+l-91.8%
*-commutative91.8%
*-commutative91.8%
sub-neg91.8%
metadata-eval91.8%
remove-double-neg91.8%
remove-double-neg91.8%
sub-neg91.8%
metadata-eval91.8%
associate--l+91.8%
Simplified91.8%
Taylor expanded in b around inf 67.4%
if -4.8999999999999999e-11 < b < -8.49999999999999951e-237 or -5.5999999999999998e-295 < b < 8.5000000000000002e-266 or 2.59999999999999981e-128 < b < 9.99999999999999924e-25Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in z around 0 80.7%
Taylor expanded in b around 0 71.9%
if -8.49999999999999951e-237 < b < -5.5999999999999998e-295 or 8.5000000000000002e-266 < b < 2.59999999999999981e-128Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 87.4%
Taylor expanded in t around 0 78.0%
Final simplification70.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* a (- 1.0 t)))) (t_2 (* y (- b z))))
(if (<= y -7.2e+106)
t_2
(if (<= y -2.25e-64)
t_1
(if (<= y -4.8e-138)
(+ a (+ (* b -2.0) (+ x z)))
(if (<= y -1.9e-186)
(* t (- b a))
(if (<= y 3.5e-9)
(- (+ x z) (* b (- 2.0 t)))
(if (<= y 5.8e+111) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * (1.0 - t));
double t_2 = y * (b - z);
double tmp;
if (y <= -7.2e+106) {
tmp = t_2;
} else if (y <= -2.25e-64) {
tmp = t_1;
} else if (y <= -4.8e-138) {
tmp = a + ((b * -2.0) + (x + z));
} else if (y <= -1.9e-186) {
tmp = t * (b - a);
} else if (y <= 3.5e-9) {
tmp = (x + z) - (b * (2.0 - t));
} else if (y <= 5.8e+111) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = x + (a * (1.0d0 - t))
t_2 = y * (b - z)
if (y <= (-7.2d+106)) then
tmp = t_2
else if (y <= (-2.25d-64)) then
tmp = t_1
else if (y <= (-4.8d-138)) then
tmp = a + ((b * (-2.0d0)) + (x + z))
else if (y <= (-1.9d-186)) then
tmp = t * (b - a)
else if (y <= 3.5d-9) then
tmp = (x + z) - (b * (2.0d0 - t))
else if (y <= 5.8d+111) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * (1.0 - t));
double t_2 = y * (b - z);
double tmp;
if (y <= -7.2e+106) {
tmp = t_2;
} else if (y <= -2.25e-64) {
tmp = t_1;
} else if (y <= -4.8e-138) {
tmp = a + ((b * -2.0) + (x + z));
} else if (y <= -1.9e-186) {
tmp = t * (b - a);
} else if (y <= 3.5e-9) {
tmp = (x + z) - (b * (2.0 - t));
} else if (y <= 5.8e+111) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (a * (1.0 - t)) t_2 = y * (b - z) tmp = 0 if y <= -7.2e+106: tmp = t_2 elif y <= -2.25e-64: tmp = t_1 elif y <= -4.8e-138: tmp = a + ((b * -2.0) + (x + z)) elif y <= -1.9e-186: tmp = t * (b - a) elif y <= 3.5e-9: tmp = (x + z) - (b * (2.0 - t)) elif y <= 5.8e+111: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(a * Float64(1.0 - t))) t_2 = Float64(y * Float64(b - z)) tmp = 0.0 if (y <= -7.2e+106) tmp = t_2; elseif (y <= -2.25e-64) tmp = t_1; elseif (y <= -4.8e-138) tmp = Float64(a + Float64(Float64(b * -2.0) + Float64(x + z))); elseif (y <= -1.9e-186) tmp = Float64(t * Float64(b - a)); elseif (y <= 3.5e-9) tmp = Float64(Float64(x + z) - Float64(b * Float64(2.0 - t))); elseif (y <= 5.8e+111) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (a * (1.0 - t)); t_2 = y * (b - z); tmp = 0.0; if (y <= -7.2e+106) tmp = t_2; elseif (y <= -2.25e-64) tmp = t_1; elseif (y <= -4.8e-138) tmp = a + ((b * -2.0) + (x + z)); elseif (y <= -1.9e-186) tmp = t * (b - a); elseif (y <= 3.5e-9) tmp = (x + z) - (b * (2.0 - t)); elseif (y <= 5.8e+111) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -7.2e+106], t$95$2, If[LessEqual[y, -2.25e-64], t$95$1, If[LessEqual[y, -4.8e-138], N[(a + N[(N[(b * -2.0), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.9e-186], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.5e-9], N[(N[(x + z), $MachinePrecision] - N[(b * N[(2.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.8e+111], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + a \cdot \left(1 - t\right)\\
t_2 := y \cdot \left(b - z\right)\\
\mathbf{if}\;y \leq -7.2 \cdot 10^{+106}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -2.25 \cdot 10^{-64}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -4.8 \cdot 10^{-138}:\\
\;\;\;\;a + \left(b \cdot -2 + \left(x + z\right)\right)\\
\mathbf{elif}\;y \leq -1.9 \cdot 10^{-186}:\\
\;\;\;\;t \cdot \left(b - a\right)\\
\mathbf{elif}\;y \leq 3.5 \cdot 10^{-9}:\\
\;\;\;\;\left(x + z\right) - b \cdot \left(2 - t\right)\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+111}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -7.2000000000000002e106 or 5.7999999999999999e111 < y Initial program 94.2%
associate-+l-94.2%
*-commutative94.2%
*-commutative94.2%
sub-neg94.2%
metadata-eval94.2%
remove-double-neg94.2%
remove-double-neg94.2%
sub-neg94.2%
metadata-eval94.2%
associate--l+94.2%
Simplified94.2%
Taylor expanded in y around inf 74.6%
if -7.2000000000000002e106 < y < -2.25000000000000005e-64 or 3.4999999999999999e-9 < y < 5.7999999999999999e111Initial program 94.6%
associate-+l-94.6%
*-commutative94.6%
*-commutative94.6%
sub-neg94.6%
metadata-eval94.6%
remove-double-neg94.6%
remove-double-neg94.6%
sub-neg94.6%
metadata-eval94.6%
associate--l+94.6%
Simplified94.6%
Taylor expanded in z around 0 86.5%
Taylor expanded in b around 0 64.4%
if -2.25000000000000005e-64 < y < -4.7999999999999998e-138Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 88.2%
if -4.7999999999999998e-138 < y < -1.89999999999999987e-186Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 80.1%
if -1.89999999999999987e-186 < y < 3.4999999999999999e-9Initial program 96.1%
sub-neg96.1%
+-commutative96.1%
associate-+l+96.1%
*-commutative96.1%
distribute-rgt-neg-in96.1%
+-commutative96.1%
fma-def97.4%
neg-sub097.4%
associate--r-97.4%
neg-sub097.4%
+-commutative97.4%
sub-neg97.4%
fma-def97.4%
sub-neg97.4%
associate-+l+97.4%
metadata-eval97.4%
sub-neg97.4%
+-commutative97.4%
Simplified97.4%
Taylor expanded in y around 0 95.6%
Taylor expanded in a around 0 74.8%
Final simplification74.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y)))) (t_2 (+ x (* b (- (+ t y) 2.0)))))
(if (<= b -3400.0)
t_2
(if (<= b 1.6e-113)
(+ t_1 (- a (* t a)))
(if (<= b 3.7e+73) (+ t_1 (* t (- b a))) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = x + (b * ((t + y) - 2.0));
double tmp;
if (b <= -3400.0) {
tmp = t_2;
} else if (b <= 1.6e-113) {
tmp = t_1 + (a - (t * a));
} else if (b <= 3.7e+73) {
tmp = t_1 + (t * (b - a));
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = x + (z * (1.0d0 - y))
t_2 = x + (b * ((t + y) - 2.0d0))
if (b <= (-3400.0d0)) then
tmp = t_2
else if (b <= 1.6d-113) then
tmp = t_1 + (a - (t * a))
else if (b <= 3.7d+73) then
tmp = t_1 + (t * (b - a))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = x + (b * ((t + y) - 2.0));
double tmp;
if (b <= -3400.0) {
tmp = t_2;
} else if (b <= 1.6e-113) {
tmp = t_1 + (a - (t * a));
} else if (b <= 3.7e+73) {
tmp = t_1 + (t * (b - a));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = x + (b * ((t + y) - 2.0)) tmp = 0 if b <= -3400.0: tmp = t_2 elif b <= 1.6e-113: tmp = t_1 + (a - (t * a)) elif b <= 3.7e+73: tmp = t_1 + (t * (b - a)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z * Float64(1.0 - y))) t_2 = Float64(x + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (b <= -3400.0) tmp = t_2; elseif (b <= 1.6e-113) tmp = Float64(t_1 + Float64(a - Float64(t * a))); elseif (b <= 3.7e+73) tmp = Float64(t_1 + Float64(t * Float64(b - a))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z * (1.0 - y)); t_2 = x + (b * ((t + y) - 2.0)); tmp = 0.0; if (b <= -3400.0) tmp = t_2; elseif (b <= 1.6e-113) tmp = t_1 + (a - (t * a)); elseif (b <= 3.7e+73) tmp = t_1 + (t * (b - a)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3400.0], t$95$2, If[LessEqual[b, 1.6e-113], N[(t$95$1 + N[(a - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.7e+73], N[(t$95$1 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := x + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -3400:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq 1.6 \cdot 10^{-113}:\\
\;\;\;\;t_1 + \left(a - t \cdot a\right)\\
\mathbf{elif}\;b \leq 3.7 \cdot 10^{+73}:\\
\;\;\;\;t_1 + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -3400 or 3.69999999999999973e73 < b Initial program 90.6%
associate-+l-90.6%
*-commutative90.6%
*-commutative90.6%
sub-neg90.6%
metadata-eval90.6%
remove-double-neg90.6%
remove-double-neg90.6%
sub-neg90.6%
metadata-eval90.6%
associate--l+90.6%
Simplified90.6%
Taylor expanded in z around 0 83.5%
Taylor expanded in a around 0 75.0%
if -3400 < b < 1.6000000000000001e-113Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in a around inf 96.0%
sub-neg96.0%
metadata-eval96.0%
*-commutative96.0%
distribute-rgt-in96.0%
*-commutative96.0%
mul-1-neg96.0%
unsub-neg96.0%
Simplified96.0%
if 1.6000000000000001e-113 < b < 3.69999999999999973e73Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 78.9%
Final simplification84.0%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -0.00025) (not (<= b 4.6e-92))) (+ (+ x (* b (- (+ t y) 2.0))) (* a (- 1.0 t))) (+ (+ x (* z (- 1.0 y))) (- a (* t a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -0.00025) || !(b <= 4.6e-92)) {
tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t));
} else {
tmp = (x + (z * (1.0 - y))) + (a - (t * 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 ((b <= (-0.00025d0)) .or. (.not. (b <= 4.6d-92))) then
tmp = (x + (b * ((t + y) - 2.0d0))) + (a * (1.0d0 - t))
else
tmp = (x + (z * (1.0d0 - y))) + (a - (t * 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 ((b <= -0.00025) || !(b <= 4.6e-92)) {
tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t));
} else {
tmp = (x + (z * (1.0 - y))) + (a - (t * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -0.00025) or not (b <= 4.6e-92): tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t)) else: tmp = (x + (z * (1.0 - y))) + (a - (t * a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -0.00025) || !(b <= 4.6e-92)) tmp = Float64(Float64(x + Float64(b * Float64(Float64(t + y) - 2.0))) + Float64(a * Float64(1.0 - t))); else tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(a - Float64(t * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -0.00025) || ~((b <= 4.6e-92))) tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t)); else tmp = (x + (z * (1.0 - y))) + (a - (t * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -0.00025], N[Not[LessEqual[b, 4.6e-92]], $MachinePrecision]], N[(N[(x + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -0.00025 \lor \neg \left(b \leq 4.6 \cdot 10^{-92}\right):\\
\;\;\;\;\left(x + b \cdot \left(\left(t + y\right) - 2\right)\right) + a \cdot \left(1 - t\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + \left(a - t \cdot a\right)\\
\end{array}
\end{array}
if b < -2.5000000000000001e-4 or 4.60000000000000032e-92 < b Initial program 92.7%
associate-+l-92.7%
*-commutative92.7%
*-commutative92.7%
sub-neg92.7%
metadata-eval92.7%
remove-double-neg92.7%
remove-double-neg92.7%
sub-neg92.7%
metadata-eval92.7%
associate--l+92.7%
Simplified92.7%
Taylor expanded in z around 0 83.1%
if -2.5000000000000001e-4 < b < 4.60000000000000032e-92Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in a around inf 95.2%
sub-neg95.2%
metadata-eval95.2%
*-commutative95.2%
distribute-rgt-in95.2%
*-commutative95.2%
mul-1-neg95.2%
unsub-neg95.2%
Simplified95.2%
Final simplification88.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- a))))
(if (<= a -1.85e+36)
t_1
(if (<= a -6e-48)
(* y b)
(if (<= a -7.5e-244)
(+ x z)
(if (<= a -7.5e-281)
(* z (- y))
(if (<= a 1.18e-172)
(+ x z)
(if (<= a 50000000000.0)
(* y b)
(if (<= a 2.4e+147) (+ x z) 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 <= -1.85e+36) {
tmp = t_1;
} else if (a <= -6e-48) {
tmp = y * b;
} else if (a <= -7.5e-244) {
tmp = x + z;
} else if (a <= -7.5e-281) {
tmp = z * -y;
} else if (a <= 1.18e-172) {
tmp = x + z;
} else if (a <= 50000000000.0) {
tmp = y * b;
} else if (a <= 2.4e+147) {
tmp = x + z;
} 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 * -a
if (a <= (-1.85d+36)) then
tmp = t_1
else if (a <= (-6d-48)) then
tmp = y * b
else if (a <= (-7.5d-244)) then
tmp = x + z
else if (a <= (-7.5d-281)) then
tmp = z * -y
else if (a <= 1.18d-172) then
tmp = x + z
else if (a <= 50000000000.0d0) then
tmp = y * b
else if (a <= 2.4d+147) then
tmp = x + z
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 * -a;
double tmp;
if (a <= -1.85e+36) {
tmp = t_1;
} else if (a <= -6e-48) {
tmp = y * b;
} else if (a <= -7.5e-244) {
tmp = x + z;
} else if (a <= -7.5e-281) {
tmp = z * -y;
} else if (a <= 1.18e-172) {
tmp = x + z;
} else if (a <= 50000000000.0) {
tmp = y * b;
} else if (a <= 2.4e+147) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * -a tmp = 0 if a <= -1.85e+36: tmp = t_1 elif a <= -6e-48: tmp = y * b elif a <= -7.5e-244: tmp = x + z elif a <= -7.5e-281: tmp = z * -y elif a <= 1.18e-172: tmp = x + z elif a <= 50000000000.0: tmp = y * b elif a <= 2.4e+147: tmp = x + z 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 <= -1.85e+36) tmp = t_1; elseif (a <= -6e-48) tmp = Float64(y * b); elseif (a <= -7.5e-244) tmp = Float64(x + z); elseif (a <= -7.5e-281) tmp = Float64(z * Float64(-y)); elseif (a <= 1.18e-172) tmp = Float64(x + z); elseif (a <= 50000000000.0) tmp = Float64(y * b); elseif (a <= 2.4e+147) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * -a; tmp = 0.0; if (a <= -1.85e+36) tmp = t_1; elseif (a <= -6e-48) tmp = y * b; elseif (a <= -7.5e-244) tmp = x + z; elseif (a <= -7.5e-281) tmp = z * -y; elseif (a <= 1.18e-172) tmp = x + z; elseif (a <= 50000000000.0) tmp = y * b; elseif (a <= 2.4e+147) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * (-a)), $MachinePrecision]}, If[LessEqual[a, -1.85e+36], t$95$1, If[LessEqual[a, -6e-48], N[(y * b), $MachinePrecision], If[LessEqual[a, -7.5e-244], N[(x + z), $MachinePrecision], If[LessEqual[a, -7.5e-281], N[(z * (-y)), $MachinePrecision], If[LessEqual[a, 1.18e-172], N[(x + z), $MachinePrecision], If[LessEqual[a, 50000000000.0], N[(y * b), $MachinePrecision], If[LessEqual[a, 2.4e+147], N[(x + z), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(-a\right)\\
\mathbf{if}\;a \leq -1.85 \cdot 10^{+36}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -6 \cdot 10^{-48}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;a \leq -7.5 \cdot 10^{-244}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;a \leq -7.5 \cdot 10^{-281}:\\
\;\;\;\;z \cdot \left(-y\right)\\
\mathbf{elif}\;a \leq 1.18 \cdot 10^{-172}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;a \leq 50000000000:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{+147}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -1.85000000000000014e36 or 2.40000000000000002e147 < a Initial program 92.3%
associate-+l-92.3%
*-commutative92.3%
*-commutative92.3%
sub-neg92.3%
metadata-eval92.3%
remove-double-neg92.3%
remove-double-neg92.3%
sub-neg92.3%
metadata-eval92.3%
associate--l+92.3%
Simplified92.3%
Taylor expanded in a around inf 69.6%
Taylor expanded in t around inf 48.0%
associate-*r*48.0%
neg-mul-148.0%
Simplified48.0%
if -1.85000000000000014e36 < a < -5.9999999999999998e-48 or 1.17999999999999999e-172 < a < 5e10Initial program 98.3%
associate-+l-98.3%
*-commutative98.3%
*-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
remove-double-neg98.3%
remove-double-neg98.3%
sub-neg98.3%
metadata-eval98.3%
associate--l+98.3%
Simplified98.3%
Taylor expanded in z around 0 75.5%
Taylor expanded in y around inf 38.6%
if -5.9999999999999998e-48 < a < -7.5000000000000003e-244 or -7.49999999999999968e-281 < a < 1.17999999999999999e-172 or 5e10 < a < 2.40000000000000002e147Initial program 97.9%
sub-neg97.9%
+-commutative97.9%
associate-+l+97.9%
*-commutative97.9%
distribute-rgt-neg-in97.9%
+-commutative97.9%
fma-def97.9%
neg-sub097.9%
associate--r-97.9%
neg-sub097.9%
+-commutative97.9%
sub-neg97.9%
fma-def98.9%
sub-neg98.9%
associate-+l+98.9%
metadata-eval98.9%
sub-neg98.9%
+-commutative98.9%
Simplified98.9%
Taylor expanded in y around 0 78.7%
Taylor expanded in b around 0 49.5%
associate-+r+49.5%
fma-udef49.5%
Simplified49.5%
Taylor expanded in a around 0 42.7%
if -7.5000000000000003e-244 < a < -7.49999999999999968e-281Initial program 88.9%
associate-+l-88.9%
*-commutative88.9%
*-commutative88.9%
sub-neg88.9%
metadata-eval88.9%
remove-double-neg88.9%
remove-double-neg88.9%
sub-neg88.9%
metadata-eval88.9%
associate--l+88.9%
Simplified88.9%
Taylor expanded in z around inf 68.2%
Taylor expanded in y around inf 57.9%
mul-1-neg57.9%
distribute-rgt-neg-in57.9%
Simplified57.9%
Final simplification44.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ a (+ (* b -2.0) (+ x z)))) (t_2 (- (* t (- b a)) (* y z))))
(if (<= t -1550000000000.0)
t_2
(if (<= t 1.3e-77)
t_1
(if (<= t 1.95e-43) (* y (- b z)) (if (<= t 700000.0) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a + ((b * -2.0) + (x + z));
double t_2 = (t * (b - a)) - (y * z);
double tmp;
if (t <= -1550000000000.0) {
tmp = t_2;
} else if (t <= 1.3e-77) {
tmp = t_1;
} else if (t <= 1.95e-43) {
tmp = y * (b - z);
} else if (t <= 700000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = a + ((b * (-2.0d0)) + (x + z))
t_2 = (t * (b - a)) - (y * z)
if (t <= (-1550000000000.0d0)) then
tmp = t_2
else if (t <= 1.3d-77) then
tmp = t_1
else if (t <= 1.95d-43) then
tmp = y * (b - z)
else if (t <= 700000.0d0) then
tmp = t_1
else
tmp = t_2
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 = a + ((b * -2.0) + (x + z));
double t_2 = (t * (b - a)) - (y * z);
double tmp;
if (t <= -1550000000000.0) {
tmp = t_2;
} else if (t <= 1.3e-77) {
tmp = t_1;
} else if (t <= 1.95e-43) {
tmp = y * (b - z);
} else if (t <= 700000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a + ((b * -2.0) + (x + z)) t_2 = (t * (b - a)) - (y * z) tmp = 0 if t <= -1550000000000.0: tmp = t_2 elif t <= 1.3e-77: tmp = t_1 elif t <= 1.95e-43: tmp = y * (b - z) elif t <= 700000.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a + Float64(Float64(b * -2.0) + Float64(x + z))) t_2 = Float64(Float64(t * Float64(b - a)) - Float64(y * z)) tmp = 0.0 if (t <= -1550000000000.0) tmp = t_2; elseif (t <= 1.3e-77) tmp = t_1; elseif (t <= 1.95e-43) tmp = Float64(y * Float64(b - z)); elseif (t <= 700000.0) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a + ((b * -2.0) + (x + z)); t_2 = (t * (b - a)) - (y * z); tmp = 0.0; if (t <= -1550000000000.0) tmp = t_2; elseif (t <= 1.3e-77) tmp = t_1; elseif (t <= 1.95e-43) tmp = y * (b - z); elseif (t <= 700000.0) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a + N[(N[(b * -2.0), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1550000000000.0], t$95$2, If[LessEqual[t, 1.3e-77], t$95$1, If[LessEqual[t, 1.95e-43], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 700000.0], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + \left(b \cdot -2 + \left(x + z\right)\right)\\
t_2 := t \cdot \left(b - a\right) - y \cdot z\\
\mathbf{if}\;t \leq -1550000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{-77}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.95 \cdot 10^{-43}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq 700000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.55e12 or 7e5 < t Initial program 92.9%
associate-+l-92.9%
*-commutative92.9%
*-commutative92.9%
sub-neg92.9%
metadata-eval92.9%
remove-double-neg92.9%
remove-double-neg92.9%
sub-neg92.9%
metadata-eval92.9%
associate--l+92.9%
Simplified92.9%
Taylor expanded in t around inf 88.0%
Taylor expanded in y around inf 76.6%
mul-1-neg76.6%
distribute-rgt-neg-in76.6%
Simplified76.6%
if -1.55e12 < t < 1.3000000000000001e-77 or 1.95e-43 < t < 7e5Initial program 98.3%
sub-neg98.3%
+-commutative98.3%
associate-+l+98.3%
*-commutative98.3%
distribute-rgt-neg-in98.3%
+-commutative98.3%
fma-def98.3%
neg-sub098.3%
associate--r-98.3%
neg-sub098.3%
+-commutative98.3%
sub-neg98.3%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 68.0%
Taylor expanded in t around 0 65.8%
if 1.3000000000000001e-77 < t < 1.95e-43Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in y around inf 78.3%
Final simplification71.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ a (+ x (* (- y 2.0) b)))) (t_2 (- (* t (- b a)) (* y z))))
(if (<= t -2000000000000.0)
t_2
(if (<= t 2.3e-219)
t_1
(if (<= t 1.2e-185)
(+ x (* z (- 1.0 y)))
(if (<= t 2800000.0) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a + (x + ((y - 2.0) * b));
double t_2 = (t * (b - a)) - (y * z);
double tmp;
if (t <= -2000000000000.0) {
tmp = t_2;
} else if (t <= 2.3e-219) {
tmp = t_1;
} else if (t <= 1.2e-185) {
tmp = x + (z * (1.0 - y));
} else if (t <= 2800000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = a + (x + ((y - 2.0d0) * b))
t_2 = (t * (b - a)) - (y * z)
if (t <= (-2000000000000.0d0)) then
tmp = t_2
else if (t <= 2.3d-219) then
tmp = t_1
else if (t <= 1.2d-185) then
tmp = x + (z * (1.0d0 - y))
else if (t <= 2800000.0d0) then
tmp = t_1
else
tmp = t_2
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 = a + (x + ((y - 2.0) * b));
double t_2 = (t * (b - a)) - (y * z);
double tmp;
if (t <= -2000000000000.0) {
tmp = t_2;
} else if (t <= 2.3e-219) {
tmp = t_1;
} else if (t <= 1.2e-185) {
tmp = x + (z * (1.0 - y));
} else if (t <= 2800000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a + (x + ((y - 2.0) * b)) t_2 = (t * (b - a)) - (y * z) tmp = 0 if t <= -2000000000000.0: tmp = t_2 elif t <= 2.3e-219: tmp = t_1 elif t <= 1.2e-185: tmp = x + (z * (1.0 - y)) elif t <= 2800000.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a + Float64(x + Float64(Float64(y - 2.0) * b))) t_2 = Float64(Float64(t * Float64(b - a)) - Float64(y * z)) tmp = 0.0 if (t <= -2000000000000.0) tmp = t_2; elseif (t <= 2.3e-219) tmp = t_1; elseif (t <= 1.2e-185) tmp = Float64(x + Float64(z * Float64(1.0 - y))); elseif (t <= 2800000.0) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a + (x + ((y - 2.0) * b)); t_2 = (t * (b - a)) - (y * z); tmp = 0.0; if (t <= -2000000000000.0) tmp = t_2; elseif (t <= 2.3e-219) tmp = t_1; elseif (t <= 1.2e-185) tmp = x + (z * (1.0 - y)); elseif (t <= 2800000.0) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a + N[(x + N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2000000000000.0], t$95$2, If[LessEqual[t, 2.3e-219], t$95$1, If[LessEqual[t, 1.2e-185], N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2800000.0], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + \left(x + \left(y - 2\right) \cdot b\right)\\
t_2 := t \cdot \left(b - a\right) - y \cdot z\\
\mathbf{if}\;t \leq -2000000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 2.3 \cdot 10^{-219}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{-185}:\\
\;\;\;\;x + z \cdot \left(1 - y\right)\\
\mathbf{elif}\;t \leq 2800000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -2e12 or 2.8e6 < t Initial program 92.9%
associate-+l-92.9%
*-commutative92.9%
*-commutative92.9%
sub-neg92.9%
metadata-eval92.9%
remove-double-neg92.9%
remove-double-neg92.9%
sub-neg92.9%
metadata-eval92.9%
associate--l+92.9%
Simplified92.9%
Taylor expanded in t around inf 88.0%
Taylor expanded in y around inf 76.6%
mul-1-neg76.6%
distribute-rgt-neg-in76.6%
Simplified76.6%
if -2e12 < t < 2.29999999999999988e-219 or 1.2000000000000001e-185 < t < 2.8e6Initial program 98.3%
associate-+l-98.3%
*-commutative98.3%
*-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
remove-double-neg98.3%
remove-double-neg98.3%
sub-neg98.3%
metadata-eval98.3%
associate--l+98.3%
Simplified98.3%
Taylor expanded in z around 0 73.2%
Taylor expanded in t around 0 71.4%
if 2.29999999999999988e-219 < t < 1.2000000000000001e-185Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 89.1%
Taylor expanded in t around 0 89.1%
Final simplification74.6%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -1.06e+95) (not (<= b 9.6e+73))) (+ x (* b (- (+ t y) 2.0))) (+ (+ x (* z (- 1.0 y))) (* t (- b a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -1.06e+95) || !(b <= 9.6e+73)) {
tmp = x + (b * ((t + y) - 2.0));
} else {
tmp = (x + (z * (1.0 - y))) + (t * (b - 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 ((b <= (-1.06d+95)) .or. (.not. (b <= 9.6d+73))) then
tmp = x + (b * ((t + y) - 2.0d0))
else
tmp = (x + (z * (1.0d0 - y))) + (t * (b - 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 ((b <= -1.06e+95) || !(b <= 9.6e+73)) {
tmp = x + (b * ((t + y) - 2.0));
} else {
tmp = (x + (z * (1.0 - y))) + (t * (b - a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -1.06e+95) or not (b <= 9.6e+73): tmp = x + (b * ((t + y) - 2.0)) else: tmp = (x + (z * (1.0 - y))) + (t * (b - a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -1.06e+95) || !(b <= 9.6e+73)) tmp = Float64(x + Float64(b * Float64(Float64(t + y) - 2.0))); else tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(t * Float64(b - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -1.06e+95) || ~((b <= 9.6e+73))) tmp = x + (b * ((t + y) - 2.0)); else tmp = (x + (z * (1.0 - y))) + (t * (b - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -1.06e+95], N[Not[LessEqual[b, 9.6e+73]], $MachinePrecision]], N[(x + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.06 \cdot 10^{+95} \lor \neg \left(b \leq 9.6 \cdot 10^{+73}\right):\\
\;\;\;\;x + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if b < -1.06000000000000001e95 or 9.60000000000000009e73 < b Initial program 88.3%
associate-+l-88.3%
*-commutative88.3%
*-commutative88.3%
sub-neg88.3%
metadata-eval88.3%
remove-double-neg88.3%
remove-double-neg88.3%
sub-neg88.3%
metadata-eval88.3%
associate--l+88.3%
Simplified88.3%
Taylor expanded in z around 0 84.6%
Taylor expanded in a around 0 77.7%
if -1.06000000000000001e95 < b < 9.60000000000000009e73Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 81.7%
Final simplification80.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
(if (<= t -1.65e+27)
t_2
(if (<= t -5.2e-246)
t_1
(if (<= t 7.5e-189) (+ x z) (if (<= t 5.8) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.65e+27) {
tmp = t_2;
} else if (t <= -5.2e-246) {
tmp = t_1;
} else if (t <= 7.5e-189) {
tmp = x + z;
} else if (t <= 5.8) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = y * (b - z)
t_2 = t * (b - a)
if (t <= (-1.65d+27)) then
tmp = t_2
else if (t <= (-5.2d-246)) then
tmp = t_1
else if (t <= 7.5d-189) then
tmp = x + z
else if (t <= 5.8d0) then
tmp = t_1
else
tmp = t_2
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 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.65e+27) {
tmp = t_2;
} else if (t <= -5.2e-246) {
tmp = t_1;
} else if (t <= 7.5e-189) {
tmp = x + z;
} else if (t <= 5.8) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * (b - z) t_2 = t * (b - a) tmp = 0 if t <= -1.65e+27: tmp = t_2 elif t <= -5.2e-246: tmp = t_1 elif t <= 7.5e-189: tmp = x + z elif t <= 5.8: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(b - z)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.65e+27) tmp = t_2; elseif (t <= -5.2e-246) tmp = t_1; elseif (t <= 7.5e-189) tmp = Float64(x + z); elseif (t <= 5.8) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * (b - z); t_2 = t * (b - a); tmp = 0.0; if (t <= -1.65e+27) tmp = t_2; elseif (t <= -5.2e-246) tmp = t_1; elseif (t <= 7.5e-189) tmp = x + z; elseif (t <= 5.8) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.65e+27], t$95$2, If[LessEqual[t, -5.2e-246], t$95$1, If[LessEqual[t, 7.5e-189], N[(x + z), $MachinePrecision], If[LessEqual[t, 5.8], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b - z\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.65 \cdot 10^{+27}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -5.2 \cdot 10^{-246}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 7.5 \cdot 10^{-189}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq 5.8:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.6499999999999999e27 or 5.79999999999999982 < t Initial program 92.8%
associate-+l-92.8%
*-commutative92.8%
*-commutative92.8%
sub-neg92.8%
metadata-eval92.8%
remove-double-neg92.8%
remove-double-neg92.8%
sub-neg92.8%
metadata-eval92.8%
associate--l+92.8%
Simplified92.8%
Taylor expanded in t around inf 69.7%
if -1.6499999999999999e27 < t < -5.1999999999999997e-246 or 7.50000000000000042e-189 < t < 5.79999999999999982Initial program 97.8%
associate-+l-97.8%
*-commutative97.8%
*-commutative97.8%
sub-neg97.8%
metadata-eval97.8%
remove-double-neg97.8%
remove-double-neg97.8%
sub-neg97.8%
metadata-eval97.8%
associate--l+97.8%
Simplified97.8%
Taylor expanded in y around inf 43.6%
if -5.1999999999999997e-246 < t < 7.50000000000000042e-189Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 76.5%
Taylor expanded in b around 0 67.9%
associate-+r+67.9%
fma-udef67.9%
Simplified67.9%
Taylor expanded in a around 0 49.4%
Final simplification57.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -8500000000000.0)
t_1
(if (<= t 2.4e-194) (+ x z) (if (<= t 216000.0) (* z (- 1.0 y)) 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 <= -8500000000000.0) {
tmp = t_1;
} else if (t <= 2.4e-194) {
tmp = x + z;
} else if (t <= 216000.0) {
tmp = z * (1.0 - y);
} 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 <= (-8500000000000.0d0)) then
tmp = t_1
else if (t <= 2.4d-194) then
tmp = x + z
else if (t <= 216000.0d0) then
tmp = z * (1.0d0 - y)
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 <= -8500000000000.0) {
tmp = t_1;
} else if (t <= 2.4e-194) {
tmp = x + z;
} else if (t <= 216000.0) {
tmp = z * (1.0 - y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -8500000000000.0: tmp = t_1 elif t <= 2.4e-194: tmp = x + z elif t <= 216000.0: tmp = z * (1.0 - y) 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 <= -8500000000000.0) tmp = t_1; elseif (t <= 2.4e-194) tmp = Float64(x + z); elseif (t <= 216000.0) tmp = Float64(z * Float64(1.0 - y)); 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 <= -8500000000000.0) tmp = t_1; elseif (t <= 2.4e-194) tmp = x + z; elseif (t <= 216000.0) tmp = z * (1.0 - y); 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, -8500000000000.0], t$95$1, If[LessEqual[t, 2.4e-194], N[(x + z), $MachinePrecision], If[LessEqual[t, 216000.0], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -8500000000000:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-194}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq 216000:\\
\;\;\;\;z \cdot \left(1 - y\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -8.5e12 or 216000 < t Initial program 92.9%
associate-+l-92.9%
*-commutative92.9%
*-commutative92.9%
sub-neg92.9%
metadata-eval92.9%
remove-double-neg92.9%
remove-double-neg92.9%
sub-neg92.9%
metadata-eval92.9%
associate--l+92.9%
Simplified92.9%
Taylor expanded in t around inf 69.4%
if -8.5e12 < t < 2.4e-194Initial program 98.8%
sub-neg98.8%
+-commutative98.8%
associate-+l+98.8%
*-commutative98.8%
distribute-rgt-neg-in98.8%
+-commutative98.8%
fma-def98.8%
neg-sub098.8%
associate--r-98.8%
neg-sub098.8%
+-commutative98.8%
sub-neg98.8%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 67.6%
Taylor expanded in b around 0 56.1%
associate-+r+56.1%
fma-udef56.1%
Simplified56.1%
Taylor expanded in a around 0 36.6%
if 2.4e-194 < t < 216000Initial program 97.7%
associate-+l-97.7%
*-commutative97.7%
*-commutative97.7%
sub-neg97.7%
metadata-eval97.7%
remove-double-neg97.7%
remove-double-neg97.7%
sub-neg97.7%
metadata-eval97.7%
associate--l+97.7%
Simplified97.7%
Taylor expanded in z around inf 41.6%
Final simplification53.9%
(FPCore (x y z t a b) :precision binary64 (if (<= t -1.62e+72) (* t b) (if (<= t 1.4e-243) x (if (<= t 16000.0) z (* t b)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.62e+72) {
tmp = t * b;
} else if (t <= 1.4e-243) {
tmp = x;
} else if (t <= 16000.0) {
tmp = z;
} 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 <= (-1.62d+72)) then
tmp = t * b
else if (t <= 1.4d-243) then
tmp = x
else if (t <= 16000.0d0) then
tmp = z
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 <= -1.62e+72) {
tmp = t * b;
} else if (t <= 1.4e-243) {
tmp = x;
} else if (t <= 16000.0) {
tmp = z;
} else {
tmp = t * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -1.62e+72: tmp = t * b elif t <= 1.4e-243: tmp = x elif t <= 16000.0: tmp = z else: tmp = t * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -1.62e+72) tmp = Float64(t * b); elseif (t <= 1.4e-243) tmp = x; elseif (t <= 16000.0) tmp = z; else tmp = Float64(t * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -1.62e+72) tmp = t * b; elseif (t <= 1.4e-243) tmp = x; elseif (t <= 16000.0) tmp = z; else tmp = t * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.62e+72], N[(t * b), $MachinePrecision], If[LessEqual[t, 1.4e-243], x, If[LessEqual[t, 16000.0], z, N[(t * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.62 \cdot 10^{+72}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{-243}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 16000:\\
\;\;\;\;z\\
\mathbf{else}:\\
\;\;\;\;t \cdot b\\
\end{array}
\end{array}
if t < -1.62000000000000008e72 or 16000 < t Initial program 92.3%
associate-+l-92.3%
*-commutative92.3%
*-commutative92.3%
sub-neg92.3%
metadata-eval92.3%
remove-double-neg92.3%
remove-double-neg92.3%
sub-neg92.3%
metadata-eval92.3%
associate--l+92.3%
Simplified92.3%
Taylor expanded in b around inf 46.7%
Taylor expanded in t around inf 37.3%
if -1.62000000000000008e72 < t < 1.39999999999999997e-243Initial program 98.8%
associate-+l-98.8%
*-commutative98.8%
*-commutative98.8%
sub-neg98.8%
metadata-eval98.8%
remove-double-neg98.8%
remove-double-neg98.8%
sub-neg98.8%
metadata-eval98.8%
associate--l+98.8%
Simplified98.8%
Taylor expanded in x around inf 26.6%
if 1.39999999999999997e-243 < t < 16000Initial program 98.1%
associate-+l-98.1%
*-commutative98.1%
*-commutative98.1%
sub-neg98.1%
metadata-eval98.1%
remove-double-neg98.1%
remove-double-neg98.1%
sub-neg98.1%
metadata-eval98.1%
associate--l+98.1%
Simplified98.1%
Taylor expanded in z around inf 42.4%
Taylor expanded in y around 0 24.5%
Final simplification31.1%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -86000000000000.0) (not (<= t 5800000.0))) (* t (- b a)) (+ x z)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -86000000000000.0) || !(t <= 5800000.0)) {
tmp = t * (b - a);
} else {
tmp = x + z;
}
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 <= (-86000000000000.0d0)) .or. (.not. (t <= 5800000.0d0))) then
tmp = t * (b - a)
else
tmp = x + z
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 <= -86000000000000.0) || !(t <= 5800000.0)) {
tmp = t * (b - a);
} else {
tmp = x + z;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -86000000000000.0) or not (t <= 5800000.0): tmp = t * (b - a) else: tmp = x + z return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -86000000000000.0) || !(t <= 5800000.0)) tmp = Float64(t * Float64(b - a)); else tmp = Float64(x + z); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -86000000000000.0) || ~((t <= 5800000.0))) tmp = t * (b - a); else tmp = x + z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -86000000000000.0], N[Not[LessEqual[t, 5800000.0]], $MachinePrecision]], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], N[(x + z), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -86000000000000 \lor \neg \left(t \leq 5800000\right):\\
\;\;\;\;t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;x + z\\
\end{array}
\end{array}
if t < -8.6e13 or 5.8e6 < t Initial program 92.9%
associate-+l-92.9%
*-commutative92.9%
*-commutative92.9%
sub-neg92.9%
metadata-eval92.9%
remove-double-neg92.9%
remove-double-neg92.9%
sub-neg92.9%
metadata-eval92.9%
associate--l+92.9%
Simplified92.9%
Taylor expanded in t around inf 69.9%
if -8.6e13 < t < 5.8e6Initial program 98.4%
sub-neg98.4%
+-commutative98.4%
associate-+l+98.4%
*-commutative98.4%
distribute-rgt-neg-in98.4%
+-commutative98.4%
fma-def98.4%
neg-sub098.4%
associate--r-98.4%
neg-sub098.4%
+-commutative98.4%
sub-neg98.4%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 65.0%
Taylor expanded in b around 0 51.5%
associate-+r+51.5%
fma-udef51.5%
Simplified51.5%
Taylor expanded in a around 0 33.6%
Final simplification51.6%
(FPCore (x y z t a b) :precision binary64 (if (<= y -38000000000000.0) (* y b) (if (<= y 1.3e+143) (* t b) (* y b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -38000000000000.0) {
tmp = y * b;
} else if (y <= 1.3e+143) {
tmp = t * b;
} else {
tmp = y * 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 (y <= (-38000000000000.0d0)) then
tmp = y * b
else if (y <= 1.3d+143) then
tmp = t * b
else
tmp = y * 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 (y <= -38000000000000.0) {
tmp = y * b;
} else if (y <= 1.3e+143) {
tmp = t * b;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -38000000000000.0: tmp = y * b elif y <= 1.3e+143: tmp = t * b else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -38000000000000.0) tmp = Float64(y * b); elseif (y <= 1.3e+143) tmp = Float64(t * b); else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -38000000000000.0) tmp = y * b; elseif (y <= 1.3e+143) tmp = t * b; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -38000000000000.0], N[(y * b), $MachinePrecision], If[LessEqual[y, 1.3e+143], N[(t * b), $MachinePrecision], N[(y * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -38000000000000:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;y \leq 1.3 \cdot 10^{+143}:\\
\;\;\;\;t \cdot b\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -3.8e13 or 1.2999999999999999e143 < y Initial program 94.2%
associate-+l-94.2%
*-commutative94.2%
*-commutative94.2%
sub-neg94.2%
metadata-eval94.2%
remove-double-neg94.2%
remove-double-neg94.2%
sub-neg94.2%
metadata-eval94.2%
associate--l+94.2%
Simplified94.2%
Taylor expanded in z around 0 74.0%
Taylor expanded in y around inf 42.1%
if -3.8e13 < y < 1.2999999999999999e143Initial program 96.7%
associate-+l-96.7%
*-commutative96.7%
*-commutative96.7%
sub-neg96.7%
metadata-eval96.7%
remove-double-neg96.7%
remove-double-neg96.7%
sub-neg96.7%
metadata-eval96.7%
associate--l+96.7%
Simplified96.7%
Taylor expanded in b around inf 35.9%
Taylor expanded in t around inf 23.8%
Final simplification31.1%
(FPCore (x y z t a b) :precision binary64 (if (<= b -4.1e-27) (* t b) (if (<= b 4.8e-80) (+ x z) (* y b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -4.1e-27) {
tmp = t * b;
} else if (b <= 4.8e-80) {
tmp = x + z;
} else {
tmp = y * 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 (b <= (-4.1d-27)) then
tmp = t * b
else if (b <= 4.8d-80) then
tmp = x + z
else
tmp = y * 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 (b <= -4.1e-27) {
tmp = t * b;
} else if (b <= 4.8e-80) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -4.1e-27: tmp = t * b elif b <= 4.8e-80: tmp = x + z else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -4.1e-27) tmp = Float64(t * b); elseif (b <= 4.8e-80) tmp = Float64(x + z); else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -4.1e-27) tmp = t * b; elseif (b <= 4.8e-80) tmp = x + z; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -4.1e-27], N[(t * b), $MachinePrecision], If[LessEqual[b, 4.8e-80], N[(x + z), $MachinePrecision], N[(y * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4.1 \cdot 10^{-27}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq 4.8 \cdot 10^{-80}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if b < -4.0999999999999999e-27Initial program 93.8%
associate-+l-93.8%
*-commutative93.8%
*-commutative93.8%
sub-neg93.8%
metadata-eval93.8%
remove-double-neg93.8%
remove-double-neg93.8%
sub-neg93.8%
metadata-eval93.8%
associate--l+93.8%
Simplified93.8%
Taylor expanded in b around inf 62.7%
Taylor expanded in t around inf 28.9%
if -4.0999999999999999e-27 < b < 4.7999999999999998e-80Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 82.4%
Taylor expanded in b around 0 79.6%
associate-+r+79.6%
fma-udef79.6%
Simplified79.6%
Taylor expanded in a around 0 43.6%
if 4.7999999999999998e-80 < b Initial program 91.4%
associate-+l-91.4%
*-commutative91.4%
*-commutative91.4%
sub-neg91.4%
metadata-eval91.4%
remove-double-neg91.4%
remove-double-neg91.4%
sub-neg91.4%
metadata-eval91.4%
associate--l+91.4%
Simplified91.4%
Taylor expanded in z around 0 81.6%
Taylor expanded in y around inf 34.0%
Final simplification36.3%
(FPCore (x y z t a b) :precision binary64 (if (<= a -5.8e+20) a (if (<= a 3.5e+139) x a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -5.8e+20) {
tmp = a;
} else if (a <= 3.5e+139) {
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 <= (-5.8d+20)) then
tmp = a
else if (a <= 3.5d+139) 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 <= -5.8e+20) {
tmp = a;
} else if (a <= 3.5e+139) {
tmp = x;
} else {
tmp = a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -5.8e+20: tmp = a elif a <= 3.5e+139: tmp = x else: tmp = a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -5.8e+20) tmp = a; elseif (a <= 3.5e+139) tmp = x; else tmp = a; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -5.8e+20) tmp = a; elseif (a <= 3.5e+139) tmp = x; else tmp = a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -5.8e+20], a, If[LessEqual[a, 3.5e+139], x, a]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.8 \cdot 10^{+20}:\\
\;\;\;\;a\\
\mathbf{elif}\;a \leq 3.5 \cdot 10^{+139}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;a\\
\end{array}
\end{array}
if a < -5.8e20 or 3.49999999999999978e139 < a Initial program 91.6%
associate-+l-91.6%
*-commutative91.6%
*-commutative91.6%
sub-neg91.6%
metadata-eval91.6%
remove-double-neg91.6%
remove-double-neg91.6%
sub-neg91.6%
metadata-eval91.6%
associate--l+91.6%
Simplified91.6%
Taylor expanded in a around inf 68.8%
Taylor expanded in t around 0 25.0%
if -5.8e20 < a < 3.49999999999999978e139Initial program 98.1%
associate-+l-98.1%
*-commutative98.1%
*-commutative98.1%
sub-neg98.1%
metadata-eval98.1%
remove-double-neg98.1%
remove-double-neg98.1%
sub-neg98.1%
metadata-eval98.1%
associate--l+98.1%
Simplified98.1%
Taylor expanded in x around inf 20.1%
Final simplification22.0%
(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 95.7%
associate-+l-95.7%
*-commutative95.7%
*-commutative95.7%
sub-neg95.7%
metadata-eval95.7%
remove-double-neg95.7%
remove-double-neg95.7%
sub-neg95.7%
metadata-eval95.7%
associate--l+95.7%
Simplified95.7%
Taylor expanded in a around inf 30.9%
Taylor expanded in t around 0 10.7%
Final simplification10.7%
herbie shell --seed 2023195
(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)))