
(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 22 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
(let* ((t_1
(+ (- (+ x (* z (- 1.0 y))) (* a (+ t -1.0))) (* b (- (+ t y) 2.0)))))
(if (<= t_1 INFINITY) 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))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = 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))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = t * (b - a);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = ((x + (z * (1.0 - y))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0)) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = t * (b - a) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(x + Float64(z * Float64(1.0 - y))) - Float64(a * Float64(t + -1.0))) + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = 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))) - (a * (t + -1.0))) + (b * ((t + y) - 2.0)); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = t * (b - a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(x + z \cdot \left(1 - y\right)\right) - a \cdot \left(t + -1\right)\right) + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;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 73.4%
Final simplification98.4%
(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 94.1%
+-commutative94.1%
fma-def97.3%
+-commutative97.3%
associate--l+97.3%
sub-neg97.3%
associate-+l-97.3%
fma-neg97.7%
sub-neg97.7%
metadata-eval97.7%
distribute-lft-neg-in97.7%
distribute-lft-neg-in97.7%
remove-double-neg97.7%
sub-neg97.7%
metadata-eval97.7%
Simplified97.7%
Final simplification97.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (- 1.0 y))) (t_2 (* t (- b a))) (t_3 (* b (- (+ t y) 2.0))))
(if (<= t -7e+75)
t_2
(if (<= t -6.5e-164)
(* y (- b z))
(if (<= t -1e-198)
(+ x a)
(if (<= t -2.5e-305)
t_3
(if (<= t 3.1e-228)
(+ x a)
(if (<= t 1.65e-94)
t_1
(if (<= t 6.8e-28)
t_3
(if (<= t 1.28e+23) t_1 (if (<= t 1.6e+122) t_3 t_2)))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (1.0 - y);
double t_2 = t * (b - a);
double t_3 = b * ((t + y) - 2.0);
double tmp;
if (t <= -7e+75) {
tmp = t_2;
} else if (t <= -6.5e-164) {
tmp = y * (b - z);
} else if (t <= -1e-198) {
tmp = x + a;
} else if (t <= -2.5e-305) {
tmp = t_3;
} else if (t <= 3.1e-228) {
tmp = x + a;
} else if (t <= 1.65e-94) {
tmp = t_1;
} else if (t <= 6.8e-28) {
tmp = t_3;
} else if (t <= 1.28e+23) {
tmp = t_1;
} else if (t <= 1.6e+122) {
tmp = t_3;
} 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 = z * (1.0d0 - y)
t_2 = t * (b - a)
t_3 = b * ((t + y) - 2.0d0)
if (t <= (-7d+75)) then
tmp = t_2
else if (t <= (-6.5d-164)) then
tmp = y * (b - z)
else if (t <= (-1d-198)) then
tmp = x + a
else if (t <= (-2.5d-305)) then
tmp = t_3
else if (t <= 3.1d-228) then
tmp = x + a
else if (t <= 1.65d-94) then
tmp = t_1
else if (t <= 6.8d-28) then
tmp = t_3
else if (t <= 1.28d+23) then
tmp = t_1
else if (t <= 1.6d+122) then
tmp = t_3
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 * (1.0 - y);
double t_2 = t * (b - a);
double t_3 = b * ((t + y) - 2.0);
double tmp;
if (t <= -7e+75) {
tmp = t_2;
} else if (t <= -6.5e-164) {
tmp = y * (b - z);
} else if (t <= -1e-198) {
tmp = x + a;
} else if (t <= -2.5e-305) {
tmp = t_3;
} else if (t <= 3.1e-228) {
tmp = x + a;
} else if (t <= 1.65e-94) {
tmp = t_1;
} else if (t <= 6.8e-28) {
tmp = t_3;
} else if (t <= 1.28e+23) {
tmp = t_1;
} else if (t <= 1.6e+122) {
tmp = t_3;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z * (1.0 - y) t_2 = t * (b - a) t_3 = b * ((t + y) - 2.0) tmp = 0 if t <= -7e+75: tmp = t_2 elif t <= -6.5e-164: tmp = y * (b - z) elif t <= -1e-198: tmp = x + a elif t <= -2.5e-305: tmp = t_3 elif t <= 3.1e-228: tmp = x + a elif t <= 1.65e-94: tmp = t_1 elif t <= 6.8e-28: tmp = t_3 elif t <= 1.28e+23: tmp = t_1 elif t <= 1.6e+122: tmp = t_3 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(1.0 - y)) t_2 = Float64(t * Float64(b - a)) t_3 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (t <= -7e+75) tmp = t_2; elseif (t <= -6.5e-164) tmp = Float64(y * Float64(b - z)); elseif (t <= -1e-198) tmp = Float64(x + a); elseif (t <= -2.5e-305) tmp = t_3; elseif (t <= 3.1e-228) tmp = Float64(x + a); elseif (t <= 1.65e-94) tmp = t_1; elseif (t <= 6.8e-28) tmp = t_3; elseif (t <= 1.28e+23) tmp = t_1; elseif (t <= 1.6e+122) tmp = t_3; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z * (1.0 - y); t_2 = t * (b - a); t_3 = b * ((t + y) - 2.0); tmp = 0.0; if (t <= -7e+75) tmp = t_2; elseif (t <= -6.5e-164) tmp = y * (b - z); elseif (t <= -1e-198) tmp = x + a; elseif (t <= -2.5e-305) tmp = t_3; elseif (t <= 3.1e-228) tmp = x + a; elseif (t <= 1.65e-94) tmp = t_1; elseif (t <= 6.8e-28) tmp = t_3; elseif (t <= 1.28e+23) tmp = t_1; elseif (t <= 1.6e+122) tmp = t_3; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7e+75], t$95$2, If[LessEqual[t, -6.5e-164], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1e-198], N[(x + a), $MachinePrecision], If[LessEqual[t, -2.5e-305], t$95$3, If[LessEqual[t, 3.1e-228], N[(x + a), $MachinePrecision], If[LessEqual[t, 1.65e-94], t$95$1, If[LessEqual[t, 6.8e-28], t$95$3, If[LessEqual[t, 1.28e+23], t$95$1, If[LessEqual[t, 1.6e+122], t$95$3, t$95$2]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(1 - y\right)\\
t_2 := t \cdot \left(b - a\right)\\
t_3 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;t \leq -7 \cdot 10^{+75}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -6.5 \cdot 10^{-164}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq -1 \cdot 10^{-198}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq -2.5 \cdot 10^{-305}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 3.1 \cdot 10^{-228}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq 1.65 \cdot 10^{-94}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6.8 \cdot 10^{-28}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 1.28 \cdot 10^{+23}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.6 \cdot 10^{+122}:\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -6.9999999999999997e75 or 1.60000000000000006e122 < t Initial program 87.1%
associate-+l-87.1%
*-commutative87.1%
*-commutative87.1%
sub-neg87.1%
metadata-eval87.1%
remove-double-neg87.1%
remove-double-neg87.1%
sub-neg87.1%
metadata-eval87.1%
associate--l+87.1%
Simplified87.1%
Taylor expanded in t around inf 78.7%
if -6.9999999999999997e75 < t < -6.50000000000000004e-164Initial 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 y around inf 50.5%
if -6.50000000000000004e-164 < t < -9.9999999999999991e-199 or -2.49999999999999993e-305 < t < 3.0999999999999998e-228Initial 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 83.9%
sub-neg83.9%
metadata-eval83.9%
*-commutative83.9%
distribute-lft-in83.9%
*-commutative83.9%
mul-1-neg83.9%
unsub-neg83.9%
Simplified83.9%
Taylor expanded in z around 0 78.4%
Taylor expanded in t around 0 78.4%
if -9.9999999999999991e-199 < t < -2.49999999999999993e-305 or 1.6500000000000001e-94 < t < 6.8000000000000001e-28 or 1.28e23 < t < 1.60000000000000006e122Initial 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 61.9%
if 3.0999999999999998e-228 < t < 1.6500000000000001e-94 or 6.8000000000000001e-28 < t < 1.28e23Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in z around inf 55.3%
Final simplification66.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (- 1.0 y))) (t_2 (* t (- b a))))
(if (<= t -2.4e+49)
t_2
(if (<= t -1.7e-162)
t_1
(if (<= t -2e-198)
(+ x a)
(if (<= t -4.5e-230)
t_1
(if (<= t -1.95e-305)
(* y b)
(if (<= t 6.8e-228) (+ x a) (if (<= t 3.8e+24) t_1 t_2)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (1.0 - y);
double t_2 = t * (b - a);
double tmp;
if (t <= -2.4e+49) {
tmp = t_2;
} else if (t <= -1.7e-162) {
tmp = t_1;
} else if (t <= -2e-198) {
tmp = x + a;
} else if (t <= -4.5e-230) {
tmp = t_1;
} else if (t <= -1.95e-305) {
tmp = y * b;
} else if (t <= 6.8e-228) {
tmp = x + a;
} else if (t <= 3.8e+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) :: tmp
t_1 = z * (1.0d0 - y)
t_2 = t * (b - a)
if (t <= (-2.4d+49)) then
tmp = t_2
else if (t <= (-1.7d-162)) then
tmp = t_1
else if (t <= (-2d-198)) then
tmp = x + a
else if (t <= (-4.5d-230)) then
tmp = t_1
else if (t <= (-1.95d-305)) then
tmp = y * b
else if (t <= 6.8d-228) then
tmp = x + a
else if (t <= 3.8d+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 = z * (1.0 - y);
double t_2 = t * (b - a);
double tmp;
if (t <= -2.4e+49) {
tmp = t_2;
} else if (t <= -1.7e-162) {
tmp = t_1;
} else if (t <= -2e-198) {
tmp = x + a;
} else if (t <= -4.5e-230) {
tmp = t_1;
} else if (t <= -1.95e-305) {
tmp = y * b;
} else if (t <= 6.8e-228) {
tmp = x + a;
} else if (t <= 3.8e+24) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z * (1.0 - y) t_2 = t * (b - a) tmp = 0 if t <= -2.4e+49: tmp = t_2 elif t <= -1.7e-162: tmp = t_1 elif t <= -2e-198: tmp = x + a elif t <= -4.5e-230: tmp = t_1 elif t <= -1.95e-305: tmp = y * b elif t <= 6.8e-228: tmp = x + a elif t <= 3.8e+24: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(1.0 - y)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -2.4e+49) tmp = t_2; elseif (t <= -1.7e-162) tmp = t_1; elseif (t <= -2e-198) tmp = Float64(x + a); elseif (t <= -4.5e-230) tmp = t_1; elseif (t <= -1.95e-305) tmp = Float64(y * b); elseif (t <= 6.8e-228) tmp = Float64(x + a); elseif (t <= 3.8e+24) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z * (1.0 - y); t_2 = t * (b - a); tmp = 0.0; if (t <= -2.4e+49) tmp = t_2; elseif (t <= -1.7e-162) tmp = t_1; elseif (t <= -2e-198) tmp = x + a; elseif (t <= -4.5e-230) tmp = t_1; elseif (t <= -1.95e-305) tmp = y * b; elseif (t <= 6.8e-228) tmp = x + a; elseif (t <= 3.8e+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[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.4e+49], t$95$2, If[LessEqual[t, -1.7e-162], t$95$1, If[LessEqual[t, -2e-198], N[(x + a), $MachinePrecision], If[LessEqual[t, -4.5e-230], t$95$1, If[LessEqual[t, -1.95e-305], N[(y * b), $MachinePrecision], If[LessEqual[t, 6.8e-228], N[(x + a), $MachinePrecision], If[LessEqual[t, 3.8e+24], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(1 - y\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.4 \cdot 10^{+49}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.7 \cdot 10^{-162}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2 \cdot 10^{-198}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq -4.5 \cdot 10^{-230}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.95 \cdot 10^{-305}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 6.8 \cdot 10^{-228}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{+24}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -2.4e49 or 3.80000000000000015e24 < t Initial program 89.2%
associate-+l-89.2%
*-commutative89.2%
*-commutative89.2%
sub-neg89.2%
metadata-eval89.2%
remove-double-neg89.2%
remove-double-neg89.2%
sub-neg89.2%
metadata-eval89.2%
associate--l+89.2%
Simplified89.2%
Taylor expanded in t around inf 70.9%
if -2.4e49 < t < -1.7e-162 or -1.9999999999999998e-198 < t < -4.50000000000000004e-230 or 6.79999999999999981e-228 < t < 3.80000000000000015e24Initial program 98.0%
associate-+l-98.0%
*-commutative98.0%
*-commutative98.0%
sub-neg98.0%
metadata-eval98.0%
remove-double-neg98.0%
remove-double-neg98.0%
sub-neg98.0%
metadata-eval98.0%
associate--l+98.0%
Simplified98.0%
Taylor expanded in z around inf 44.3%
if -1.7e-162 < t < -1.9999999999999998e-198 or -1.95000000000000013e-305 < t < 6.79999999999999981e-228Initial 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 83.9%
sub-neg83.9%
metadata-eval83.9%
*-commutative83.9%
distribute-lft-in83.9%
*-commutative83.9%
mul-1-neg83.9%
unsub-neg83.9%
Simplified83.9%
Taylor expanded in z around 0 78.4%
Taylor expanded in t around 0 78.4%
if -4.50000000000000004e-230 < t < -1.95000000000000013e-305Initial 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 64.6%
Taylor expanded in y around inf 51.4%
Final simplification59.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y))))
(t_2 (* b (- (+ t y) 2.0)))
(t_3 (* a (- 1.0 t))))
(if (<= b -2.7e+57)
t_2
(if (<= b -3.2e-169)
t_1
(if (<= b -8e-193)
t_3
(if (<= b 1.1e-83)
t_1
(if (<= b 8.2e-11) t_3 (if (<= b 2.2e+24) 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));
double t_2 = b * ((t + y) - 2.0);
double t_3 = a * (1.0 - t);
double tmp;
if (b <= -2.7e+57) {
tmp = t_2;
} else if (b <= -3.2e-169) {
tmp = t_1;
} else if (b <= -8e-193) {
tmp = t_3;
} else if (b <= 1.1e-83) {
tmp = t_1;
} else if (b <= 8.2e-11) {
tmp = t_3;
} else if (b <= 2.2e+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 + (z * (1.0d0 - y))
t_2 = b * ((t + y) - 2.0d0)
t_3 = a * (1.0d0 - t)
if (b <= (-2.7d+57)) then
tmp = t_2
else if (b <= (-3.2d-169)) then
tmp = t_1
else if (b <= (-8d-193)) then
tmp = t_3
else if (b <= 1.1d-83) then
tmp = t_1
else if (b <= 8.2d-11) then
tmp = t_3
else if (b <= 2.2d+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 + (z * (1.0 - y));
double t_2 = b * ((t + y) - 2.0);
double t_3 = a * (1.0 - t);
double tmp;
if (b <= -2.7e+57) {
tmp = t_2;
} else if (b <= -3.2e-169) {
tmp = t_1;
} else if (b <= -8e-193) {
tmp = t_3;
} else if (b <= 1.1e-83) {
tmp = t_1;
} else if (b <= 8.2e-11) {
tmp = t_3;
} else if (b <= 2.2e+24) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = b * ((t + y) - 2.0) t_3 = a * (1.0 - t) tmp = 0 if b <= -2.7e+57: tmp = t_2 elif b <= -3.2e-169: tmp = t_1 elif b <= -8e-193: tmp = t_3 elif b <= 1.1e-83: tmp = t_1 elif b <= 8.2e-11: tmp = t_3 elif b <= 2.2e+24: tmp = t_1 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(b * Float64(Float64(t + y) - 2.0)) t_3 = Float64(a * Float64(1.0 - t)) tmp = 0.0 if (b <= -2.7e+57) tmp = t_2; elseif (b <= -3.2e-169) tmp = t_1; elseif (b <= -8e-193) tmp = t_3; elseif (b <= 1.1e-83) tmp = t_1; elseif (b <= 8.2e-11) tmp = t_3; elseif (b <= 2.2e+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 + (z * (1.0 - y)); t_2 = b * ((t + y) - 2.0); t_3 = a * (1.0 - t); tmp = 0.0; if (b <= -2.7e+57) tmp = t_2; elseif (b <= -3.2e-169) tmp = t_1; elseif (b <= -8e-193) tmp = t_3; elseif (b <= 1.1e-83) tmp = t_1; elseif (b <= 8.2e-11) tmp = t_3; elseif (b <= 2.2e+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[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.7e+57], t$95$2, If[LessEqual[b, -3.2e-169], t$95$1, If[LessEqual[b, -8e-193], t$95$3, If[LessEqual[b, 1.1e-83], t$95$1, If[LessEqual[b, 8.2e-11], t$95$3, If[LessEqual[b, 2.2e+24], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
t_3 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;b \leq -2.7 \cdot 10^{+57}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -3.2 \cdot 10^{-169}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -8 \cdot 10^{-193}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 1.1 \cdot 10^{-83}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 8.2 \cdot 10^{-11}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 2.2 \cdot 10^{+24}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -2.6999999999999998e57 or 2.20000000000000002e24 < b Initial program 89.4%
associate-+l-89.4%
*-commutative89.4%
*-commutative89.4%
sub-neg89.4%
metadata-eval89.4%
remove-double-neg89.4%
remove-double-neg89.4%
sub-neg89.4%
metadata-eval89.4%
associate--l+89.4%
Simplified89.4%
Taylor expanded in b around inf 71.2%
if -2.6999999999999998e57 < b < -3.19999999999999995e-169 or -8.0000000000000004e-193 < b < 1.10000000000000004e-83 or 8.2000000000000001e-11 < b < 2.20000000000000002e24Initial program 97.5%
associate-+l-97.5%
*-commutative97.5%
*-commutative97.5%
sub-neg97.5%
metadata-eval97.5%
remove-double-neg97.5%
remove-double-neg97.5%
sub-neg97.5%
metadata-eval97.5%
associate--l+97.5%
Simplified97.5%
Taylor expanded in a around inf 88.8%
sub-neg88.8%
metadata-eval88.8%
*-commutative88.8%
distribute-lft-in88.8%
*-commutative88.8%
mul-1-neg88.8%
unsub-neg88.8%
Simplified88.8%
Taylor expanded in a around 0 60.3%
if -3.19999999999999995e-169 < b < -8.0000000000000004e-193 or 1.10000000000000004e-83 < b < 8.2000000000000001e-11Initial 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 65.5%
Final simplification65.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= y -9.4e+85)
(+ (+ x (* z (- 1.0 y))) (* y b))
(if (<= y 2.2e+124)
(+ (* a (- 1.0 t)) (+ z (+ x (* b (- t 2.0)))))
(* y (- b z)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -9.4e+85) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (y <= 2.2e+124) {
tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0))));
} else {
tmp = y * (b - 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 (y <= (-9.4d+85)) then
tmp = (x + (z * (1.0d0 - y))) + (y * b)
else if (y <= 2.2d+124) then
tmp = (a * (1.0d0 - t)) + (z + (x + (b * (t - 2.0d0))))
else
tmp = y * (b - 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 (y <= -9.4e+85) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (y <= 2.2e+124) {
tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0))));
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -9.4e+85: tmp = (x + (z * (1.0 - y))) + (y * b) elif y <= 2.2e+124: tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0)))) else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -9.4e+85) tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(y * b)); elseif (y <= 2.2e+124) tmp = Float64(Float64(a * Float64(1.0 - t)) + Float64(z + Float64(x + Float64(b * Float64(t - 2.0))))); else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -9.4e+85) tmp = (x + (z * (1.0 - y))) + (y * b); elseif (y <= 2.2e+124) tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0)))); else tmp = y * (b - z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -9.4e+85], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.2e+124], N[(N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision] + N[(z + N[(x + N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.4 \cdot 10^{+85}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + y \cdot b\\
\mathbf{elif}\;y \leq 2.2 \cdot 10^{+124}:\\
\;\;\;\;a \cdot \left(1 - t\right) + \left(z + \left(x + b \cdot \left(t - 2\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if y < -9.4000000000000004e85Initial 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 85.9%
mul-1-neg85.9%
distribute-rgt-neg-in85.9%
Simplified85.9%
if -9.4000000000000004e85 < y < 2.2000000000000001e124Initial program 94.8%
sub-neg94.8%
+-commutative94.8%
associate-+l+94.8%
*-commutative94.8%
distribute-rgt-neg-in94.8%
+-commutative94.8%
fma-def96.0%
neg-sub096.0%
associate--r-96.0%
neg-sub096.0%
+-commutative96.0%
sub-neg96.0%
fma-def96.0%
sub-neg96.0%
associate-+l+96.0%
metadata-eval96.0%
sub-neg96.0%
+-commutative96.0%
Simplified96.0%
Taylor expanded in y around 0 88.0%
if 2.2000000000000001e124 < y Initial program 81.3%
associate-+l-81.3%
*-commutative81.3%
*-commutative81.3%
sub-neg81.3%
metadata-eval81.3%
remove-double-neg81.3%
remove-double-neg81.3%
sub-neg81.3%
metadata-eval81.3%
associate--l+81.3%
Simplified81.3%
Taylor expanded in y around inf 84.9%
Final simplification87.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
(if (<= t -3.9e+71)
t_2
(if (<= t -9.5e-164)
t_1
(if (<= t -2.2e-198)
(+ x a)
(if (<= t -1.6e-305)
t_1
(if (<= t 6.8e-228)
(+ x a)
(if (<= t 9.2e+24) (* z (- 1.0 y)) 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 <= -3.9e+71) {
tmp = t_2;
} else if (t <= -9.5e-164) {
tmp = t_1;
} else if (t <= -2.2e-198) {
tmp = x + a;
} else if (t <= -1.6e-305) {
tmp = t_1;
} else if (t <= 6.8e-228) {
tmp = x + a;
} else if (t <= 9.2e+24) {
tmp = z * (1.0 - y);
} 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 <= (-3.9d+71)) then
tmp = t_2
else if (t <= (-9.5d-164)) then
tmp = t_1
else if (t <= (-2.2d-198)) then
tmp = x + a
else if (t <= (-1.6d-305)) then
tmp = t_1
else if (t <= 6.8d-228) then
tmp = x + a
else if (t <= 9.2d+24) then
tmp = z * (1.0d0 - y)
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 <= -3.9e+71) {
tmp = t_2;
} else if (t <= -9.5e-164) {
tmp = t_1;
} else if (t <= -2.2e-198) {
tmp = x + a;
} else if (t <= -1.6e-305) {
tmp = t_1;
} else if (t <= 6.8e-228) {
tmp = x + a;
} else if (t <= 9.2e+24) {
tmp = z * (1.0 - y);
} 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 <= -3.9e+71: tmp = t_2 elif t <= -9.5e-164: tmp = t_1 elif t <= -2.2e-198: tmp = x + a elif t <= -1.6e-305: tmp = t_1 elif t <= 6.8e-228: tmp = x + a elif t <= 9.2e+24: tmp = z * (1.0 - y) 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 <= -3.9e+71) tmp = t_2; elseif (t <= -9.5e-164) tmp = t_1; elseif (t <= -2.2e-198) tmp = Float64(x + a); elseif (t <= -1.6e-305) tmp = t_1; elseif (t <= 6.8e-228) tmp = Float64(x + a); elseif (t <= 9.2e+24) tmp = Float64(z * Float64(1.0 - y)); 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 <= -3.9e+71) tmp = t_2; elseif (t <= -9.5e-164) tmp = t_1; elseif (t <= -2.2e-198) tmp = x + a; elseif (t <= -1.6e-305) tmp = t_1; elseif (t <= 6.8e-228) tmp = x + a; elseif (t <= 9.2e+24) tmp = z * (1.0 - y); 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, -3.9e+71], t$95$2, If[LessEqual[t, -9.5e-164], t$95$1, If[LessEqual[t, -2.2e-198], N[(x + a), $MachinePrecision], If[LessEqual[t, -1.6e-305], t$95$1, If[LessEqual[t, 6.8e-228], N[(x + a), $MachinePrecision], If[LessEqual[t, 9.2e+24], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], 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 -3.9 \cdot 10^{+71}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -9.5 \cdot 10^{-164}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2.2 \cdot 10^{-198}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq -1.6 \cdot 10^{-305}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6.8 \cdot 10^{-228}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq 9.2 \cdot 10^{+24}:\\
\;\;\;\;z \cdot \left(1 - y\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -3.9000000000000001e71 or 9.1999999999999996e24 < t Initial program 88.7%
associate-+l-88.7%
*-commutative88.7%
*-commutative88.7%
sub-neg88.7%
metadata-eval88.7%
remove-double-neg88.7%
remove-double-neg88.7%
sub-neg88.7%
metadata-eval88.7%
associate--l+88.7%
Simplified88.7%
Taylor expanded in t around inf 72.9%
if -3.9000000000000001e71 < t < -9.5000000000000001e-164 or -2.2e-198 < t < -1.60000000000000004e-305Initial program 98.7%
associate-+l-98.7%
*-commutative98.7%
*-commutative98.7%
sub-neg98.7%
metadata-eval98.7%
remove-double-neg98.7%
remove-double-neg98.7%
sub-neg98.7%
metadata-eval98.7%
associate--l+98.7%
Simplified98.7%
Taylor expanded in y around inf 50.6%
if -9.5000000000000001e-164 < t < -2.2e-198 or -1.60000000000000004e-305 < t < 6.79999999999999981e-228Initial 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 83.9%
sub-neg83.9%
metadata-eval83.9%
*-commutative83.9%
distribute-lft-in83.9%
*-commutative83.9%
mul-1-neg83.9%
unsub-neg83.9%
Simplified83.9%
Taylor expanded in z around 0 78.4%
Taylor expanded in t around 0 78.4%
if 6.79999999999999981e-228 < t < 9.1999999999999996e24Initial program 97.9%
associate-+l-97.9%
*-commutative97.9%
*-commutative97.9%
sub-neg97.9%
metadata-eval97.9%
remove-double-neg97.9%
remove-double-neg97.9%
sub-neg97.9%
metadata-eval97.9%
associate--l+97.9%
Simplified97.9%
Taylor expanded in z around inf 46.8%
Final simplification61.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y)))) (t_2 (* t (- b a))))
(if (<= t -3.4e+62)
t_2
(if (<= t -1.16e-54)
t_1
(if (<= t 9.2e+22)
(+ a (+ (+ x z) (* b -2.0)))
(if (<= t 8e+92)
(* b (- (+ t y) 2.0))
(if (<= t 3.8e+120) 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));
double t_2 = t * (b - a);
double tmp;
if (t <= -3.4e+62) {
tmp = t_2;
} else if (t <= -1.16e-54) {
tmp = t_1;
} else if (t <= 9.2e+22) {
tmp = a + ((x + z) + (b * -2.0));
} else if (t <= 8e+92) {
tmp = b * ((t + y) - 2.0);
} else if (t <= 3.8e+120) {
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))
t_2 = t * (b - a)
if (t <= (-3.4d+62)) then
tmp = t_2
else if (t <= (-1.16d-54)) then
tmp = t_1
else if (t <= 9.2d+22) then
tmp = a + ((x + z) + (b * (-2.0d0)))
else if (t <= 8d+92) then
tmp = b * ((t + y) - 2.0d0)
else if (t <= 3.8d+120) 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));
double t_2 = t * (b - a);
double tmp;
if (t <= -3.4e+62) {
tmp = t_2;
} else if (t <= -1.16e-54) {
tmp = t_1;
} else if (t <= 9.2e+22) {
tmp = a + ((x + z) + (b * -2.0));
} else if (t <= 8e+92) {
tmp = b * ((t + y) - 2.0);
} else if (t <= 3.8e+120) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = t * (b - a) tmp = 0 if t <= -3.4e+62: tmp = t_2 elif t <= -1.16e-54: tmp = t_1 elif t <= 9.2e+22: tmp = a + ((x + z) + (b * -2.0)) elif t <= 8e+92: tmp = b * ((t + y) - 2.0) elif t <= 3.8e+120: tmp = t_1 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(t * Float64(b - a)) tmp = 0.0 if (t <= -3.4e+62) tmp = t_2; elseif (t <= -1.16e-54) tmp = t_1; elseif (t <= 9.2e+22) tmp = Float64(a + Float64(Float64(x + z) + Float64(b * -2.0))); elseif (t <= 8e+92) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); elseif (t <= 3.8e+120) 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)); t_2 = t * (b - a); tmp = 0.0; if (t <= -3.4e+62) tmp = t_2; elseif (t <= -1.16e-54) tmp = t_1; elseif (t <= 9.2e+22) tmp = a + ((x + z) + (b * -2.0)); elseif (t <= 8e+92) tmp = b * ((t + y) - 2.0); elseif (t <= 3.8e+120) 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 * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.4e+62], t$95$2, If[LessEqual[t, -1.16e-54], t$95$1, If[LessEqual[t, 9.2e+22], N[(a + N[(N[(x + z), $MachinePrecision] + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e+92], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.8e+120], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -3.4 \cdot 10^{+62}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.16 \cdot 10^{-54}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 9.2 \cdot 10^{+22}:\\
\;\;\;\;a + \left(\left(x + z\right) + b \cdot -2\right)\\
\mathbf{elif}\;t \leq 8 \cdot 10^{+92}:\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{+120}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -3.40000000000000014e62 or 3.7999999999999998e120 < t Initial program 87.5%
associate-+l-87.5%
*-commutative87.5%
*-commutative87.5%
sub-neg87.5%
metadata-eval87.5%
remove-double-neg87.5%
remove-double-neg87.5%
sub-neg87.5%
metadata-eval87.5%
associate--l+87.5%
Simplified87.5%
Taylor expanded in t around inf 77.5%
if -3.40000000000000014e62 < t < -1.16e-54 or 8.0000000000000003e92 < t < 3.7999999999999998e120Initial 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 71.5%
sub-neg71.5%
metadata-eval71.5%
*-commutative71.5%
distribute-lft-in71.5%
*-commutative71.5%
mul-1-neg71.5%
unsub-neg71.5%
Simplified71.5%
Taylor expanded in a around 0 68.2%
if -1.16e-54 < t < 9.2000000000000008e22Initial program 98.2%
sub-neg98.2%
+-commutative98.2%
associate-+l+98.2%
*-commutative98.2%
distribute-rgt-neg-in98.2%
+-commutative98.2%
fma-def98.2%
neg-sub098.2%
associate--r-98.2%
neg-sub098.2%
+-commutative98.2%
sub-neg98.2%
fma-def99.1%
sub-neg99.1%
associate-+l+99.1%
metadata-eval99.1%
sub-neg99.1%
+-commutative99.1%
Simplified99.1%
Taylor expanded in y around 0 67.3%
Taylor expanded in t around 0 63.8%
if 9.2000000000000008e22 < t < 8.0000000000000003e92Initial 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 73.4%
Final simplification70.3%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -3.8e+76) (not (<= b 2.2e+73))) (* b (- (+ t y) 2.0)) (+ (+ 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 <= -3.8e+76) || !(b <= 2.2e+73)) {
tmp = b * ((t + y) - 2.0);
} 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 <= (-3.8d+76)) .or. (.not. (b <= 2.2d+73))) then
tmp = b * ((t + y) - 2.0d0)
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 <= -3.8e+76) || !(b <= 2.2e+73)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + (z * (1.0 - y))) + (a - (t * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -3.8e+76) or not (b <= 2.2e+73): tmp = b * ((t + y) - 2.0) 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 <= -3.8e+76) || !(b <= 2.2e+73)) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); 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 <= -3.8e+76) || ~((b <= 2.2e+73))) tmp = b * ((t + y) - 2.0); 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, -3.8e+76], N[Not[LessEqual[b, 2.2e+73]], $MachinePrecision]], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $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 -3.8 \cdot 10^{+76} \lor \neg \left(b \leq 2.2 \cdot 10^{+73}\right):\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + \left(a - t \cdot a\right)\\
\end{array}
\end{array}
if b < -3.80000000000000024e76 or 2.2e73 < b Initial 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 b around inf 74.9%
if -3.80000000000000024e76 < b < 2.2e73Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in a around inf 87.2%
sub-neg87.2%
metadata-eval87.2%
*-commutative87.2%
distribute-lft-in87.1%
*-commutative87.1%
mul-1-neg87.1%
unsub-neg87.1%
Simplified87.1%
Final simplification82.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- a))))
(if (<= t -3.9e+59)
t_1
(if (<= t -1.55e-198)
(+ x a)
(if (<= t -4e-305)
(* y b)
(if (<= t 1.6e+122)
(+ x a)
(if (or (<= t 3.2e+242) (not (<= t 3.1e+275))) t_1 (* t b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * -a;
double tmp;
if (t <= -3.9e+59) {
tmp = t_1;
} else if (t <= -1.55e-198) {
tmp = x + a;
} else if (t <= -4e-305) {
tmp = y * b;
} else if (t <= 1.6e+122) {
tmp = x + a;
} else if ((t <= 3.2e+242) || !(t <= 3.1e+275)) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = t * -a
if (t <= (-3.9d+59)) then
tmp = t_1
else if (t <= (-1.55d-198)) then
tmp = x + a
else if (t <= (-4d-305)) then
tmp = y * b
else if (t <= 1.6d+122) then
tmp = x + a
else if ((t <= 3.2d+242) .or. (.not. (t <= 3.1d+275))) then
tmp = t_1
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 t_1 = t * -a;
double tmp;
if (t <= -3.9e+59) {
tmp = t_1;
} else if (t <= -1.55e-198) {
tmp = x + a;
} else if (t <= -4e-305) {
tmp = y * b;
} else if (t <= 1.6e+122) {
tmp = x + a;
} else if ((t <= 3.2e+242) || !(t <= 3.1e+275)) {
tmp = t_1;
} else {
tmp = t * b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * -a tmp = 0 if t <= -3.9e+59: tmp = t_1 elif t <= -1.55e-198: tmp = x + a elif t <= -4e-305: tmp = y * b elif t <= 1.6e+122: tmp = x + a elif (t <= 3.2e+242) or not (t <= 3.1e+275): tmp = t_1 else: tmp = t * b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(-a)) tmp = 0.0 if (t <= -3.9e+59) tmp = t_1; elseif (t <= -1.55e-198) tmp = Float64(x + a); elseif (t <= -4e-305) tmp = Float64(y * b); elseif (t <= 1.6e+122) tmp = Float64(x + a); elseif ((t <= 3.2e+242) || !(t <= 3.1e+275)) tmp = t_1; else tmp = Float64(t * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * -a; tmp = 0.0; if (t <= -3.9e+59) tmp = t_1; elseif (t <= -1.55e-198) tmp = x + a; elseif (t <= -4e-305) tmp = y * b; elseif (t <= 1.6e+122) tmp = x + a; elseif ((t <= 3.2e+242) || ~((t <= 3.1e+275))) tmp = t_1; else tmp = t * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * (-a)), $MachinePrecision]}, If[LessEqual[t, -3.9e+59], t$95$1, If[LessEqual[t, -1.55e-198], N[(x + a), $MachinePrecision], If[LessEqual[t, -4e-305], N[(y * b), $MachinePrecision], If[LessEqual[t, 1.6e+122], N[(x + a), $MachinePrecision], If[Or[LessEqual[t, 3.2e+242], N[Not[LessEqual[t, 3.1e+275]], $MachinePrecision]], t$95$1, N[(t * b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(-a\right)\\
\mathbf{if}\;t \leq -3.9 \cdot 10^{+59}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.55 \cdot 10^{-198}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq -4 \cdot 10^{-305}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 1.6 \cdot 10^{+122}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{+242} \lor \neg \left(t \leq 3.1 \cdot 10^{+275}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t \cdot b\\
\end{array}
\end{array}
if t < -3.90000000000000021e59 or 1.60000000000000006e122 < t < 3.2000000000000002e242 or 3.0999999999999999e275 < t Initial program 87.2%
associate-+l-87.2%
*-commutative87.2%
*-commutative87.2%
sub-neg87.2%
metadata-eval87.2%
remove-double-neg87.2%
remove-double-neg87.2%
sub-neg87.2%
metadata-eval87.2%
associate--l+87.2%
Simplified87.2%
Taylor expanded in a around inf 54.3%
Taylor expanded in t around inf 54.3%
associate-*r*54.3%
neg-mul-154.3%
Simplified54.3%
if -3.90000000000000021e59 < t < -1.5499999999999999e-198 or -3.99999999999999999e-305 < t < 1.60000000000000006e122Initial 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 a around inf 68.8%
sub-neg68.8%
metadata-eval68.8%
*-commutative68.8%
distribute-lft-in68.8%
*-commutative68.8%
mul-1-neg68.8%
unsub-neg68.8%
Simplified68.8%
Taylor expanded in z around 0 36.5%
Taylor expanded in t around 0 35.0%
if -1.5499999999999999e-198 < t < -3.99999999999999999e-305Initial 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 56.4%
Taylor expanded in y around inf 42.5%
if 3.2000000000000002e242 < t < 3.0999999999999999e275Initial program 90.0%
associate-+l-90.0%
*-commutative90.0%
*-commutative90.0%
sub-neg90.0%
metadata-eval90.0%
remove-double-neg90.0%
remove-double-neg90.0%
sub-neg90.0%
metadata-eval90.0%
associate--l+90.0%
Simplified90.0%
Taylor expanded in b around inf 70.3%
Taylor expanded in t around inf 70.3%
Final simplification44.1%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -8.4e+64) (not (<= b 3.6e+74))) (* b (- (+ t y) 2.0)) (- (+ x (* z (- 1.0 y))) (* t a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -8.4e+64) || !(b <= 3.6e+74)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + (z * (1.0 - y))) - (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 <= (-8.4d+64)) .or. (.not. (b <= 3.6d+74))) then
tmp = b * ((t + y) - 2.0d0)
else
tmp = (x + (z * (1.0d0 - y))) - (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 <= -8.4e+64) || !(b <= 3.6e+74)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + (z * (1.0 - y))) - (t * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -8.4e+64) or not (b <= 3.6e+74): tmp = b * ((t + y) - 2.0) else: tmp = (x + (z * (1.0 - y))) - (t * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -8.4e+64) || !(b <= 3.6e+74)) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); else tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) - Float64(t * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -8.4e+64) || ~((b <= 3.6e+74))) tmp = b * ((t + y) - 2.0); else tmp = (x + (z * (1.0 - y))) - (t * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -8.4e+64], N[Not[LessEqual[b, 3.6e+74]], $MachinePrecision]], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -8.4 \cdot 10^{+64} \lor \neg \left(b \leq 3.6 \cdot 10^{+74}\right):\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) - t \cdot a\\
\end{array}
\end{array}
if b < -8.4000000000000001e64 or 3.59999999999999988e74 < b Initial program 89.3%
associate-+l-89.3%
*-commutative89.3%
*-commutative89.3%
sub-neg89.3%
metadata-eval89.3%
remove-double-neg89.3%
remove-double-neg89.3%
sub-neg89.3%
metadata-eval89.3%
associate--l+89.3%
Simplified89.3%
Taylor expanded in b around inf 74.0%
if -8.4000000000000001e64 < b < 3.59999999999999988e74Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in a around inf 87.5%
sub-neg87.5%
metadata-eval87.5%
*-commutative87.5%
distribute-lft-in87.5%
*-commutative87.5%
mul-1-neg87.5%
unsub-neg87.5%
Simplified87.5%
Taylor expanded in t around inf 75.8%
*-commutative75.8%
Simplified75.8%
Final simplification75.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t))))
(if (<= y -7.5e+74)
(* y (- z))
(if (<= y 2.5e-117)
t_1
(if (<= y 3.6e-79) z (if (<= y 1.2e+138) t_1 (* y b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double tmp;
if (y <= -7.5e+74) {
tmp = y * -z;
} else if (y <= 2.5e-117) {
tmp = t_1;
} else if (y <= 3.6e-79) {
tmp = z;
} else if (y <= 1.2e+138) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = a * (1.0d0 - t)
if (y <= (-7.5d+74)) then
tmp = y * -z
else if (y <= 2.5d-117) then
tmp = t_1
else if (y <= 3.6d-79) then
tmp = z
else if (y <= 1.2d+138) then
tmp = t_1
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 t_1 = a * (1.0 - t);
double tmp;
if (y <= -7.5e+74) {
tmp = y * -z;
} else if (y <= 2.5e-117) {
tmp = t_1;
} else if (y <= 3.6e-79) {
tmp = z;
} else if (y <= 1.2e+138) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) tmp = 0 if y <= -7.5e+74: tmp = y * -z elif y <= 2.5e-117: tmp = t_1 elif y <= 3.6e-79: tmp = z elif y <= 1.2e+138: tmp = t_1 else: tmp = y * b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(1.0 - t)) tmp = 0.0 if (y <= -7.5e+74) tmp = Float64(y * Float64(-z)); elseif (y <= 2.5e-117) tmp = t_1; elseif (y <= 3.6e-79) tmp = z; elseif (y <= 1.2e+138) tmp = t_1; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (1.0 - t); tmp = 0.0; if (y <= -7.5e+74) tmp = y * -z; elseif (y <= 2.5e-117) tmp = t_1; elseif (y <= 3.6e-79) tmp = z; elseif (y <= 1.2e+138) tmp = t_1; else tmp = y * b; 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[y, -7.5e+74], N[(y * (-z)), $MachinePrecision], If[LessEqual[y, 2.5e-117], t$95$1, If[LessEqual[y, 3.6e-79], z, If[LessEqual[y, 1.2e+138], t$95$1, N[(y * b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;y \leq -7.5 \cdot 10^{+74}:\\
\;\;\;\;y \cdot \left(-z\right)\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{-117}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{-79}:\\
\;\;\;\;z\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{+138}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -7.5e74Initial 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 inf 43.2%
Taylor expanded in y around inf 43.2%
mul-1-neg43.2%
distribute-rgt-neg-in43.2%
Simplified43.2%
if -7.5e74 < y < 2.5e-117 or 3.6000000000000002e-79 < y < 1.2e138Initial program 94.5%
associate-+l-94.5%
*-commutative94.5%
*-commutative94.5%
sub-neg94.5%
metadata-eval94.5%
remove-double-neg94.5%
remove-double-neg94.5%
sub-neg94.5%
metadata-eval94.5%
associate--l+94.5%
Simplified94.5%
Taylor expanded in a around inf 39.8%
if 2.5e-117 < y < 3.6000000000000002e-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 100.0%
Taylor expanded in z around inf 63.5%
if 1.2e138 < y Initial program 80.0%
associate-+l-80.0%
*-commutative80.0%
*-commutative80.0%
sub-neg80.0%
metadata-eval80.0%
remove-double-neg80.0%
remove-double-neg80.0%
sub-neg80.0%
metadata-eval80.0%
associate--l+80.0%
Simplified80.0%
Taylor expanded in b around inf 63.8%
Taylor expanded in y around inf 64.0%
Final simplification44.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -2.35e+17)
t_1
(if (<= t -1.65e-198)
(+ x a)
(if (<= t -4e-305) (* y b) (if (<= t 2.8e+120) (+ x a) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -2.35e+17) {
tmp = t_1;
} else if (t <= -1.65e-198) {
tmp = x + a;
} else if (t <= -4e-305) {
tmp = y * b;
} else if (t <= 2.8e+120) {
tmp = x + a;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-2.35d+17)) then
tmp = t_1
else if (t <= (-1.65d-198)) then
tmp = x + a
else if (t <= (-4d-305)) then
tmp = y * b
else if (t <= 2.8d+120) then
tmp = x + a
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -2.35e+17) {
tmp = t_1;
} else if (t <= -1.65e-198) {
tmp = x + a;
} else if (t <= -4e-305) {
tmp = y * b;
} else if (t <= 2.8e+120) {
tmp = x + a;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -2.35e+17: tmp = t_1 elif t <= -1.65e-198: tmp = x + a elif t <= -4e-305: tmp = y * b elif t <= 2.8e+120: tmp = x + a else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -2.35e+17) tmp = t_1; elseif (t <= -1.65e-198) tmp = Float64(x + a); elseif (t <= -4e-305) tmp = Float64(y * b); elseif (t <= 2.8e+120) tmp = Float64(x + a); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -2.35e+17) tmp = t_1; elseif (t <= -1.65e-198) tmp = x + a; elseif (t <= -4e-305) tmp = y * b; elseif (t <= 2.8e+120) tmp = x + a; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.35e+17], t$95$1, If[LessEqual[t, -1.65e-198], N[(x + a), $MachinePrecision], If[LessEqual[t, -4e-305], N[(y * b), $MachinePrecision], If[LessEqual[t, 2.8e+120], N[(x + a), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.35 \cdot 10^{+17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.65 \cdot 10^{-198}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;t \leq -4 \cdot 10^{-305}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{+120}:\\
\;\;\;\;x + a\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.35e17 or 2.8000000000000001e120 < t Initial program 88.6%
associate-+l-88.6%
*-commutative88.6%
*-commutative88.6%
sub-neg88.6%
metadata-eval88.6%
remove-double-neg88.6%
remove-double-neg88.6%
sub-neg88.6%
metadata-eval88.6%
associate--l+88.6%
Simplified88.6%
Taylor expanded in t around inf 72.7%
if -2.35e17 < t < -1.65e-198 or -3.99999999999999999e-305 < t < 2.8000000000000001e120Initial 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 a around inf 69.5%
sub-neg69.5%
metadata-eval69.5%
*-commutative69.5%
distribute-lft-in69.5%
*-commutative69.5%
mul-1-neg69.5%
unsub-neg69.5%
Simplified69.5%
Taylor expanded in z around 0 38.1%
Taylor expanded in t around 0 36.5%
if -1.65e-198 < t < -3.99999999999999999e-305Initial 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 56.4%
Taylor expanded in y around inf 42.5%
Final simplification53.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* b (- (+ t y) 2.0))))
(if (<= b -1.9e+60)
t_1
(if (<= b 8.5e-184)
(- (+ x z) (* t a))
(if (<= b 2.7e+35) (- (+ x a) (* t a)) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = b * ((t + y) - 2.0);
double tmp;
if (b <= -1.9e+60) {
tmp = t_1;
} else if (b <= 8.5e-184) {
tmp = (x + z) - (t * a);
} else if (b <= 2.7e+35) {
tmp = (x + a) - (t * a);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((t + y) - 2.0d0)
if (b <= (-1.9d+60)) then
tmp = t_1
else if (b <= 8.5d-184) then
tmp = (x + z) - (t * a)
else if (b <= 2.7d+35) then
tmp = (x + a) - (t * a)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = b * ((t + y) - 2.0);
double tmp;
if (b <= -1.9e+60) {
tmp = t_1;
} else if (b <= 8.5e-184) {
tmp = (x + z) - (t * a);
} else if (b <= 2.7e+35) {
tmp = (x + a) - (t * a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = b * ((t + y) - 2.0) tmp = 0 if b <= -1.9e+60: tmp = t_1 elif b <= 8.5e-184: tmp = (x + z) - (t * a) elif b <= 2.7e+35: tmp = (x + a) - (t * a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -1.9e+60) tmp = t_1; elseif (b <= 8.5e-184) tmp = Float64(Float64(x + z) - Float64(t * a)); elseif (b <= 2.7e+35) tmp = Float64(Float64(x + a) - Float64(t * a)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -1.9e+60) tmp = t_1; elseif (b <= 8.5e-184) tmp = (x + z) - (t * a); elseif (b <= 2.7e+35) tmp = (x + a) - (t * a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.9e+60], t$95$1, If[LessEqual[b, 8.5e-184], N[(N[(x + z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.7e+35], N[(N[(x + a), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -1.9 \cdot 10^{+60}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 8.5 \cdot 10^{-184}:\\
\;\;\;\;\left(x + z\right) - t \cdot a\\
\mathbf{elif}\;b \leq 2.7 \cdot 10^{+35}:\\
\;\;\;\;\left(x + a\right) - t \cdot a\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if b < -1.90000000000000005e60 or 2.70000000000000003e35 < b Initial program 89.1%
associate-+l-89.1%
*-commutative89.1%
*-commutative89.1%
sub-neg89.1%
metadata-eval89.1%
remove-double-neg89.1%
remove-double-neg89.1%
sub-neg89.1%
metadata-eval89.1%
associate--l+89.1%
Simplified89.1%
Taylor expanded in b around inf 72.2%
if -1.90000000000000005e60 < b < 8.50000000000000036e-184Initial program 97.0%
associate-+l-97.0%
*-commutative97.0%
*-commutative97.0%
sub-neg97.0%
metadata-eval97.0%
remove-double-neg97.0%
remove-double-neg97.0%
sub-neg97.0%
metadata-eval97.0%
associate--l+97.0%
Simplified97.0%
Taylor expanded in a around inf 91.4%
sub-neg91.4%
metadata-eval91.4%
*-commutative91.4%
distribute-lft-in91.4%
*-commutative91.4%
mul-1-neg91.4%
unsub-neg91.4%
Simplified91.4%
Taylor expanded in t around inf 82.2%
*-commutative82.2%
Simplified82.2%
Taylor expanded in y around 0 66.0%
cancel-sign-sub-inv66.0%
metadata-eval66.0%
*-lft-identity66.0%
+-commutative66.0%
Simplified66.0%
if 8.50000000000000036e-184 < b < 2.70000000000000003e35Initial 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 83.3%
sub-neg83.3%
metadata-eval83.3%
*-commutative83.3%
distribute-lft-in83.3%
*-commutative83.3%
mul-1-neg83.3%
unsub-neg83.3%
Simplified83.3%
Taylor expanded in z around 0 54.9%
Final simplification66.7%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -1e+60) (not (<= b 6.2e+39))) (* b (- (+ t y) 2.0)) (+ (+ x z) (- a (* t a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -1e+60) || !(b <= 6.2e+39)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + z) + (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 <= (-1d+60)) .or. (.not. (b <= 6.2d+39))) then
tmp = b * ((t + y) - 2.0d0)
else
tmp = (x + z) + (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 <= -1e+60) || !(b <= 6.2e+39)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + z) + (a - (t * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -1e+60) or not (b <= 6.2e+39): tmp = b * ((t + y) - 2.0) else: tmp = (x + z) + (a - (t * a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -1e+60) || !(b <= 6.2e+39)) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); else tmp = Float64(Float64(x + z) + Float64(a - Float64(t * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -1e+60) || ~((b <= 6.2e+39))) tmp = b * ((t + y) - 2.0); else tmp = (x + z) + (a - (t * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -1e+60], N[Not[LessEqual[b, 6.2e+39]], $MachinePrecision]], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x + z), $MachinePrecision] + N[(a - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1 \cdot 10^{+60} \lor \neg \left(b \leq 6.2 \cdot 10^{+39}\right):\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z\right) + \left(a - t \cdot a\right)\\
\end{array}
\end{array}
if b < -9.9999999999999995e59 or 6.2000000000000005e39 < b Initial program 89.1%
associate-+l-89.1%
*-commutative89.1%
*-commutative89.1%
sub-neg89.1%
metadata-eval89.1%
remove-double-neg89.1%
remove-double-neg89.1%
sub-neg89.1%
metadata-eval89.1%
associate--l+89.1%
Simplified89.1%
Taylor expanded in b around inf 72.2%
if -9.9999999999999995e59 < b < 6.2000000000000005e39Initial program 97.9%
associate-+l-97.9%
*-commutative97.9%
*-commutative97.9%
sub-neg97.9%
metadata-eval97.9%
remove-double-neg97.9%
remove-double-neg97.9%
sub-neg97.9%
metadata-eval97.9%
associate--l+97.9%
Simplified97.9%
Taylor expanded in a around inf 88.9%
sub-neg88.9%
metadata-eval88.9%
*-commutative88.9%
distribute-lft-in88.9%
*-commutative88.9%
mul-1-neg88.9%
unsub-neg88.9%
Simplified88.9%
Taylor expanded in y around 0 70.8%
cancel-sign-sub-inv58.5%
metadata-eval58.5%
*-lft-identity58.5%
+-commutative58.5%
Simplified70.8%
Final simplification71.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= x -5.5e+78)
x
(if (<= x -3.6e-110)
(* t b)
(if (<= x 5.2e-204) z (if (<= x 3.3e+131) (* t b) x)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -5.5e+78) {
tmp = x;
} else if (x <= -3.6e-110) {
tmp = t * b;
} else if (x <= 5.2e-204) {
tmp = z;
} else if (x <= 3.3e+131) {
tmp = t * b;
} else {
tmp = x;
}
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 (x <= (-5.5d+78)) then
tmp = x
else if (x <= (-3.6d-110)) then
tmp = t * b
else if (x <= 5.2d-204) then
tmp = z
else if (x <= 3.3d+131) then
tmp = t * b
else
tmp = x
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 (x <= -5.5e+78) {
tmp = x;
} else if (x <= -3.6e-110) {
tmp = t * b;
} else if (x <= 5.2e-204) {
tmp = z;
} else if (x <= 3.3e+131) {
tmp = t * b;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -5.5e+78: tmp = x elif x <= -3.6e-110: tmp = t * b elif x <= 5.2e-204: tmp = z elif x <= 3.3e+131: tmp = t * b else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -5.5e+78) tmp = x; elseif (x <= -3.6e-110) tmp = Float64(t * b); elseif (x <= 5.2e-204) tmp = z; elseif (x <= 3.3e+131) tmp = Float64(t * b); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -5.5e+78) tmp = x; elseif (x <= -3.6e-110) tmp = t * b; elseif (x <= 5.2e-204) tmp = z; elseif (x <= 3.3e+131) tmp = t * b; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -5.5e+78], x, If[LessEqual[x, -3.6e-110], N[(t * b), $MachinePrecision], If[LessEqual[x, 5.2e-204], z, If[LessEqual[x, 3.3e+131], N[(t * b), $MachinePrecision], x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.5 \cdot 10^{+78}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq -3.6 \cdot 10^{-110}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;x \leq 5.2 \cdot 10^{-204}:\\
\;\;\;\;z\\
\mathbf{elif}\;x \leq 3.3 \cdot 10^{+131}:\\
\;\;\;\;t \cdot b\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -5.4999999999999997e78 or 3.2999999999999998e131 < x 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 x around inf 38.4%
if -5.4999999999999997e78 < x < -3.59999999999999995e-110 or 5.19999999999999965e-204 < x < 3.2999999999999998e131Initial program 97.2%
associate-+l-97.2%
*-commutative97.2%
*-commutative97.2%
sub-neg97.2%
metadata-eval97.2%
remove-double-neg97.2%
remove-double-neg97.2%
sub-neg97.2%
metadata-eval97.2%
associate--l+97.2%
Simplified97.2%
Taylor expanded in b around inf 48.8%
Taylor expanded in t around inf 29.6%
if -3.59999999999999995e-110 < x < 5.19999999999999965e-204Initial program 90.9%
sub-neg90.9%
+-commutative90.9%
associate-+l+90.9%
*-commutative90.9%
distribute-rgt-neg-in90.9%
+-commutative90.9%
fma-def92.4%
neg-sub092.4%
associate--r-92.4%
neg-sub092.4%
+-commutative92.4%
sub-neg92.4%
fma-def92.4%
sub-neg92.4%
associate-+l+92.4%
metadata-eval92.4%
sub-neg92.4%
+-commutative92.4%
Simplified92.4%
Taylor expanded in y around 0 63.8%
Taylor expanded in z around inf 19.6%
Final simplification29.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -2.7e+64) (not (<= b 8e+36))) (* b (- (+ t y) 2.0)) (- (+ x a) (* t a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -2.7e+64) || !(b <= 8e+36)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + 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 <= (-2.7d+64)) .or. (.not. (b <= 8d+36))) then
tmp = b * ((t + y) - 2.0d0)
else
tmp = (x + 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 <= -2.7e+64) || !(b <= 8e+36)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + a) - (t * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -2.7e+64) or not (b <= 8e+36): tmp = b * ((t + y) - 2.0) else: tmp = (x + a) - (t * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -2.7e+64) || !(b <= 8e+36)) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); else tmp = Float64(Float64(x + a) - Float64(t * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -2.7e+64) || ~((b <= 8e+36))) tmp = b * ((t + y) - 2.0); else tmp = (x + a) - (t * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -2.7e+64], N[Not[LessEqual[b, 8e+36]], $MachinePrecision]], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x + a), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.7 \cdot 10^{+64} \lor \neg \left(b \leq 8 \cdot 10^{+36}\right):\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + a\right) - t \cdot a\\
\end{array}
\end{array}
if b < -2.7e64 or 8.00000000000000034e36 < b Initial program 89.1%
associate-+l-89.1%
*-commutative89.1%
*-commutative89.1%
sub-neg89.1%
metadata-eval89.1%
remove-double-neg89.1%
remove-double-neg89.1%
sub-neg89.1%
metadata-eval89.1%
associate--l+89.1%
Simplified89.1%
Taylor expanded in b around inf 72.2%
if -2.7e64 < b < 8.00000000000000034e36Initial program 97.9%
associate-+l-97.9%
*-commutative97.9%
*-commutative97.9%
sub-neg97.9%
metadata-eval97.9%
remove-double-neg97.9%
remove-double-neg97.9%
sub-neg97.9%
metadata-eval97.9%
associate--l+97.9%
Simplified97.9%
Taylor expanded in a around inf 88.9%
sub-neg88.9%
metadata-eval88.9%
*-commutative88.9%
distribute-lft-in88.9%
*-commutative88.9%
mul-1-neg88.9%
unsub-neg88.9%
Simplified88.9%
Taylor expanded in z around 0 57.3%
Final simplification63.7%
(FPCore (x y z t a b) :precision binary64 (if (<= x -4.4e+189) x (if (<= x 6e-204) (* y b) (if (<= x 5e+129) (* t b) x))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -4.4e+189) {
tmp = x;
} else if (x <= 6e-204) {
tmp = y * b;
} else if (x <= 5e+129) {
tmp = t * b;
} else {
tmp = x;
}
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 (x <= (-4.4d+189)) then
tmp = x
else if (x <= 6d-204) then
tmp = y * b
else if (x <= 5d+129) then
tmp = t * b
else
tmp = x
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 (x <= -4.4e+189) {
tmp = x;
} else if (x <= 6e-204) {
tmp = y * b;
} else if (x <= 5e+129) {
tmp = t * b;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -4.4e+189: tmp = x elif x <= 6e-204: tmp = y * b elif x <= 5e+129: tmp = t * b else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -4.4e+189) tmp = x; elseif (x <= 6e-204) tmp = Float64(y * b); elseif (x <= 5e+129) tmp = Float64(t * b); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -4.4e+189) tmp = x; elseif (x <= 6e-204) tmp = y * b; elseif (x <= 5e+129) tmp = t * b; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -4.4e+189], x, If[LessEqual[x, 6e-204], N[(y * b), $MachinePrecision], If[LessEqual[x, 5e+129], N[(t * b), $MachinePrecision], x]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -4.4 \cdot 10^{+189}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 6 \cdot 10^{-204}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;x \leq 5 \cdot 10^{+129}:\\
\;\;\;\;t \cdot b\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -4.4000000000000001e189 or 5.0000000000000003e129 < x 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 x around inf 49.1%
if -4.4000000000000001e189 < x < 5.9999999999999997e-204Initial 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 43.7%
Taylor expanded in y around inf 24.3%
if 5.9999999999999997e-204 < x < 5.0000000000000003e129Initial program 97.1%
associate-+l-97.1%
*-commutative97.1%
*-commutative97.1%
sub-neg97.1%
metadata-eval97.1%
remove-double-neg97.1%
remove-double-neg97.1%
sub-neg97.1%
metadata-eval97.1%
associate--l+97.1%
Simplified97.1%
Taylor expanded in b around inf 41.9%
Taylor expanded in t around inf 28.0%
Final simplification30.9%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.35e+113) (* t b) (if (<= b 3.2e+24) (+ x a) (if (<= b 1.7e+151) (* t b) (* y b)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.35e+113) {
tmp = t * b;
} else if (b <= 3.2e+24) {
tmp = x + a;
} else if (b <= 1.7e+151) {
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 (b <= (-1.35d+113)) then
tmp = t * b
else if (b <= 3.2d+24) then
tmp = x + a
else if (b <= 1.7d+151) 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 (b <= -1.35e+113) {
tmp = t * b;
} else if (b <= 3.2e+24) {
tmp = x + a;
} else if (b <= 1.7e+151) {
tmp = t * b;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.35e+113: tmp = t * b elif b <= 3.2e+24: tmp = x + a elif b <= 1.7e+151: tmp = t * b else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.35e+113) tmp = Float64(t * b); elseif (b <= 3.2e+24) tmp = Float64(x + a); elseif (b <= 1.7e+151) 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 (b <= -1.35e+113) tmp = t * b; elseif (b <= 3.2e+24) tmp = x + a; elseif (b <= 1.7e+151) tmp = t * b; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.35e+113], N[(t * b), $MachinePrecision], If[LessEqual[b, 3.2e+24], N[(x + a), $MachinePrecision], If[LessEqual[b, 1.7e+151], N[(t * b), $MachinePrecision], N[(y * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.35 \cdot 10^{+113}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq 3.2 \cdot 10^{+24}:\\
\;\;\;\;x + a\\
\mathbf{elif}\;b \leq 1.7 \cdot 10^{+151}:\\
\;\;\;\;t \cdot b\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if b < -1.35000000000000006e113 or 3.1999999999999997e24 < b < 1.7e151Initial program 85.3%
associate-+l-85.3%
*-commutative85.3%
*-commutative85.3%
sub-neg85.3%
metadata-eval85.3%
remove-double-neg85.3%
remove-double-neg85.3%
sub-neg85.3%
metadata-eval85.3%
associate--l+85.3%
Simplified85.3%
Taylor expanded in b around inf 71.6%
Taylor expanded in t around inf 40.2%
if -1.35000000000000006e113 < b < 3.1999999999999997e24Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in a around inf 86.5%
sub-neg86.5%
metadata-eval86.5%
*-commutative86.5%
distribute-lft-in86.5%
*-commutative86.5%
mul-1-neg86.5%
unsub-neg86.5%
Simplified86.5%
Taylor expanded in z around 0 56.3%
Taylor expanded in t around 0 32.8%
if 1.7e151 < b Initial 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 b around inf 76.7%
Taylor expanded in y around inf 54.3%
Final simplification37.4%
(FPCore (x y z t a b) :precision binary64 (if (<= z -4.45e+86) z (if (<= z -8.5e-308) a (if (<= z 2.5e+71) x z))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= -4.45e+86) {
tmp = z;
} else if (z <= -8.5e-308) {
tmp = a;
} else if (z <= 2.5e+71) {
tmp = x;
} else {
tmp = 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 (z <= (-4.45d+86)) then
tmp = z
else if (z <= (-8.5d-308)) then
tmp = a
else if (z <= 2.5d+71) then
tmp = x
else
tmp = 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 (z <= -4.45e+86) {
tmp = z;
} else if (z <= -8.5e-308) {
tmp = a;
} else if (z <= 2.5e+71) {
tmp = x;
} else {
tmp = z;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if z <= -4.45e+86: tmp = z elif z <= -8.5e-308: tmp = a elif z <= 2.5e+71: tmp = x else: tmp = z return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (z <= -4.45e+86) tmp = z; elseif (z <= -8.5e-308) tmp = a; elseif (z <= 2.5e+71) tmp = x; else tmp = z; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (z <= -4.45e+86) tmp = z; elseif (z <= -8.5e-308) tmp = a; elseif (z <= 2.5e+71) tmp = x; else tmp = z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -4.45e+86], z, If[LessEqual[z, -8.5e-308], a, If[LessEqual[z, 2.5e+71], x, z]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.45 \cdot 10^{+86}:\\
\;\;\;\;z\\
\mathbf{elif}\;z \leq -8.5 \cdot 10^{-308}:\\
\;\;\;\;a\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{+71}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;z\\
\end{array}
\end{array}
if z < -4.45e86 or 2.49999999999999986e71 < z Initial program 91.3%
sub-neg91.3%
+-commutative91.3%
associate-+l+91.3%
*-commutative91.3%
distribute-rgt-neg-in91.3%
+-commutative91.3%
fma-def94.6%
neg-sub094.6%
associate--r-94.6%
neg-sub094.6%
+-commutative94.6%
sub-neg94.6%
fma-def95.7%
sub-neg95.7%
associate-+l+95.7%
metadata-eval95.7%
sub-neg95.7%
+-commutative95.7%
Simplified95.7%
Taylor expanded in y around 0 57.5%
Taylor expanded in z around inf 25.8%
if -4.45e86 < z < -8.49999999999999972e-308Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in a around inf 41.4%
Taylor expanded in t around 0 18.9%
if -8.49999999999999972e-308 < z < 2.49999999999999986e71Initial 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 x around inf 24.3%
Final simplification23.2%
(FPCore (x y z t a b) :precision binary64 (if (<= x -1.55e+81) x (if (<= x 2e+140) a x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -1.55e+81) {
tmp = x;
} else if (x <= 2e+140) {
tmp = a;
} else {
tmp = x;
}
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 (x <= (-1.55d+81)) then
tmp = x
else if (x <= 2d+140) then
tmp = a
else
tmp = x
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 (x <= -1.55e+81) {
tmp = x;
} else if (x <= 2e+140) {
tmp = a;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -1.55e+81: tmp = x elif x <= 2e+140: tmp = a else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -1.55e+81) tmp = x; elseif (x <= 2e+140) tmp = a; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -1.55e+81) tmp = x; elseif (x <= 2e+140) tmp = a; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.55e+81], x, If[LessEqual[x, 2e+140], a, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.55 \cdot 10^{+81}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 2 \cdot 10^{+140}:\\
\;\;\;\;a\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.55e81 or 2.00000000000000012e140 < x Initial program 95.0%
associate-+l-95.0%
*-commutative95.0%
*-commutative95.0%
sub-neg95.0%
metadata-eval95.0%
remove-double-neg95.0%
remove-double-neg95.0%
sub-neg95.0%
metadata-eval95.0%
associate--l+95.0%
Simplified95.0%
Taylor expanded in x around inf 40.1%
if -1.55e81 < x < 2.00000000000000012e140Initial 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 a around inf 36.9%
Taylor expanded in t around 0 12.8%
Final simplification21.4%
(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 94.1%
associate-+l-94.1%
*-commutative94.1%
*-commutative94.1%
sub-neg94.1%
metadata-eval94.1%
remove-double-neg94.1%
remove-double-neg94.1%
sub-neg94.1%
metadata-eval94.1%
associate--l+94.1%
Simplified94.1%
Taylor expanded in a around inf 30.7%
Taylor expanded in t around 0 10.4%
Final simplification10.4%
herbie shell --seed 2023240
(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)))