
(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
(let* ((t_1
(+
(- (- x (* z (+ y -1.0))) (* a (+ t -1.0)))
(* b (- (+ y t) 2.0)))))
(if (<= t_1 INFINITY) t_1 (* y (- b z)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((x - (z * (y + -1.0))) - (a * (t + -1.0))) + (b * ((y + t) - 2.0));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = y * (b - z);
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((x - (z * (y + -1.0))) - (a * (t + -1.0))) + (b * ((y + t) - 2.0));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = ((x - (z * (y + -1.0))) - (a * (t + -1.0))) + (b * ((y + t) - 2.0)) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(x - Float64(z * Float64(y + -1.0))) - Float64(a * Float64(t + -1.0))) + Float64(b * Float64(Float64(y + t) - 2.0))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = ((x - (z * (y + -1.0))) - (a * (t + -1.0))) + (b * ((y + t) - 2.0)); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = y * (b - z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(x - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(x - z \cdot \left(y + -1\right)\right) - a \cdot \left(t + -1\right)\right) + b \cdot \left(\left(y + t\right) - 2\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\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 y around inf 77.4%
Final simplification98.8%
(FPCore (x y z t a b) :precision binary64 (fma (+ y (+ t -2.0)) b (fma a (- 1.0 t) (fma z (- 1.0 y) x))))
double code(double x, double y, double z, double t, double a, double b) {
return fma((y + (t + -2.0)), b, fma(a, (1.0 - t), fma(z, (1.0 - y), x)));
}
function code(x, y, z, t, a, b) return fma(Float64(y + Float64(t + -2.0)), b, fma(a, Float64(1.0 - t), fma(z, Float64(1.0 - y), x))) end
code[x_, y_, z_, t_, a_, b_] := N[(N[(y + N[(t + -2.0), $MachinePrecision]), $MachinePrecision] * b + N[(a * N[(1.0 - t), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y + \left(t + -2\right), b, \mathsf{fma}\left(a, 1 - t, \mathsf{fma}\left(z, 1 - y, x\right)\right)\right)
\end{array}
Initial program 94.9%
+-commutative94.9%
fma-def97.3%
sub-neg97.3%
associate-+l+97.3%
metadata-eval97.3%
sub-neg97.3%
+-commutative97.3%
*-commutative97.3%
distribute-rgt-neg-in97.3%
fma-def98.0%
neg-sub098.0%
associate--r-98.0%
neg-sub098.0%
+-commutative98.0%
sub-neg98.0%
sub-neg98.0%
+-commutative98.0%
*-commutative98.0%
distribute-rgt-neg-in98.0%
fma-def98.0%
Simplified98.0%
Final simplification98.0%
(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.9%
+-commutative94.9%
fma-def97.3%
+-commutative97.3%
associate--l+97.3%
sub-neg97.3%
associate-+l-97.3%
fma-neg97.6%
sub-neg97.6%
metadata-eval97.6%
distribute-lft-neg-in97.6%
distribute-lft-neg-in97.6%
remove-double-neg97.6%
sub-neg97.6%
metadata-eval97.6%
Simplified97.6%
Final simplification97.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -3.3e+68)
t_1
(if (<= t -3600.0)
(+ z x)
(if (<= t -2.2e-138)
(* a (- 1.0 t))
(if (<= t 2.05e-137)
(+ z x)
(if (<= t 1.6e-92)
(* y (- z))
(if (<= t 1.3e-48)
(+ z x)
(if (<= t 9e-29)
(* y b)
(if (<= t 3.3e-24)
a
(if (<= t 1.02e+33) (+ z x) t_1)))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -3.3e+68) {
tmp = t_1;
} else if (t <= -3600.0) {
tmp = z + x;
} else if (t <= -2.2e-138) {
tmp = a * (1.0 - t);
} else if (t <= 2.05e-137) {
tmp = z + x;
} else if (t <= 1.6e-92) {
tmp = y * -z;
} else if (t <= 1.3e-48) {
tmp = z + x;
} else if (t <= 9e-29) {
tmp = y * b;
} else if (t <= 3.3e-24) {
tmp = a;
} else if (t <= 1.02e+33) {
tmp = z + x;
} 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 <= (-3.3d+68)) then
tmp = t_1
else if (t <= (-3600.0d0)) then
tmp = z + x
else if (t <= (-2.2d-138)) then
tmp = a * (1.0d0 - t)
else if (t <= 2.05d-137) then
tmp = z + x
else if (t <= 1.6d-92) then
tmp = y * -z
else if (t <= 1.3d-48) then
tmp = z + x
else if (t <= 9d-29) then
tmp = y * b
else if (t <= 3.3d-24) then
tmp = a
else if (t <= 1.02d+33) then
tmp = z + x
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 <= -3.3e+68) {
tmp = t_1;
} else if (t <= -3600.0) {
tmp = z + x;
} else if (t <= -2.2e-138) {
tmp = a * (1.0 - t);
} else if (t <= 2.05e-137) {
tmp = z + x;
} else if (t <= 1.6e-92) {
tmp = y * -z;
} else if (t <= 1.3e-48) {
tmp = z + x;
} else if (t <= 9e-29) {
tmp = y * b;
} else if (t <= 3.3e-24) {
tmp = a;
} else if (t <= 1.02e+33) {
tmp = z + x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -3.3e+68: tmp = t_1 elif t <= -3600.0: tmp = z + x elif t <= -2.2e-138: tmp = a * (1.0 - t) elif t <= 2.05e-137: tmp = z + x elif t <= 1.6e-92: tmp = y * -z elif t <= 1.3e-48: tmp = z + x elif t <= 9e-29: tmp = y * b elif t <= 3.3e-24: tmp = a elif t <= 1.02e+33: tmp = z + x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -3.3e+68) tmp = t_1; elseif (t <= -3600.0) tmp = Float64(z + x); elseif (t <= -2.2e-138) tmp = Float64(a * Float64(1.0 - t)); elseif (t <= 2.05e-137) tmp = Float64(z + x); elseif (t <= 1.6e-92) tmp = Float64(y * Float64(-z)); elseif (t <= 1.3e-48) tmp = Float64(z + x); elseif (t <= 9e-29) tmp = Float64(y * b); elseif (t <= 3.3e-24) tmp = a; elseif (t <= 1.02e+33) tmp = Float64(z + x); 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 <= -3.3e+68) tmp = t_1; elseif (t <= -3600.0) tmp = z + x; elseif (t <= -2.2e-138) tmp = a * (1.0 - t); elseif (t <= 2.05e-137) tmp = z + x; elseif (t <= 1.6e-92) tmp = y * -z; elseif (t <= 1.3e-48) tmp = z + x; elseif (t <= 9e-29) tmp = y * b; elseif (t <= 3.3e-24) tmp = a; elseif (t <= 1.02e+33) tmp = z + x; 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, -3.3e+68], t$95$1, If[LessEqual[t, -3600.0], N[(z + x), $MachinePrecision], If[LessEqual[t, -2.2e-138], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.05e-137], N[(z + x), $MachinePrecision], If[LessEqual[t, 1.6e-92], N[(y * (-z)), $MachinePrecision], If[LessEqual[t, 1.3e-48], N[(z + x), $MachinePrecision], If[LessEqual[t, 9e-29], N[(y * b), $MachinePrecision], If[LessEqual[t, 3.3e-24], a, If[LessEqual[t, 1.02e+33], N[(z + x), $MachinePrecision], t$95$1]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -3.3 \cdot 10^{+68}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3600:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq -2.2 \cdot 10^{-138}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;t \leq 2.05 \cdot 10^{-137}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 1.6 \cdot 10^{-92}:\\
\;\;\;\;y \cdot \left(-z\right)\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{-48}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 9 \cdot 10^{-29}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 3.3 \cdot 10^{-24}:\\
\;\;\;\;a\\
\mathbf{elif}\;t \leq 1.02 \cdot 10^{+33}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -3.3e68 or 1.02000000000000001e33 < 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 64.8%
if -3.3e68 < t < -3600 or -2.1999999999999999e-138 < t < 2.0499999999999999e-137 or 1.5999999999999998e-92 < t < 1.29999999999999994e-48 or 3.29999999999999984e-24 < t < 1.02000000000000001e33Initial 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 y around inf 72.6%
mul-1-neg72.6%
distribute-rgt-neg-in72.6%
Simplified72.6%
Taylor expanded in y around 0 47.7%
sub-neg47.7%
neg-mul-147.7%
remove-double-neg47.7%
+-commutative47.7%
Simplified47.7%
if -3600 < t < -2.1999999999999999e-138Initial 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 38.8%
if 2.0499999999999999e-137 < t < 1.5999999999999998e-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 t around inf 71.7%
Taylor expanded in y around inf 71.7%
mul-1-neg71.7%
*-commutative71.7%
distribute-rgt-neg-in71.7%
Simplified71.7%
if 1.29999999999999994e-48 < t < 8.9999999999999996e-29Initial 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 y around inf 67.9%
Taylor expanded in b around inf 45.8%
if 8.9999999999999996e-29 < t < 3.29999999999999984e-24Initial 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 50.5%
Taylor expanded in t around 0 50.5%
Final simplification54.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ a x) (* b (- y 2.0))))
(t_2 (+ (+ a x) (* z (- 1.0 y))))
(t_3 (+ (- x (* z (+ y -1.0))) (* t (- b a)))))
(if (<= t -0.0275)
t_3
(if (<= t -1.45e-129)
t_2
(if (<= t 8.4e-282)
t_1
(if (<= t 7.5e-39) t_2 (if (<= t 1.82e-25) t_1 t_3)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a + x) + (b * (y - 2.0));
double t_2 = (a + x) + (z * (1.0 - y));
double t_3 = (x - (z * (y + -1.0))) + (t * (b - a));
double tmp;
if (t <= -0.0275) {
tmp = t_3;
} else if (t <= -1.45e-129) {
tmp = t_2;
} else if (t <= 8.4e-282) {
tmp = t_1;
} else if (t <= 7.5e-39) {
tmp = t_2;
} else if (t <= 1.82e-25) {
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 = (a + x) + (b * (y - 2.0d0))
t_2 = (a + x) + (z * (1.0d0 - y))
t_3 = (x - (z * (y + (-1.0d0)))) + (t * (b - a))
if (t <= (-0.0275d0)) then
tmp = t_3
else if (t <= (-1.45d-129)) then
tmp = t_2
else if (t <= 8.4d-282) then
tmp = t_1
else if (t <= 7.5d-39) then
tmp = t_2
else if (t <= 1.82d-25) 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 = (a + x) + (b * (y - 2.0));
double t_2 = (a + x) + (z * (1.0 - y));
double t_3 = (x - (z * (y + -1.0))) + (t * (b - a));
double tmp;
if (t <= -0.0275) {
tmp = t_3;
} else if (t <= -1.45e-129) {
tmp = t_2;
} else if (t <= 8.4e-282) {
tmp = t_1;
} else if (t <= 7.5e-39) {
tmp = t_2;
} else if (t <= 1.82e-25) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (a + x) + (b * (y - 2.0)) t_2 = (a + x) + (z * (1.0 - y)) t_3 = (x - (z * (y + -1.0))) + (t * (b - a)) tmp = 0 if t <= -0.0275: tmp = t_3 elif t <= -1.45e-129: tmp = t_2 elif t <= 8.4e-282: tmp = t_1 elif t <= 7.5e-39: tmp = t_2 elif t <= 1.82e-25: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(a + x) + Float64(b * Float64(y - 2.0))) t_2 = Float64(Float64(a + x) + Float64(z * Float64(1.0 - y))) t_3 = Float64(Float64(x - Float64(z * Float64(y + -1.0))) + Float64(t * Float64(b - a))) tmp = 0.0 if (t <= -0.0275) tmp = t_3; elseif (t <= -1.45e-129) tmp = t_2; elseif (t <= 8.4e-282) tmp = t_1; elseif (t <= 7.5e-39) tmp = t_2; elseif (t <= 1.82e-25) tmp = t_1; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (a + x) + (b * (y - 2.0)); t_2 = (a + x) + (z * (1.0 - y)); t_3 = (x - (z * (y + -1.0))) + (t * (b - a)); tmp = 0.0; if (t <= -0.0275) tmp = t_3; elseif (t <= -1.45e-129) tmp = t_2; elseif (t <= 8.4e-282) tmp = t_1; elseif (t <= 7.5e-39) tmp = t_2; elseif (t <= 1.82e-25) tmp = t_1; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(a + x), $MachinePrecision] + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(a + x), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -0.0275], t$95$3, If[LessEqual[t, -1.45e-129], t$95$2, If[LessEqual[t, 8.4e-282], t$95$1, If[LessEqual[t, 7.5e-39], t$95$2, If[LessEqual[t, 1.82e-25], t$95$1, t$95$3]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a + x\right) + b \cdot \left(y - 2\right)\\
t_2 := \left(a + x\right) + z \cdot \left(1 - y\right)\\
t_3 := \left(x - z \cdot \left(y + -1\right)\right) + t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -0.0275:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq -1.45 \cdot 10^{-129}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 8.4 \cdot 10^{-282}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 7.5 \cdot 10^{-39}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.82 \cdot 10^{-25}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if t < -0.0275000000000000001 or 1.8199999999999999e-25 < t 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 t around inf 89.9%
if -0.0275000000000000001 < t < -1.45000000000000008e-129 or 8.40000000000000046e-282 < t < 7.49999999999999971e-39Initial 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 t around 0 96.9%
sub-neg96.9%
+-commutative96.9%
mul-1-neg96.9%
unsub-neg96.9%
*-commutative96.9%
distribute-rgt-neg-in96.9%
sub-neg96.9%
metadata-eval96.9%
+-commutative96.9%
distribute-neg-in96.9%
metadata-eval96.9%
sub-neg96.9%
Simplified96.9%
Taylor expanded in b around 0 85.9%
if -1.45000000000000008e-129 < t < 8.40000000000000046e-282 or 7.49999999999999971e-39 < t < 1.8199999999999999e-25Initial 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 t around 0 98.1%
sub-neg98.1%
+-commutative98.1%
mul-1-neg98.1%
unsub-neg98.1%
*-commutative98.1%
distribute-rgt-neg-in98.1%
sub-neg98.1%
metadata-eval98.1%
+-commutative98.1%
distribute-neg-in98.1%
metadata-eval98.1%
sub-neg98.1%
Simplified98.1%
Taylor expanded in z around 0 85.7%
Final simplification87.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -1.7e+68)
t_1
(if (<= t -5200.0)
(+ z x)
(if (<= t -4.1e-125)
(* a (- 1.0 t))
(if (<= t -2.8e-273)
(* b (- y 2.0))
(if (<= t -9e-307)
(+ z x)
(if (<= t 3.4e-208)
(+ x (* y b))
(if (<= t 1.18e-23)
(* y (- b z))
(if (<= t 9e+31) (+ z x) t_1))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1.7e+68) {
tmp = t_1;
} else if (t <= -5200.0) {
tmp = z + x;
} else if (t <= -4.1e-125) {
tmp = a * (1.0 - t);
} else if (t <= -2.8e-273) {
tmp = b * (y - 2.0);
} else if (t <= -9e-307) {
tmp = z + x;
} else if (t <= 3.4e-208) {
tmp = x + (y * b);
} else if (t <= 1.18e-23) {
tmp = y * (b - z);
} else if (t <= 9e+31) {
tmp = z + x;
} 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 <= (-1.7d+68)) then
tmp = t_1
else if (t <= (-5200.0d0)) then
tmp = z + x
else if (t <= (-4.1d-125)) then
tmp = a * (1.0d0 - t)
else if (t <= (-2.8d-273)) then
tmp = b * (y - 2.0d0)
else if (t <= (-9d-307)) then
tmp = z + x
else if (t <= 3.4d-208) then
tmp = x + (y * b)
else if (t <= 1.18d-23) then
tmp = y * (b - z)
else if (t <= 9d+31) then
tmp = z + x
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 <= -1.7e+68) {
tmp = t_1;
} else if (t <= -5200.0) {
tmp = z + x;
} else if (t <= -4.1e-125) {
tmp = a * (1.0 - t);
} else if (t <= -2.8e-273) {
tmp = b * (y - 2.0);
} else if (t <= -9e-307) {
tmp = z + x;
} else if (t <= 3.4e-208) {
tmp = x + (y * b);
} else if (t <= 1.18e-23) {
tmp = y * (b - z);
} else if (t <= 9e+31) {
tmp = z + x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -1.7e+68: tmp = t_1 elif t <= -5200.0: tmp = z + x elif t <= -4.1e-125: tmp = a * (1.0 - t) elif t <= -2.8e-273: tmp = b * (y - 2.0) elif t <= -9e-307: tmp = z + x elif t <= 3.4e-208: tmp = x + (y * b) elif t <= 1.18e-23: tmp = y * (b - z) elif t <= 9e+31: tmp = z + x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.7e+68) tmp = t_1; elseif (t <= -5200.0) tmp = Float64(z + x); elseif (t <= -4.1e-125) tmp = Float64(a * Float64(1.0 - t)); elseif (t <= -2.8e-273) tmp = Float64(b * Float64(y - 2.0)); elseif (t <= -9e-307) tmp = Float64(z + x); elseif (t <= 3.4e-208) tmp = Float64(x + Float64(y * b)); elseif (t <= 1.18e-23) tmp = Float64(y * Float64(b - z)); elseif (t <= 9e+31) tmp = Float64(z + x); 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 <= -1.7e+68) tmp = t_1; elseif (t <= -5200.0) tmp = z + x; elseif (t <= -4.1e-125) tmp = a * (1.0 - t); elseif (t <= -2.8e-273) tmp = b * (y - 2.0); elseif (t <= -9e-307) tmp = z + x; elseif (t <= 3.4e-208) tmp = x + (y * b); elseif (t <= 1.18e-23) tmp = y * (b - z); elseif (t <= 9e+31) tmp = z + x; 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, -1.7e+68], t$95$1, If[LessEqual[t, -5200.0], N[(z + x), $MachinePrecision], If[LessEqual[t, -4.1e-125], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.8e-273], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -9e-307], N[(z + x), $MachinePrecision], If[LessEqual[t, 3.4e-208], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.18e-23], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9e+31], N[(z + x), $MachinePrecision], t$95$1]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.7 \cdot 10^{+68}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -5200:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq -4.1 \cdot 10^{-125}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;t \leq -2.8 \cdot 10^{-273}:\\
\;\;\;\;b \cdot \left(y - 2\right)\\
\mathbf{elif}\;t \leq -9 \cdot 10^{-307}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 3.4 \cdot 10^{-208}:\\
\;\;\;\;x + y \cdot b\\
\mathbf{elif}\;t \leq 1.18 \cdot 10^{-23}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq 9 \cdot 10^{+31}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.70000000000000008e68 or 8.9999999999999992e31 < 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 64.8%
if -1.70000000000000008e68 < t < -5200 or -2.79999999999999985e-273 < t < -8.99999999999999978e-307 or 1.18e-23 < t < 8.9999999999999992e31Initial 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 y around inf 79.7%
mul-1-neg79.7%
distribute-rgt-neg-in79.7%
Simplified79.7%
Taylor expanded in y around 0 61.3%
sub-neg61.3%
neg-mul-161.3%
remove-double-neg61.3%
+-commutative61.3%
Simplified61.3%
if -5200 < t < -4.0999999999999997e-125Initial 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 42.8%
if -4.0999999999999997e-125 < t < -2.79999999999999985e-273Initial 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 0 100.0%
sub-neg100.0%
+-commutative100.0%
mul-1-neg100.0%
unsub-neg100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
metadata-eval100.0%
+-commutative100.0%
distribute-neg-in100.0%
metadata-eval100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in b around inf 55.7%
if -8.99999999999999978e-307 < t < 3.4e-208Initial program 93.3%
associate-+l-93.3%
*-commutative93.3%
*-commutative93.3%
sub-neg93.3%
metadata-eval93.3%
remove-double-neg93.3%
remove-double-neg93.3%
sub-neg93.3%
metadata-eval93.3%
associate--l+93.3%
Simplified93.3%
Taylor expanded in y around inf 74.4%
mul-1-neg74.4%
distribute-rgt-neg-in74.4%
Simplified74.4%
Taylor expanded in z around 0 61.5%
Taylor expanded in x around 0 61.5%
if 3.4e-208 < t < 1.18e-23Initial program 94.7%
associate-+l-94.7%
*-commutative94.7%
*-commutative94.7%
sub-neg94.7%
metadata-eval94.7%
remove-double-neg94.7%
remove-double-neg94.7%
sub-neg94.7%
metadata-eval94.7%
associate--l+94.7%
Simplified94.7%
Taylor expanded in y around inf 51.2%
Final simplification58.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* t (- b a))))
(t_2 (- x (* z (+ y -1.0))))
(t_3 (* b (- (+ y t) 2.0))))
(if (<= b -5e+110)
t_3
(if (<= b -0.015)
t_1
(if (<= b -3.5e-14)
(* y (- b z))
(if (<= b -2.15e-163)
(+ x (- z (* t a)))
(if (<= b 1.15e-39)
t_2
(if (<= b 1.3e+53) t_1 (if (<= b 2.65e+129) t_2 t_3)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = x - (z * (y + -1.0));
double t_3 = b * ((y + t) - 2.0);
double tmp;
if (b <= -5e+110) {
tmp = t_3;
} else if (b <= -0.015) {
tmp = t_1;
} else if (b <= -3.5e-14) {
tmp = y * (b - z);
} else if (b <= -2.15e-163) {
tmp = x + (z - (t * a));
} else if (b <= 1.15e-39) {
tmp = t_2;
} else if (b <= 1.3e+53) {
tmp = t_1;
} else if (b <= 2.65e+129) {
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 + (t * (b - a))
t_2 = x - (z * (y + (-1.0d0)))
t_3 = b * ((y + t) - 2.0d0)
if (b <= (-5d+110)) then
tmp = t_3
else if (b <= (-0.015d0)) then
tmp = t_1
else if (b <= (-3.5d-14)) then
tmp = y * (b - z)
else if (b <= (-2.15d-163)) then
tmp = x + (z - (t * a))
else if (b <= 1.15d-39) then
tmp = t_2
else if (b <= 1.3d+53) then
tmp = t_1
else if (b <= 2.65d+129) 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 + (t * (b - a));
double t_2 = x - (z * (y + -1.0));
double t_3 = b * ((y + t) - 2.0);
double tmp;
if (b <= -5e+110) {
tmp = t_3;
} else if (b <= -0.015) {
tmp = t_1;
} else if (b <= -3.5e-14) {
tmp = y * (b - z);
} else if (b <= -2.15e-163) {
tmp = x + (z - (t * a));
} else if (b <= 1.15e-39) {
tmp = t_2;
} else if (b <= 1.3e+53) {
tmp = t_1;
} else if (b <= 2.65e+129) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (t * (b - a)) t_2 = x - (z * (y + -1.0)) t_3 = b * ((y + t) - 2.0) tmp = 0 if b <= -5e+110: tmp = t_3 elif b <= -0.015: tmp = t_1 elif b <= -3.5e-14: tmp = y * (b - z) elif b <= -2.15e-163: tmp = x + (z - (t * a)) elif b <= 1.15e-39: tmp = t_2 elif b <= 1.3e+53: tmp = t_1 elif b <= 2.65e+129: tmp = t_2 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(t * Float64(b - a))) t_2 = Float64(x - Float64(z * Float64(y + -1.0))) t_3 = Float64(b * Float64(Float64(y + t) - 2.0)) tmp = 0.0 if (b <= -5e+110) tmp = t_3; elseif (b <= -0.015) tmp = t_1; elseif (b <= -3.5e-14) tmp = Float64(y * Float64(b - z)); elseif (b <= -2.15e-163) tmp = Float64(x + Float64(z - Float64(t * a))); elseif (b <= 1.15e-39) tmp = t_2; elseif (b <= 1.3e+53) tmp = t_1; elseif (b <= 2.65e+129) tmp = t_2; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (t * (b - a)); t_2 = x - (z * (y + -1.0)); t_3 = b * ((y + t) - 2.0); tmp = 0.0; if (b <= -5e+110) tmp = t_3; elseif (b <= -0.015) tmp = t_1; elseif (b <= -3.5e-14) tmp = y * (b - z); elseif (b <= -2.15e-163) tmp = x + (z - (t * a)); elseif (b <= 1.15e-39) tmp = t_2; elseif (b <= 1.3e+53) tmp = t_1; elseif (b <= 2.65e+129) 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[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5e+110], t$95$3, If[LessEqual[b, -0.015], t$95$1, If[LessEqual[b, -3.5e-14], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -2.15e-163], N[(x + N[(z - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.15e-39], t$95$2, If[LessEqual[b, 1.3e+53], t$95$1, If[LessEqual[b, 2.65e+129], t$95$2, t$95$3]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \left(b - a\right)\\
t_2 := x - z \cdot \left(y + -1\right)\\
t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\
\mathbf{if}\;b \leq -5 \cdot 10^{+110}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq -0.015:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -3.5 \cdot 10^{-14}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;b \leq -2.15 \cdot 10^{-163}:\\
\;\;\;\;x + \left(z - t \cdot a\right)\\
\mathbf{elif}\;b \leq 1.15 \cdot 10^{-39}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq 1.3 \cdot 10^{+53}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 2.65 \cdot 10^{+129}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if b < -4.99999999999999978e110 or 2.6499999999999999e129 < b Initial program 90.8%
associate-+l-90.8%
*-commutative90.8%
*-commutative90.8%
sub-neg90.8%
metadata-eval90.8%
remove-double-neg90.8%
remove-double-neg90.8%
sub-neg90.8%
metadata-eval90.8%
associate--l+90.8%
Simplified90.8%
Taylor expanded in b around inf 81.8%
if -4.99999999999999978e110 < b < -0.014999999999999999 or 1.15000000000000004e-39 < b < 1.29999999999999999e53Initial program 93.1%
associate-+l-93.1%
*-commutative93.1%
*-commutative93.1%
sub-neg93.1%
metadata-eval93.1%
remove-double-neg93.1%
remove-double-neg93.1%
sub-neg93.1%
metadata-eval93.1%
associate--l+93.1%
Simplified93.1%
Taylor expanded in t around inf 80.8%
Taylor expanded in z around 0 60.8%
if -0.014999999999999999 < b < -3.5000000000000002e-14Initial program 99.7%
associate-+l-99.7%
*-commutative99.7%
*-commutative99.7%
sub-neg99.7%
metadata-eval99.7%
remove-double-neg99.7%
remove-double-neg99.7%
sub-neg99.7%
metadata-eval99.7%
associate--l+99.7%
Simplified99.7%
Taylor expanded in y around inf 95.9%
if -3.5000000000000002e-14 < b < -2.15000000000000004e-163Initial 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 76.1%
Taylor expanded in a around inf 76.1%
*-commutative76.1%
Simplified76.1%
Taylor expanded in y around 0 65.4%
+-commutative65.4%
mul-1-neg65.4%
unsub-neg65.4%
Simplified65.4%
if -2.15000000000000004e-163 < b < 1.15000000000000004e-39 or 1.29999999999999999e53 < b < 2.6499999999999999e129Initial program 96.8%
associate-+l-96.8%
*-commutative96.8%
*-commutative96.8%
sub-neg96.8%
metadata-eval96.8%
remove-double-neg96.8%
remove-double-neg96.8%
sub-neg96.8%
metadata-eval96.8%
associate--l+96.8%
Simplified96.8%
Taylor expanded in t around inf 81.9%
Taylor expanded in t around 0 67.5%
Final simplification70.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ a x) (* z (- 1.0 y))))
(t_2 (+ x (* t (- b a))))
(t_3 (+ (+ a x) (* b (- y 2.0)))))
(if (<= t -1.8e+68)
t_2
(if (<= t -2.8e-129)
t_1
(if (<= t 1.9e-283)
t_3
(if (<= t 1.75e-38)
t_1
(if (<= t 1.15e-28) t_3 (if (<= t 2.5e+80) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a + x) + (z * (1.0 - y));
double t_2 = x + (t * (b - a));
double t_3 = (a + x) + (b * (y - 2.0));
double tmp;
if (t <= -1.8e+68) {
tmp = t_2;
} else if (t <= -2.8e-129) {
tmp = t_1;
} else if (t <= 1.9e-283) {
tmp = t_3;
} else if (t <= 1.75e-38) {
tmp = t_1;
} else if (t <= 1.15e-28) {
tmp = t_3;
} else if (t <= 2.5e+80) {
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 = (a + x) + (z * (1.0d0 - y))
t_2 = x + (t * (b - a))
t_3 = (a + x) + (b * (y - 2.0d0))
if (t <= (-1.8d+68)) then
tmp = t_2
else if (t <= (-2.8d-129)) then
tmp = t_1
else if (t <= 1.9d-283) then
tmp = t_3
else if (t <= 1.75d-38) then
tmp = t_1
else if (t <= 1.15d-28) then
tmp = t_3
else if (t <= 2.5d+80) 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) + (z * (1.0 - y));
double t_2 = x + (t * (b - a));
double t_3 = (a + x) + (b * (y - 2.0));
double tmp;
if (t <= -1.8e+68) {
tmp = t_2;
} else if (t <= -2.8e-129) {
tmp = t_1;
} else if (t <= 1.9e-283) {
tmp = t_3;
} else if (t <= 1.75e-38) {
tmp = t_1;
} else if (t <= 1.15e-28) {
tmp = t_3;
} else if (t <= 2.5e+80) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (a + x) + (z * (1.0 - y)) t_2 = x + (t * (b - a)) t_3 = (a + x) + (b * (y - 2.0)) tmp = 0 if t <= -1.8e+68: tmp = t_2 elif t <= -2.8e-129: tmp = t_1 elif t <= 1.9e-283: tmp = t_3 elif t <= 1.75e-38: tmp = t_1 elif t <= 1.15e-28: tmp = t_3 elif t <= 2.5e+80: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(a + x) + Float64(z * Float64(1.0 - y))) t_2 = Float64(x + Float64(t * Float64(b - a))) t_3 = Float64(Float64(a + x) + Float64(b * Float64(y - 2.0))) tmp = 0.0 if (t <= -1.8e+68) tmp = t_2; elseif (t <= -2.8e-129) tmp = t_1; elseif (t <= 1.9e-283) tmp = t_3; elseif (t <= 1.75e-38) tmp = t_1; elseif (t <= 1.15e-28) tmp = t_3; elseif (t <= 2.5e+80) 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) + (z * (1.0 - y)); t_2 = x + (t * (b - a)); t_3 = (a + x) + (b * (y - 2.0)); tmp = 0.0; if (t <= -1.8e+68) tmp = t_2; elseif (t <= -2.8e-129) tmp = t_1; elseif (t <= 1.9e-283) tmp = t_3; elseif (t <= 1.75e-38) tmp = t_1; elseif (t <= 1.15e-28) tmp = t_3; elseif (t <= 2.5e+80) 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[(a + x), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(a + x), $MachinePrecision] + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.8e+68], t$95$2, If[LessEqual[t, -2.8e-129], t$95$1, If[LessEqual[t, 1.9e-283], t$95$3, If[LessEqual[t, 1.75e-38], t$95$1, If[LessEqual[t, 1.15e-28], t$95$3, If[LessEqual[t, 2.5e+80], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a + x\right) + z \cdot \left(1 - y\right)\\
t_2 := x + t \cdot \left(b - a\right)\\
t_3 := \left(a + x\right) + b \cdot \left(y - 2\right)\\
\mathbf{if}\;t \leq -1.8 \cdot 10^{+68}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -2.8 \cdot 10^{-129}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{-283}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{-38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-28}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 2.5 \cdot 10^{+80}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.7999999999999999e68 or 2.4999999999999998e80 < t 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 t around inf 90.7%
Taylor expanded in z around 0 76.7%
if -1.7999999999999999e68 < t < -2.7999999999999999e-129 or 1.9000000000000001e-283 < t < 1.7500000000000001e-38 or 1.14999999999999993e-28 < t < 2.4999999999999998e80Initial 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 t around 0 88.8%
sub-neg88.8%
+-commutative88.8%
mul-1-neg88.8%
unsub-neg88.8%
*-commutative88.8%
distribute-rgt-neg-in88.8%
sub-neg88.8%
metadata-eval88.8%
+-commutative88.8%
distribute-neg-in88.8%
metadata-eval88.8%
sub-neg88.8%
Simplified88.8%
Taylor expanded in b around 0 80.7%
if -2.7999999999999999e-129 < t < 1.9000000000000001e-283 or 1.7500000000000001e-38 < t < 1.14999999999999993e-28Initial 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 t around 0 98.0%
sub-neg98.0%
+-commutative98.0%
mul-1-neg98.0%
unsub-neg98.0%
*-commutative98.0%
distribute-rgt-neg-in98.0%
sub-neg98.0%
metadata-eval98.0%
+-commutative98.0%
distribute-neg-in98.0%
metadata-eval98.0%
sub-neg98.0%
Simplified98.0%
Taylor expanded in z around 0 85.5%
Final simplification80.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ a x) (* z (- 1.0 y))))
(t_2 (+ (+ z x) (* t (- b a))))
(t_3 (+ (+ a x) (* b (- y 2.0)))))
(if (<= t -7.8e+67)
t_2
(if (<= t -1.75e-129)
t_1
(if (<= t 4.4e-283)
t_3
(if (<= t 2.1e-38)
t_1
(if (<= t 6e-28) t_3 (if (<= t 80.0) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a + x) + (z * (1.0 - y));
double t_2 = (z + x) + (t * (b - a));
double t_3 = (a + x) + (b * (y - 2.0));
double tmp;
if (t <= -7.8e+67) {
tmp = t_2;
} else if (t <= -1.75e-129) {
tmp = t_1;
} else if (t <= 4.4e-283) {
tmp = t_3;
} else if (t <= 2.1e-38) {
tmp = t_1;
} else if (t <= 6e-28) {
tmp = t_3;
} else if (t <= 80.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 = (a + x) + (z * (1.0d0 - y))
t_2 = (z + x) + (t * (b - a))
t_3 = (a + x) + (b * (y - 2.0d0))
if (t <= (-7.8d+67)) then
tmp = t_2
else if (t <= (-1.75d-129)) then
tmp = t_1
else if (t <= 4.4d-283) then
tmp = t_3
else if (t <= 2.1d-38) then
tmp = t_1
else if (t <= 6d-28) then
tmp = t_3
else if (t <= 80.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) + (z * (1.0 - y));
double t_2 = (z + x) + (t * (b - a));
double t_3 = (a + x) + (b * (y - 2.0));
double tmp;
if (t <= -7.8e+67) {
tmp = t_2;
} else if (t <= -1.75e-129) {
tmp = t_1;
} else if (t <= 4.4e-283) {
tmp = t_3;
} else if (t <= 2.1e-38) {
tmp = t_1;
} else if (t <= 6e-28) {
tmp = t_3;
} else if (t <= 80.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (a + x) + (z * (1.0 - y)) t_2 = (z + x) + (t * (b - a)) t_3 = (a + x) + (b * (y - 2.0)) tmp = 0 if t <= -7.8e+67: tmp = t_2 elif t <= -1.75e-129: tmp = t_1 elif t <= 4.4e-283: tmp = t_3 elif t <= 2.1e-38: tmp = t_1 elif t <= 6e-28: tmp = t_3 elif t <= 80.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(a + x) + Float64(z * Float64(1.0 - y))) t_2 = Float64(Float64(z + x) + Float64(t * Float64(b - a))) t_3 = Float64(Float64(a + x) + Float64(b * Float64(y - 2.0))) tmp = 0.0 if (t <= -7.8e+67) tmp = t_2; elseif (t <= -1.75e-129) tmp = t_1; elseif (t <= 4.4e-283) tmp = t_3; elseif (t <= 2.1e-38) tmp = t_1; elseif (t <= 6e-28) tmp = t_3; elseif (t <= 80.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) + (z * (1.0 - y)); t_2 = (z + x) + (t * (b - a)); t_3 = (a + x) + (b * (y - 2.0)); tmp = 0.0; if (t <= -7.8e+67) tmp = t_2; elseif (t <= -1.75e-129) tmp = t_1; elseif (t <= 4.4e-283) tmp = t_3; elseif (t <= 2.1e-38) tmp = t_1; elseif (t <= 6e-28) tmp = t_3; elseif (t <= 80.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[(N[(a + x), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + x), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(a + x), $MachinePrecision] + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.8e+67], t$95$2, If[LessEqual[t, -1.75e-129], t$95$1, If[LessEqual[t, 4.4e-283], t$95$3, If[LessEqual[t, 2.1e-38], t$95$1, If[LessEqual[t, 6e-28], t$95$3, If[LessEqual[t, 80.0], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a + x\right) + z \cdot \left(1 - y\right)\\
t_2 := \left(z + x\right) + t \cdot \left(b - a\right)\\
t_3 := \left(a + x\right) + b \cdot \left(y - 2\right)\\
\mathbf{if}\;t \leq -7.8 \cdot 10^{+67}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.75 \cdot 10^{-129}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{-283}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{-38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-28}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq 80:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -7.80000000000000013e67 or 80 < t Initial program 92.0%
associate-+l-92.0%
*-commutative92.0%
*-commutative92.0%
sub-neg92.0%
metadata-eval92.0%
remove-double-neg92.0%
remove-double-neg92.0%
sub-neg92.0%
metadata-eval92.0%
associate--l+92.0%
Simplified92.0%
Taylor expanded in t around inf 91.2%
Taylor expanded in y around 0 76.6%
+-commutative76.6%
associate--r+76.6%
sub-neg76.6%
neg-mul-176.6%
remove-double-neg76.6%
+-commutative76.6%
Simplified76.6%
if -7.80000000000000013e67 < t < -1.7499999999999999e-129 or 4.3999999999999996e-283 < t < 2.10000000000000013e-38 or 6.00000000000000005e-28 < t < 80Initial 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 t around 0 92.8%
sub-neg92.8%
+-commutative92.8%
mul-1-neg92.8%
unsub-neg92.8%
*-commutative92.8%
distribute-rgt-neg-in92.8%
sub-neg92.8%
metadata-eval92.8%
+-commutative92.8%
distribute-neg-in92.8%
metadata-eval92.8%
sub-neg92.8%
Simplified92.8%
Taylor expanded in b around 0 84.3%
if -1.7499999999999999e-129 < t < 4.3999999999999996e-283 or 2.10000000000000013e-38 < t < 6.00000000000000005e-28Initial 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 t around 0 98.0%
sub-neg98.0%
+-commutative98.0%
mul-1-neg98.0%
unsub-neg98.0%
*-commutative98.0%
distribute-rgt-neg-in98.0%
sub-neg98.0%
metadata-eval98.0%
+-commutative98.0%
distribute-neg-in98.0%
metadata-eval98.0%
sub-neg98.0%
Simplified98.0%
Taylor expanded in z around 0 85.5%
Final simplification81.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t))))
(if (<= a -1.7e+135)
t_1
(if (<= a -9.2e+39)
(* y (- z))
(if (<= a -1.5e+28)
(* y b)
(if (<= a -1.36e-27)
(* t b)
(if (<= a 8.8e-20)
(+ z x)
(if (<= a 1.5e+53) (* t b) (if (<= a 7.5e+91) (+ z x) 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 <= -1.7e+135) {
tmp = t_1;
} else if (a <= -9.2e+39) {
tmp = y * -z;
} else if (a <= -1.5e+28) {
tmp = y * b;
} else if (a <= -1.36e-27) {
tmp = t * b;
} else if (a <= 8.8e-20) {
tmp = z + x;
} else if (a <= 1.5e+53) {
tmp = t * b;
} else if (a <= 7.5e+91) {
tmp = z + x;
} 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 <= (-1.7d+135)) then
tmp = t_1
else if (a <= (-9.2d+39)) then
tmp = y * -z
else if (a <= (-1.5d+28)) then
tmp = y * b
else if (a <= (-1.36d-27)) then
tmp = t * b
else if (a <= 8.8d-20) then
tmp = z + x
else if (a <= 1.5d+53) then
tmp = t * b
else if (a <= 7.5d+91) then
tmp = z + x
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 <= -1.7e+135) {
tmp = t_1;
} else if (a <= -9.2e+39) {
tmp = y * -z;
} else if (a <= -1.5e+28) {
tmp = y * b;
} else if (a <= -1.36e-27) {
tmp = t * b;
} else if (a <= 8.8e-20) {
tmp = z + x;
} else if (a <= 1.5e+53) {
tmp = t * b;
} else if (a <= 7.5e+91) {
tmp = z + x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) tmp = 0 if a <= -1.7e+135: tmp = t_1 elif a <= -9.2e+39: tmp = y * -z elif a <= -1.5e+28: tmp = y * b elif a <= -1.36e-27: tmp = t * b elif a <= 8.8e-20: tmp = z + x elif a <= 1.5e+53: tmp = t * b elif a <= 7.5e+91: tmp = z + x 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 <= -1.7e+135) tmp = t_1; elseif (a <= -9.2e+39) tmp = Float64(y * Float64(-z)); elseif (a <= -1.5e+28) tmp = Float64(y * b); elseif (a <= -1.36e-27) tmp = Float64(t * b); elseif (a <= 8.8e-20) tmp = Float64(z + x); elseif (a <= 1.5e+53) tmp = Float64(t * b); elseif (a <= 7.5e+91) tmp = Float64(z + x); 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 <= -1.7e+135) tmp = t_1; elseif (a <= -9.2e+39) tmp = y * -z; elseif (a <= -1.5e+28) tmp = y * b; elseif (a <= -1.36e-27) tmp = t * b; elseif (a <= 8.8e-20) tmp = z + x; elseif (a <= 1.5e+53) tmp = t * b; elseif (a <= 7.5e+91) tmp = z + x; 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, -1.7e+135], t$95$1, If[LessEqual[a, -9.2e+39], N[(y * (-z)), $MachinePrecision], If[LessEqual[a, -1.5e+28], N[(y * b), $MachinePrecision], If[LessEqual[a, -1.36e-27], N[(t * b), $MachinePrecision], If[LessEqual[a, 8.8e-20], N[(z + x), $MachinePrecision], If[LessEqual[a, 1.5e+53], N[(t * b), $MachinePrecision], If[LessEqual[a, 7.5e+91], N[(z + x), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;a \leq -1.7 \cdot 10^{+135}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -9.2 \cdot 10^{+39}:\\
\;\;\;\;y \cdot \left(-z\right)\\
\mathbf{elif}\;a \leq -1.5 \cdot 10^{+28}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;a \leq -1.36 \cdot 10^{-27}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;a \leq 8.8 \cdot 10^{-20}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;a \leq 1.5 \cdot 10^{+53}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;a \leq 7.5 \cdot 10^{+91}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -1.70000000000000005e135 or 7.50000000000000033e91 < a Initial program 93.5%
associate-+l-93.5%
*-commutative93.5%
*-commutative93.5%
sub-neg93.5%
metadata-eval93.5%
remove-double-neg93.5%
remove-double-neg93.5%
sub-neg93.5%
metadata-eval93.5%
associate--l+93.5%
Simplified93.5%
Taylor expanded in a around inf 68.1%
if -1.70000000000000005e135 < a < -9.20000000000000047e39Initial program 90.5%
associate-+l-90.5%
*-commutative90.5%
*-commutative90.5%
sub-neg90.5%
metadata-eval90.5%
remove-double-neg90.5%
remove-double-neg90.5%
sub-neg90.5%
metadata-eval90.5%
associate--l+90.5%
Simplified90.5%
Taylor expanded in t around inf 67.4%
Taylor expanded in y around inf 35.0%
mul-1-neg35.0%
*-commutative35.0%
distribute-rgt-neg-in35.0%
Simplified35.0%
if -9.20000000000000047e39 < a < -1.5e28Initial program 75.0%
associate-+l-75.0%
*-commutative75.0%
*-commutative75.0%
sub-neg75.0%
metadata-eval75.0%
remove-double-neg75.0%
remove-double-neg75.0%
sub-neg75.0%
metadata-eval75.0%
associate--l+75.0%
Simplified75.0%
Taylor expanded in y around inf 75.5%
Taylor expanded in b around inf 75.5%
if -1.5e28 < a < -1.36e-27 or 8.79999999999999964e-20 < a < 1.49999999999999999e53Initial 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 70.5%
Taylor expanded in b around inf 36.0%
if -1.36e-27 < a < 8.79999999999999964e-20 or 1.49999999999999999e53 < a < 7.50000000000000033e91Initial program 96.0%
associate-+l-96.0%
*-commutative96.0%
*-commutative96.0%
sub-neg96.0%
metadata-eval96.0%
remove-double-neg96.0%
remove-double-neg96.0%
sub-neg96.0%
metadata-eval96.0%
associate--l+96.0%
Simplified96.0%
Taylor expanded in y around inf 70.3%
mul-1-neg70.3%
distribute-rgt-neg-in70.3%
Simplified70.3%
Taylor expanded in y around 0 40.8%
sub-neg40.8%
neg-mul-140.8%
remove-double-neg40.8%
+-commutative40.8%
Simplified40.8%
Final simplification48.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -2.4e+68)
t_1
(if (<= t -3600.0)
(+ z x)
(if (<= t -3.5e-120)
(* a (- 1.0 t))
(if (<= t -8.5e-273)
(* b (- y 2.0))
(if (<= t 3.4e-141)
(+ z x)
(if (<= t 8.5e-24)
(* y (- b z))
(if (<= t 2.2e+34) (+ z x) t_1)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -2.4e+68) {
tmp = t_1;
} else if (t <= -3600.0) {
tmp = z + x;
} else if (t <= -3.5e-120) {
tmp = a * (1.0 - t);
} else if (t <= -8.5e-273) {
tmp = b * (y - 2.0);
} else if (t <= 3.4e-141) {
tmp = z + x;
} else if (t <= 8.5e-24) {
tmp = y * (b - z);
} else if (t <= 2.2e+34) {
tmp = z + x;
} 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.4d+68)) then
tmp = t_1
else if (t <= (-3600.0d0)) then
tmp = z + x
else if (t <= (-3.5d-120)) then
tmp = a * (1.0d0 - t)
else if (t <= (-8.5d-273)) then
tmp = b * (y - 2.0d0)
else if (t <= 3.4d-141) then
tmp = z + x
else if (t <= 8.5d-24) then
tmp = y * (b - z)
else if (t <= 2.2d+34) then
tmp = z + x
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.4e+68) {
tmp = t_1;
} else if (t <= -3600.0) {
tmp = z + x;
} else if (t <= -3.5e-120) {
tmp = a * (1.0 - t);
} else if (t <= -8.5e-273) {
tmp = b * (y - 2.0);
} else if (t <= 3.4e-141) {
tmp = z + x;
} else if (t <= 8.5e-24) {
tmp = y * (b - z);
} else if (t <= 2.2e+34) {
tmp = z + x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -2.4e+68: tmp = t_1 elif t <= -3600.0: tmp = z + x elif t <= -3.5e-120: tmp = a * (1.0 - t) elif t <= -8.5e-273: tmp = b * (y - 2.0) elif t <= 3.4e-141: tmp = z + x elif t <= 8.5e-24: tmp = y * (b - z) elif t <= 2.2e+34: tmp = z + x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -2.4e+68) tmp = t_1; elseif (t <= -3600.0) tmp = Float64(z + x); elseif (t <= -3.5e-120) tmp = Float64(a * Float64(1.0 - t)); elseif (t <= -8.5e-273) tmp = Float64(b * Float64(y - 2.0)); elseif (t <= 3.4e-141) tmp = Float64(z + x); elseif (t <= 8.5e-24) tmp = Float64(y * Float64(b - z)); elseif (t <= 2.2e+34) tmp = Float64(z + x); 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.4e+68) tmp = t_1; elseif (t <= -3600.0) tmp = z + x; elseif (t <= -3.5e-120) tmp = a * (1.0 - t); elseif (t <= -8.5e-273) tmp = b * (y - 2.0); elseif (t <= 3.4e-141) tmp = z + x; elseif (t <= 8.5e-24) tmp = y * (b - z); elseif (t <= 2.2e+34) tmp = z + x; 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.4e+68], t$95$1, If[LessEqual[t, -3600.0], N[(z + x), $MachinePrecision], If[LessEqual[t, -3.5e-120], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -8.5e-273], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.4e-141], N[(z + x), $MachinePrecision], If[LessEqual[t, 8.5e-24], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.2e+34], N[(z + x), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.4 \cdot 10^{+68}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3600:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq -3.5 \cdot 10^{-120}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;t \leq -8.5 \cdot 10^{-273}:\\
\;\;\;\;b \cdot \left(y - 2\right)\\
\mathbf{elif}\;t \leq 3.4 \cdot 10^{-141}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{-24}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq 2.2 \cdot 10^{+34}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.40000000000000008e68 or 2.2000000000000002e34 < 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 64.8%
if -2.40000000000000008e68 < t < -3600 or -8.5000000000000008e-273 < t < 3.3999999999999998e-141 or 8.5000000000000002e-24 < t < 2.2000000000000002e34Initial program 96.6%
associate-+l-96.6%
*-commutative96.6%
*-commutative96.6%
sub-neg96.6%
metadata-eval96.6%
remove-double-neg96.6%
remove-double-neg96.6%
sub-neg96.6%
metadata-eval96.6%
associate--l+96.6%
Simplified96.6%
Taylor expanded in y around inf 76.2%
mul-1-neg76.2%
distribute-rgt-neg-in76.2%
Simplified76.2%
Taylor expanded in y around 0 53.2%
sub-neg53.2%
neg-mul-153.2%
remove-double-neg53.2%
+-commutative53.2%
Simplified53.2%
if -3600 < t < -3.5e-120Initial 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 42.8%
if -3.5e-120 < t < -8.5000000000000008e-273Initial 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 0 100.0%
sub-neg100.0%
+-commutative100.0%
mul-1-neg100.0%
unsub-neg100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
metadata-eval100.0%
+-commutative100.0%
distribute-neg-in100.0%
metadata-eval100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in b around inf 55.7%
if 3.3999999999999998e-141 < t < 8.5000000000000002e-24Initial program 92.2%
associate-+l-92.2%
*-commutative92.2%
*-commutative92.2%
sub-neg92.2%
metadata-eval92.2%
remove-double-neg92.2%
remove-double-neg92.2%
sub-neg92.2%
metadata-eval92.2%
associate--l+92.2%
Simplified92.2%
Taylor expanded in y around inf 58.2%
Final simplification57.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))) (t_2 (* y (- b z))) (t_3 (+ x t_1)))
(if (<= y -6e+125)
t_2
(if (<= y -1.42e+88)
t_1
(if (<= y -1.72e+34)
t_2
(if (<= y 2.6e-143)
t_3
(if (<= y 7.8e-93) (+ z x) (if (<= y 1.25e+132) t_3 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double t_2 = y * (b - z);
double t_3 = x + t_1;
double tmp;
if (y <= -6e+125) {
tmp = t_2;
} else if (y <= -1.42e+88) {
tmp = t_1;
} else if (y <= -1.72e+34) {
tmp = t_2;
} else if (y <= 2.6e-143) {
tmp = t_3;
} else if (y <= 7.8e-93) {
tmp = z + x;
} else if (y <= 1.25e+132) {
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 = t * (b - a)
t_2 = y * (b - z)
t_3 = x + t_1
if (y <= (-6d+125)) then
tmp = t_2
else if (y <= (-1.42d+88)) then
tmp = t_1
else if (y <= (-1.72d+34)) then
tmp = t_2
else if (y <= 2.6d-143) then
tmp = t_3
else if (y <= 7.8d-93) then
tmp = z + x
else if (y <= 1.25d+132) 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 = t * (b - a);
double t_2 = y * (b - z);
double t_3 = x + t_1;
double tmp;
if (y <= -6e+125) {
tmp = t_2;
} else if (y <= -1.42e+88) {
tmp = t_1;
} else if (y <= -1.72e+34) {
tmp = t_2;
} else if (y <= 2.6e-143) {
tmp = t_3;
} else if (y <= 7.8e-93) {
tmp = z + x;
} else if (y <= 1.25e+132) {
tmp = t_3;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) t_2 = y * (b - z) t_3 = x + t_1 tmp = 0 if y <= -6e+125: tmp = t_2 elif y <= -1.42e+88: tmp = t_1 elif y <= -1.72e+34: tmp = t_2 elif y <= 2.6e-143: tmp = t_3 elif y <= 7.8e-93: tmp = z + x elif y <= 1.25e+132: tmp = t_3 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) t_2 = Float64(y * Float64(b - z)) t_3 = Float64(x + t_1) tmp = 0.0 if (y <= -6e+125) tmp = t_2; elseif (y <= -1.42e+88) tmp = t_1; elseif (y <= -1.72e+34) tmp = t_2; elseif (y <= 2.6e-143) tmp = t_3; elseif (y <= 7.8e-93) tmp = Float64(z + x); elseif (y <= 1.25e+132) tmp = t_3; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); t_2 = y * (b - z); t_3 = x + t_1; tmp = 0.0; if (y <= -6e+125) tmp = t_2; elseif (y <= -1.42e+88) tmp = t_1; elseif (y <= -1.72e+34) tmp = t_2; elseif (y <= 2.6e-143) tmp = t_3; elseif (y <= 7.8e-93) tmp = z + x; elseif (y <= 1.25e+132) tmp = t_3; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + t$95$1), $MachinePrecision]}, If[LessEqual[y, -6e+125], t$95$2, If[LessEqual[y, -1.42e+88], t$95$1, If[LessEqual[y, -1.72e+34], t$95$2, If[LessEqual[y, 2.6e-143], t$95$3, If[LessEqual[y, 7.8e-93], N[(z + x), $MachinePrecision], If[LessEqual[y, 1.25e+132], t$95$3, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
t_2 := y \cdot \left(b - z\right)\\
t_3 := x + t_1\\
\mathbf{if}\;y \leq -6 \cdot 10^{+125}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -1.42 \cdot 10^{+88}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.72 \cdot 10^{+34}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 2.6 \cdot 10^{-143}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq 7.8 \cdot 10^{-93}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;y \leq 1.25 \cdot 10^{+132}:\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -6.0000000000000003e125 or -1.41999999999999996e88 < y < -1.72000000000000011e34 or 1.25e132 < y Initial program 89.0%
associate-+l-89.0%
*-commutative89.0%
*-commutative89.0%
sub-neg89.0%
metadata-eval89.0%
remove-double-neg89.0%
remove-double-neg89.0%
sub-neg89.0%
metadata-eval89.0%
associate--l+89.0%
Simplified89.0%
Taylor expanded in y around inf 79.7%
if -6.0000000000000003e125 < y < -1.41999999999999996e88Initial 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 t around inf 70.5%
if -1.72000000000000011e34 < y < 2.59999999999999987e-143 or 7.80000000000000035e-93 < y < 1.25e132Initial 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 t around inf 72.4%
Taylor expanded in z around 0 58.1%
if 2.59999999999999987e-143 < y < 7.80000000000000035e-93Initial 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 68.2%
mul-1-neg68.2%
distribute-rgt-neg-in68.2%
Simplified68.2%
Taylor expanded in y around 0 68.2%
sub-neg68.2%
neg-mul-168.2%
remove-double-neg68.2%
+-commutative68.2%
Simplified68.2%
Final simplification66.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (* z (+ y -1.0))))
(t_2 (+ x (* t (- b a))))
(t_3 (* b (- (+ y t) 2.0))))
(if (<= b -1.05e+112)
t_3
(if (<= b -0.0042)
t_2
(if (<= b -6e-14)
(* y (- b z))
(if (<= b 4.1e-38)
t_1
(if (<= b 1.3e+53) t_2 (if (<= b 5.5e+130) t_1 t_3))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - (z * (y + -1.0));
double t_2 = x + (t * (b - a));
double t_3 = b * ((y + t) - 2.0);
double tmp;
if (b <= -1.05e+112) {
tmp = t_3;
} else if (b <= -0.0042) {
tmp = t_2;
} else if (b <= -6e-14) {
tmp = y * (b - z);
} else if (b <= 4.1e-38) {
tmp = t_1;
} else if (b <= 1.3e+53) {
tmp = t_2;
} else if (b <= 5.5e+130) {
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 * (y + (-1.0d0)))
t_2 = x + (t * (b - a))
t_3 = b * ((y + t) - 2.0d0)
if (b <= (-1.05d+112)) then
tmp = t_3
else if (b <= (-0.0042d0)) then
tmp = t_2
else if (b <= (-6d-14)) then
tmp = y * (b - z)
else if (b <= 4.1d-38) then
tmp = t_1
else if (b <= 1.3d+53) then
tmp = t_2
else if (b <= 5.5d+130) 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 * (y + -1.0));
double t_2 = x + (t * (b - a));
double t_3 = b * ((y + t) - 2.0);
double tmp;
if (b <= -1.05e+112) {
tmp = t_3;
} else if (b <= -0.0042) {
tmp = t_2;
} else if (b <= -6e-14) {
tmp = y * (b - z);
} else if (b <= 4.1e-38) {
tmp = t_1;
} else if (b <= 1.3e+53) {
tmp = t_2;
} else if (b <= 5.5e+130) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x - (z * (y + -1.0)) t_2 = x + (t * (b - a)) t_3 = b * ((y + t) - 2.0) tmp = 0 if b <= -1.05e+112: tmp = t_3 elif b <= -0.0042: tmp = t_2 elif b <= -6e-14: tmp = y * (b - z) elif b <= 4.1e-38: tmp = t_1 elif b <= 1.3e+53: tmp = t_2 elif b <= 5.5e+130: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x - Float64(z * Float64(y + -1.0))) t_2 = Float64(x + Float64(t * Float64(b - a))) t_3 = Float64(b * Float64(Float64(y + t) - 2.0)) tmp = 0.0 if (b <= -1.05e+112) tmp = t_3; elseif (b <= -0.0042) tmp = t_2; elseif (b <= -6e-14) tmp = Float64(y * Float64(b - z)); elseif (b <= 4.1e-38) tmp = t_1; elseif (b <= 1.3e+53) tmp = t_2; elseif (b <= 5.5e+130) 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 * (y + -1.0)); t_2 = x + (t * (b - a)); t_3 = b * ((y + t) - 2.0); tmp = 0.0; if (b <= -1.05e+112) tmp = t_3; elseif (b <= -0.0042) tmp = t_2; elseif (b <= -6e-14) tmp = y * (b - z); elseif (b <= 4.1e-38) tmp = t_1; elseif (b <= 1.3e+53) tmp = t_2; elseif (b <= 5.5e+130) 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 * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.05e+112], t$95$3, If[LessEqual[b, -0.0042], t$95$2, If[LessEqual[b, -6e-14], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.1e-38], t$95$1, If[LessEqual[b, 1.3e+53], t$95$2, If[LessEqual[b, 5.5e+130], t$95$1, t$95$3]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - z \cdot \left(y + -1\right)\\
t_2 := x + t \cdot \left(b - a\right)\\
t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\
\mathbf{if}\;b \leq -1.05 \cdot 10^{+112}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq -0.0042:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -6 \cdot 10^{-14}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;b \leq 4.1 \cdot 10^{-38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 1.3 \cdot 10^{+53}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq 5.5 \cdot 10^{+130}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if b < -1.0499999999999999e112 or 5.4999999999999997e130 < b Initial program 90.8%
associate-+l-90.8%
*-commutative90.8%
*-commutative90.8%
sub-neg90.8%
metadata-eval90.8%
remove-double-neg90.8%
remove-double-neg90.8%
sub-neg90.8%
metadata-eval90.8%
associate--l+90.8%
Simplified90.8%
Taylor expanded in b around inf 81.8%
if -1.0499999999999999e112 < b < -0.00419999999999999974 or 4.0999999999999998e-38 < b < 1.29999999999999999e53Initial program 93.1%
associate-+l-93.1%
*-commutative93.1%
*-commutative93.1%
sub-neg93.1%
metadata-eval93.1%
remove-double-neg93.1%
remove-double-neg93.1%
sub-neg93.1%
metadata-eval93.1%
associate--l+93.1%
Simplified93.1%
Taylor expanded in t around inf 80.8%
Taylor expanded in z around 0 60.8%
if -0.00419999999999999974 < b < -5.9999999999999997e-14Initial program 99.7%
associate-+l-99.7%
*-commutative99.7%
*-commutative99.7%
sub-neg99.7%
metadata-eval99.7%
remove-double-neg99.7%
remove-double-neg99.7%
sub-neg99.7%
metadata-eval99.7%
associate--l+99.7%
Simplified99.7%
Taylor expanded in y around inf 95.9%
if -5.9999999999999997e-14 < b < 4.0999999999999998e-38 or 1.29999999999999999e53 < b < 5.4999999999999997e130Initial 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 t around inf 80.3%
Taylor expanded in t around 0 63.1%
Final simplification69.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (* z (+ y -1.0)))))
(if (or (<= t -2.3) (not (<= t 175.0)))
(+ t_1 (* t (- b a)))
(+ t_1 (+ a (* b (- y 2.0)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - (z * (y + -1.0));
double tmp;
if ((t <= -2.3) || !(t <= 175.0)) {
tmp = t_1 + (t * (b - a));
} else {
tmp = t_1 + (a + (b * (y - 2.0)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x - (z * (y + (-1.0d0)))
if ((t <= (-2.3d0)) .or. (.not. (t <= 175.0d0))) then
tmp = t_1 + (t * (b - a))
else
tmp = t_1 + (a + (b * (y - 2.0d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - (z * (y + -1.0));
double tmp;
if ((t <= -2.3) || !(t <= 175.0)) {
tmp = t_1 + (t * (b - a));
} else {
tmp = t_1 + (a + (b * (y - 2.0)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x - (z * (y + -1.0)) tmp = 0 if (t <= -2.3) or not (t <= 175.0): tmp = t_1 + (t * (b - a)) else: tmp = t_1 + (a + (b * (y - 2.0))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x - Float64(z * Float64(y + -1.0))) tmp = 0.0 if ((t <= -2.3) || !(t <= 175.0)) tmp = Float64(t_1 + Float64(t * Float64(b - a))); else tmp = Float64(t_1 + Float64(a + Float64(b * Float64(y - 2.0)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x - (z * (y + -1.0)); tmp = 0.0; if ((t <= -2.3) || ~((t <= 175.0))) tmp = t_1 + (t * (b - a)); else tmp = t_1 + (a + (b * (y - 2.0))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t, -2.3], N[Not[LessEqual[t, 175.0]], $MachinePrecision]], N[(t$95$1 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(a + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - z \cdot \left(y + -1\right)\\
\mathbf{if}\;t \leq -2.3 \lor \neg \left(t \leq 175\right):\\
\;\;\;\;t_1 + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;t_1 + \left(a + b \cdot \left(y - 2\right)\right)\\
\end{array}
\end{array}
if t < -2.2999999999999998 or 175 < t Initial program 92.0%
associate-+l-92.0%
*-commutative92.0%
*-commutative92.0%
sub-neg92.0%
metadata-eval92.0%
remove-double-neg92.0%
remove-double-neg92.0%
sub-neg92.0%
metadata-eval92.0%
associate--l+92.0%
Simplified92.0%
Taylor expanded in t around inf 90.9%
if -2.2999999999999998 < t < 175Initial 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 t around 0 96.9%
sub-neg96.9%
+-commutative96.9%
mul-1-neg96.9%
unsub-neg96.9%
*-commutative96.9%
distribute-rgt-neg-in96.9%
sub-neg96.9%
metadata-eval96.9%
+-commutative96.9%
distribute-neg-in96.9%
metadata-eval96.9%
sub-neg96.9%
Simplified96.9%
Final simplification94.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -2.9e+68)
t_1
(if (<= t -1500000.0)
(+ z x)
(if (<= t -3.2e-142)
(* a (- 1.0 t))
(if (<= t 1.8e-137)
(+ z x)
(if (<= t 5e-24)
(* y (- b z))
(if (<= t 1.02e+33) (+ z x) t_1))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -2.9e+68) {
tmp = t_1;
} else if (t <= -1500000.0) {
tmp = z + x;
} else if (t <= -3.2e-142) {
tmp = a * (1.0 - t);
} else if (t <= 1.8e-137) {
tmp = z + x;
} else if (t <= 5e-24) {
tmp = y * (b - z);
} else if (t <= 1.02e+33) {
tmp = z + x;
} 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.9d+68)) then
tmp = t_1
else if (t <= (-1500000.0d0)) then
tmp = z + x
else if (t <= (-3.2d-142)) then
tmp = a * (1.0d0 - t)
else if (t <= 1.8d-137) then
tmp = z + x
else if (t <= 5d-24) then
tmp = y * (b - z)
else if (t <= 1.02d+33) then
tmp = z + x
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.9e+68) {
tmp = t_1;
} else if (t <= -1500000.0) {
tmp = z + x;
} else if (t <= -3.2e-142) {
tmp = a * (1.0 - t);
} else if (t <= 1.8e-137) {
tmp = z + x;
} else if (t <= 5e-24) {
tmp = y * (b - z);
} else if (t <= 1.02e+33) {
tmp = z + x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -2.9e+68: tmp = t_1 elif t <= -1500000.0: tmp = z + x elif t <= -3.2e-142: tmp = a * (1.0 - t) elif t <= 1.8e-137: tmp = z + x elif t <= 5e-24: tmp = y * (b - z) elif t <= 1.02e+33: tmp = z + x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -2.9e+68) tmp = t_1; elseif (t <= -1500000.0) tmp = Float64(z + x); elseif (t <= -3.2e-142) tmp = Float64(a * Float64(1.0 - t)); elseif (t <= 1.8e-137) tmp = Float64(z + x); elseif (t <= 5e-24) tmp = Float64(y * Float64(b - z)); elseif (t <= 1.02e+33) tmp = Float64(z + x); 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.9e+68) tmp = t_1; elseif (t <= -1500000.0) tmp = z + x; elseif (t <= -3.2e-142) tmp = a * (1.0 - t); elseif (t <= 1.8e-137) tmp = z + x; elseif (t <= 5e-24) tmp = y * (b - z); elseif (t <= 1.02e+33) tmp = z + x; 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.9e+68], t$95$1, If[LessEqual[t, -1500000.0], N[(z + x), $MachinePrecision], If[LessEqual[t, -3.2e-142], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.8e-137], N[(z + x), $MachinePrecision], If[LessEqual[t, 5e-24], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.02e+33], N[(z + x), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.9 \cdot 10^{+68}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1500000:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq -3.2 \cdot 10^{-142}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;t \leq 1.8 \cdot 10^{-137}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-24}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq 1.02 \cdot 10^{+33}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.90000000000000011e68 or 1.02000000000000001e33 < 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 64.8%
if -2.90000000000000011e68 < t < -1.5e6 or -3.1999999999999998e-142 < t < 1.80000000000000003e-137 or 4.9999999999999998e-24 < t < 1.02000000000000001e33Initial 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 73.4%
mul-1-neg73.4%
distribute-rgt-neg-in73.4%
Simplified73.4%
Taylor expanded in y around 0 47.3%
sub-neg47.3%
neg-mul-147.3%
remove-double-neg47.3%
+-commutative47.3%
Simplified47.3%
if -1.5e6 < t < -3.1999999999999998e-142Initial 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 38.8%
if 1.80000000000000003e-137 < t < 4.9999999999999998e-24Initial program 92.2%
associate-+l-92.2%
*-commutative92.2%
*-commutative92.2%
sub-neg92.2%
metadata-eval92.2%
remove-double-neg92.2%
remove-double-neg92.2%
sub-neg92.2%
metadata-eval92.2%
associate--l+92.2%
Simplified92.2%
Taylor expanded in y around inf 58.2%
Final simplification54.4%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -1.85e+108) (not (<= b 3.6e+131))) (* b (- (+ y t) 2.0)) (+ (- x (* z (+ y -1.0))) (- a (* t a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -1.85e+108) || !(b <= 3.6e+131)) {
tmp = b * ((y + t) - 2.0);
} else {
tmp = (x - (z * (y + -1.0))) + (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 <= (-1.85d+108)) .or. (.not. (b <= 3.6d+131))) then
tmp = b * ((y + t) - 2.0d0)
else
tmp = (x - (z * (y + (-1.0d0)))) + (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 <= -1.85e+108) || !(b <= 3.6e+131)) {
tmp = b * ((y + t) - 2.0);
} else {
tmp = (x - (z * (y + -1.0))) + (a - (t * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -1.85e+108) or not (b <= 3.6e+131): tmp = b * ((y + t) - 2.0) else: tmp = (x - (z * (y + -1.0))) + (a - (t * a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -1.85e+108) || !(b <= 3.6e+131)) tmp = Float64(b * Float64(Float64(y + t) - 2.0)); else tmp = Float64(Float64(x - Float64(z * Float64(y + -1.0))) + Float64(a - Float64(t * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -1.85e+108) || ~((b <= 3.6e+131))) tmp = b * ((y + t) - 2.0); else tmp = (x - (z * (y + -1.0))) + (a - (t * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -1.85e+108], N[Not[LessEqual[b, 3.6e+131]], $MachinePrecision]], N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.85 \cdot 10^{+108} \lor \neg \left(b \leq 3.6 \cdot 10^{+131}\right):\\
\;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x - z \cdot \left(y + -1\right)\right) + \left(a - t \cdot a\right)\\
\end{array}
\end{array}
if b < -1.8499999999999999e108 or 3.60000000000000031e131 < b Initial program 90.8%
associate-+l-90.8%
*-commutative90.8%
*-commutative90.8%
sub-neg90.8%
metadata-eval90.8%
remove-double-neg90.8%
remove-double-neg90.8%
sub-neg90.8%
metadata-eval90.8%
associate--l+90.8%
Simplified90.8%
Taylor expanded in b around inf 81.8%
if -1.8499999999999999e108 < b < 3.60000000000000031e131Initial program 96.6%
associate-+l-96.6%
*-commutative96.6%
*-commutative96.6%
sub-neg96.6%
metadata-eval96.6%
remove-double-neg96.6%
remove-double-neg96.6%
sub-neg96.6%
metadata-eval96.6%
associate--l+96.6%
Simplified96.6%
Taylor expanded in a around inf 89.5%
sub-neg89.5%
metadata-eval89.5%
+-commutative89.5%
*-commutative89.5%
+-commutative89.5%
distribute-rgt-in89.5%
fma-def89.5%
mul-1-neg89.5%
fma-neg89.5%
Simplified89.5%
Final simplification87.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- z))))
(if (<= y -8.2e+149)
t_1
(if (<= y -1.65e+93)
(* y b)
(if (<= y -7.7e+24)
t_1
(if (<= y 6.2e-48)
(+ z x)
(if (<= y 5.5e+61) (* t b) (if (<= y 1.2e+133) (+ z x) t_1))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * -z;
double tmp;
if (y <= -8.2e+149) {
tmp = t_1;
} else if (y <= -1.65e+93) {
tmp = y * b;
} else if (y <= -7.7e+24) {
tmp = t_1;
} else if (y <= 6.2e-48) {
tmp = z + x;
} else if (y <= 5.5e+61) {
tmp = t * b;
} else if (y <= 1.2e+133) {
tmp = z + x;
} 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 = y * -z
if (y <= (-8.2d+149)) then
tmp = t_1
else if (y <= (-1.65d+93)) then
tmp = y * b
else if (y <= (-7.7d+24)) then
tmp = t_1
else if (y <= 6.2d-48) then
tmp = z + x
else if (y <= 5.5d+61) then
tmp = t * b
else if (y <= 1.2d+133) then
tmp = z + x
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 = y * -z;
double tmp;
if (y <= -8.2e+149) {
tmp = t_1;
} else if (y <= -1.65e+93) {
tmp = y * b;
} else if (y <= -7.7e+24) {
tmp = t_1;
} else if (y <= 6.2e-48) {
tmp = z + x;
} else if (y <= 5.5e+61) {
tmp = t * b;
} else if (y <= 1.2e+133) {
tmp = z + x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * -z tmp = 0 if y <= -8.2e+149: tmp = t_1 elif y <= -1.65e+93: tmp = y * b elif y <= -7.7e+24: tmp = t_1 elif y <= 6.2e-48: tmp = z + x elif y <= 5.5e+61: tmp = t * b elif y <= 1.2e+133: tmp = z + x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(-z)) tmp = 0.0 if (y <= -8.2e+149) tmp = t_1; elseif (y <= -1.65e+93) tmp = Float64(y * b); elseif (y <= -7.7e+24) tmp = t_1; elseif (y <= 6.2e-48) tmp = Float64(z + x); elseif (y <= 5.5e+61) tmp = Float64(t * b); elseif (y <= 1.2e+133) tmp = Float64(z + x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * -z; tmp = 0.0; if (y <= -8.2e+149) tmp = t_1; elseif (y <= -1.65e+93) tmp = y * b; elseif (y <= -7.7e+24) tmp = t_1; elseif (y <= 6.2e-48) tmp = z + x; elseif (y <= 5.5e+61) tmp = t * b; elseif (y <= 1.2e+133) tmp = z + x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * (-z)), $MachinePrecision]}, If[LessEqual[y, -8.2e+149], t$95$1, If[LessEqual[y, -1.65e+93], N[(y * b), $MachinePrecision], If[LessEqual[y, -7.7e+24], t$95$1, If[LessEqual[y, 6.2e-48], N[(z + x), $MachinePrecision], If[LessEqual[y, 5.5e+61], N[(t * b), $MachinePrecision], If[LessEqual[y, 1.2e+133], N[(z + x), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(-z\right)\\
\mathbf{if}\;y \leq -8.2 \cdot 10^{+149}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.65 \cdot 10^{+93}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;y \leq -7.7 \cdot 10^{+24}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 6.2 \cdot 10^{-48}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;y \leq 5.5 \cdot 10^{+61}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{+133}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -8.1999999999999992e149 or -1.65000000000000004e93 < y < -7.70000000000000046e24 or 1.1999999999999999e133 < y Initial program 90.8%
associate-+l-90.8%
*-commutative90.8%
*-commutative90.8%
sub-neg90.8%
metadata-eval90.8%
remove-double-neg90.8%
remove-double-neg90.8%
sub-neg90.8%
metadata-eval90.8%
associate--l+90.8%
Simplified90.8%
Taylor expanded in t around inf 72.5%
Taylor expanded in y around inf 53.5%
mul-1-neg53.5%
*-commutative53.5%
distribute-rgt-neg-in53.5%
Simplified53.5%
if -8.1999999999999992e149 < y < -1.65000000000000004e93Initial program 76.9%
associate-+l-76.9%
*-commutative76.9%
*-commutative76.9%
sub-neg76.9%
metadata-eval76.9%
remove-double-neg76.9%
remove-double-neg76.9%
sub-neg76.9%
metadata-eval76.9%
associate--l+76.9%
Simplified76.9%
Taylor expanded in y around inf 54.7%
Taylor expanded in b around inf 47.7%
if -7.70000000000000046e24 < y < 6.20000000000000033e-48 or 5.50000000000000036e61 < y < 1.1999999999999999e133Initial program 99.2%
associate-+l-99.2%
*-commutative99.2%
*-commutative99.2%
sub-neg99.2%
metadata-eval99.2%
remove-double-neg99.2%
remove-double-neg99.2%
sub-neg99.2%
metadata-eval99.2%
associate--l+99.2%
Simplified99.2%
Taylor expanded in y around inf 43.1%
mul-1-neg43.1%
distribute-rgt-neg-in43.1%
Simplified43.1%
Taylor expanded in y around 0 39.9%
sub-neg39.9%
neg-mul-139.9%
remove-double-neg39.9%
+-commutative39.9%
Simplified39.9%
if 6.20000000000000033e-48 < y < 5.50000000000000036e61Initial 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 t around inf 79.2%
Taylor expanded in b around inf 45.5%
Final simplification45.5%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -2.4e+112) (not (<= b 1.3e+134))) (* b (- (+ y t) 2.0)) (- (- x (* z (+ y -1.0))) (* t a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -2.4e+112) || !(b <= 1.3e+134)) {
tmp = b * ((y + t) - 2.0);
} else {
tmp = (x - (z * (y + -1.0))) - (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.4d+112)) .or. (.not. (b <= 1.3d+134))) then
tmp = b * ((y + t) - 2.0d0)
else
tmp = (x - (z * (y + (-1.0d0)))) - (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.4e+112) || !(b <= 1.3e+134)) {
tmp = b * ((y + t) - 2.0);
} else {
tmp = (x - (z * (y + -1.0))) - (t * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -2.4e+112) or not (b <= 1.3e+134): tmp = b * ((y + t) - 2.0) else: tmp = (x - (z * (y + -1.0))) - (t * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -2.4e+112) || !(b <= 1.3e+134)) tmp = Float64(b * Float64(Float64(y + t) - 2.0)); else tmp = Float64(Float64(x - Float64(z * Float64(y + -1.0))) - Float64(t * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -2.4e+112) || ~((b <= 1.3e+134))) tmp = b * ((y + t) - 2.0); else tmp = (x - (z * (y + -1.0))) - (t * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -2.4e+112], N[Not[LessEqual[b, 1.3e+134]], $MachinePrecision]], N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.4 \cdot 10^{+112} \lor \neg \left(b \leq 1.3 \cdot 10^{+134}\right):\\
\;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x - z \cdot \left(y + -1\right)\right) - t \cdot a\\
\end{array}
\end{array}
if b < -2.4e112 or 1.3000000000000001e134 < b Initial program 90.8%
associate-+l-90.8%
*-commutative90.8%
*-commutative90.8%
sub-neg90.8%
metadata-eval90.8%
remove-double-neg90.8%
remove-double-neg90.8%
sub-neg90.8%
metadata-eval90.8%
associate--l+90.8%
Simplified90.8%
Taylor expanded in b around inf 81.8%
if -2.4e112 < b < 1.3000000000000001e134Initial program 96.6%
associate-+l-96.6%
*-commutative96.6%
*-commutative96.6%
sub-neg96.6%
metadata-eval96.6%
remove-double-neg96.6%
remove-double-neg96.6%
sub-neg96.6%
metadata-eval96.6%
associate--l+96.6%
Simplified96.6%
Taylor expanded in t around inf 80.0%
Taylor expanded in a around inf 76.4%
*-commutative76.4%
Simplified76.4%
Final simplification78.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- z (* y z))))
(if (<= z -1.26e+111)
t_1
(if (<= z -8.8e-98)
(* b (- (+ y t) 2.0))
(if (<= z 1.55e-254)
(+ x (* y b))
(if (<= z 5.5e+46) (- x (* t a)) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z - (y * z);
double tmp;
if (z <= -1.26e+111) {
tmp = t_1;
} else if (z <= -8.8e-98) {
tmp = b * ((y + t) - 2.0);
} else if (z <= 1.55e-254) {
tmp = x + (y * b);
} else if (z <= 5.5e+46) {
tmp = x - (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 = z - (y * z)
if (z <= (-1.26d+111)) then
tmp = t_1
else if (z <= (-8.8d-98)) then
tmp = b * ((y + t) - 2.0d0)
else if (z <= 1.55d-254) then
tmp = x + (y * b)
else if (z <= 5.5d+46) then
tmp = x - (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 = z - (y * z);
double tmp;
if (z <= -1.26e+111) {
tmp = t_1;
} else if (z <= -8.8e-98) {
tmp = b * ((y + t) - 2.0);
} else if (z <= 1.55e-254) {
tmp = x + (y * b);
} else if (z <= 5.5e+46) {
tmp = x - (t * a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z - (y * z) tmp = 0 if z <= -1.26e+111: tmp = t_1 elif z <= -8.8e-98: tmp = b * ((y + t) - 2.0) elif z <= 1.55e-254: tmp = x + (y * b) elif z <= 5.5e+46: tmp = x - (t * a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z - Float64(y * z)) tmp = 0.0 if (z <= -1.26e+111) tmp = t_1; elseif (z <= -8.8e-98) tmp = Float64(b * Float64(Float64(y + t) - 2.0)); elseif (z <= 1.55e-254) tmp = Float64(x + Float64(y * b)); elseif (z <= 5.5e+46) tmp = Float64(x - Float64(t * a)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z - (y * z); tmp = 0.0; if (z <= -1.26e+111) tmp = t_1; elseif (z <= -8.8e-98) tmp = b * ((y + t) - 2.0); elseif (z <= 1.55e-254) tmp = x + (y * b); elseif (z <= 5.5e+46) tmp = x - (t * a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.26e+111], t$95$1, If[LessEqual[z, -8.8e-98], N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.55e-254], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.5e+46], N[(x - N[(t * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z - y \cdot z\\
\mathbf{if}\;z \leq -1.26 \cdot 10^{+111}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -8.8 \cdot 10^{-98}:\\
\;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{-254}:\\
\;\;\;\;x + y \cdot b\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{+46}:\\
\;\;\;\;x - t \cdot a\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.26e111 or 5.4999999999999998e46 < z Initial program 90.2%
associate-+l-90.2%
*-commutative90.2%
*-commutative90.2%
sub-neg90.2%
metadata-eval90.2%
remove-double-neg90.2%
remove-double-neg90.2%
sub-neg90.2%
metadata-eval90.2%
associate--l+90.2%
Simplified90.2%
Taylor expanded in z around inf 60.4%
sub-neg60.4%
neg-mul-160.4%
distribute-rgt-in60.4%
*-lft-identity60.4%
associate-*r*60.4%
mul-1-neg60.4%
unsub-neg60.4%
Simplified60.4%
if -1.26e111 < z < -8.79999999999999985e-98Initial 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 b around inf 46.7%
if -8.79999999999999985e-98 < z < 1.54999999999999994e-254Initial 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 61.2%
mul-1-neg61.2%
distribute-rgt-neg-in61.2%
Simplified61.2%
Taylor expanded in z around 0 55.6%
Taylor expanded in x around 0 55.6%
if 1.54999999999999994e-254 < z < 5.4999999999999998e46Initial program 96.8%
associate-+l-96.8%
*-commutative96.8%
*-commutative96.8%
sub-neg96.8%
metadata-eval96.8%
remove-double-neg96.8%
remove-double-neg96.8%
sub-neg96.8%
metadata-eval96.8%
associate--l+96.8%
Simplified96.8%
Taylor expanded in t around inf 74.1%
Taylor expanded in a around inf 53.9%
*-commutative53.9%
Simplified53.9%
Taylor expanded in z around 0 51.7%
Final simplification55.2%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -7.2e+114) (not (<= b 2.65e+129))) (* b (- (+ y t) 2.0)) (+ (+ a x) (* z (- 1.0 y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -7.2e+114) || !(b <= 2.65e+129)) {
tmp = b * ((y + t) - 2.0);
} else {
tmp = (a + x) + (z * (1.0 - y));
}
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 <= (-7.2d+114)) .or. (.not. (b <= 2.65d+129))) then
tmp = b * ((y + t) - 2.0d0)
else
tmp = (a + x) + (z * (1.0d0 - y))
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 <= -7.2e+114) || !(b <= 2.65e+129)) {
tmp = b * ((y + t) - 2.0);
} else {
tmp = (a + x) + (z * (1.0 - y));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -7.2e+114) or not (b <= 2.65e+129): tmp = b * ((y + t) - 2.0) else: tmp = (a + x) + (z * (1.0 - y)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -7.2e+114) || !(b <= 2.65e+129)) tmp = Float64(b * Float64(Float64(y + t) - 2.0)); else tmp = Float64(Float64(a + x) + Float64(z * Float64(1.0 - y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -7.2e+114) || ~((b <= 2.65e+129))) tmp = b * ((y + t) - 2.0); else tmp = (a + x) + (z * (1.0 - y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -7.2e+114], N[Not[LessEqual[b, 2.65e+129]], $MachinePrecision]], N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(a + x), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -7.2 \cdot 10^{+114} \lor \neg \left(b \leq 2.65 \cdot 10^{+129}\right):\\
\;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a + x\right) + z \cdot \left(1 - y\right)\\
\end{array}
\end{array}
if b < -7.2000000000000001e114 or 2.6499999999999999e129 < 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 83.7%
if -7.2000000000000001e114 < b < 2.6499999999999999e129Initial program 96.2%
associate-+l-96.2%
*-commutative96.2%
*-commutative96.2%
sub-neg96.2%
metadata-eval96.2%
remove-double-neg96.2%
remove-double-neg96.2%
sub-neg96.2%
metadata-eval96.2%
associate--l+96.2%
Simplified96.2%
Taylor expanded in t around 0 75.5%
sub-neg75.5%
+-commutative75.5%
mul-1-neg75.5%
unsub-neg75.5%
*-commutative75.5%
distribute-rgt-neg-in75.5%
sub-neg75.5%
metadata-eval75.5%
+-commutative75.5%
distribute-neg-in75.5%
metadata-eval75.5%
sub-neg75.5%
Simplified75.5%
Taylor expanded in b around 0 70.8%
Final simplification74.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (* t a))))
(if (<= a -2.7e+121)
t_1
(if (<= a 8.5e-20)
(+ z x)
(if (<= a 1.76e+53) (* t b) (if (<= a 1.15e+91) (+ z x) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = -(t * a);
double tmp;
if (a <= -2.7e+121) {
tmp = t_1;
} else if (a <= 8.5e-20) {
tmp = z + x;
} else if (a <= 1.76e+53) {
tmp = t * b;
} else if (a <= 1.15e+91) {
tmp = z + x;
} 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 <= (-2.7d+121)) then
tmp = t_1
else if (a <= 8.5d-20) then
tmp = z + x
else if (a <= 1.76d+53) then
tmp = t * b
else if (a <= 1.15d+91) then
tmp = z + x
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 <= -2.7e+121) {
tmp = t_1;
} else if (a <= 8.5e-20) {
tmp = z + x;
} else if (a <= 1.76e+53) {
tmp = t * b;
} else if (a <= 1.15e+91) {
tmp = z + x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = -(t * a) tmp = 0 if a <= -2.7e+121: tmp = t_1 elif a <= 8.5e-20: tmp = z + x elif a <= 1.76e+53: tmp = t * b elif a <= 1.15e+91: tmp = z + x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(-Float64(t * a)) tmp = 0.0 if (a <= -2.7e+121) tmp = t_1; elseif (a <= 8.5e-20) tmp = Float64(z + x); elseif (a <= 1.76e+53) tmp = Float64(t * b); elseif (a <= 1.15e+91) tmp = Float64(z + x); 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 <= -2.7e+121) tmp = t_1; elseif (a <= 8.5e-20) tmp = z + x; elseif (a <= 1.76e+53) tmp = t * b; elseif (a <= 1.15e+91) tmp = z + x; 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, -2.7e+121], t$95$1, If[LessEqual[a, 8.5e-20], N[(z + x), $MachinePrecision], If[LessEqual[a, 1.76e+53], N[(t * b), $MachinePrecision], If[LessEqual[a, 1.15e+91], N[(z + x), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := -t \cdot a\\
\mathbf{if}\;a \leq -2.7 \cdot 10^{+121}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 8.5 \cdot 10^{-20}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;a \leq 1.76 \cdot 10^{+53}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;a \leq 1.15 \cdot 10^{+91}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -2.7000000000000002e121 or 1.14999999999999996e91 < 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 t around inf 64.2%
Taylor expanded in a around inf 42.8%
associate-*r*42.8%
*-commutative42.8%
neg-mul-142.8%
Simplified42.8%
if -2.7000000000000002e121 < a < 8.5000000000000005e-20 or 1.76e53 < a < 1.14999999999999996e91Initial program 95.6%
associate-+l-95.6%
*-commutative95.6%
*-commutative95.6%
sub-neg95.6%
metadata-eval95.6%
remove-double-neg95.6%
remove-double-neg95.6%
sub-neg95.6%
metadata-eval95.6%
associate--l+95.6%
Simplified95.6%
Taylor expanded in y around inf 68.3%
mul-1-neg68.3%
distribute-rgt-neg-in68.3%
Simplified68.3%
Taylor expanded in y around 0 38.4%
sub-neg38.4%
neg-mul-138.4%
remove-double-neg38.4%
+-commutative38.4%
Simplified38.4%
if 8.5000000000000005e-20 < a < 1.76e53Initial 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 65.1%
Taylor expanded in b around inf 33.2%
Final simplification39.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- z (* y z))))
(if (<= z -2e-21)
t_1
(if (<= z 4.8e-255)
(+ x (* y b))
(if (<= z 2.6e+46) (- x (* t a)) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z - (y * z);
double tmp;
if (z <= -2e-21) {
tmp = t_1;
} else if (z <= 4.8e-255) {
tmp = x + (y * b);
} else if (z <= 2.6e+46) {
tmp = x - (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 = z - (y * z)
if (z <= (-2d-21)) then
tmp = t_1
else if (z <= 4.8d-255) then
tmp = x + (y * b)
else if (z <= 2.6d+46) then
tmp = x - (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 = z - (y * z);
double tmp;
if (z <= -2e-21) {
tmp = t_1;
} else if (z <= 4.8e-255) {
tmp = x + (y * b);
} else if (z <= 2.6e+46) {
tmp = x - (t * a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z - (y * z) tmp = 0 if z <= -2e-21: tmp = t_1 elif z <= 4.8e-255: tmp = x + (y * b) elif z <= 2.6e+46: tmp = x - (t * a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z - Float64(y * z)) tmp = 0.0 if (z <= -2e-21) tmp = t_1; elseif (z <= 4.8e-255) tmp = Float64(x + Float64(y * b)); elseif (z <= 2.6e+46) tmp = Float64(x - Float64(t * a)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z - (y * z); tmp = 0.0; if (z <= -2e-21) tmp = t_1; elseif (z <= 4.8e-255) tmp = x + (y * b); elseif (z <= 2.6e+46) tmp = x - (t * a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e-21], t$95$1, If[LessEqual[z, 4.8e-255], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.6e+46], N[(x - N[(t * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z - y \cdot z\\
\mathbf{if}\;z \leq -2 \cdot 10^{-21}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 4.8 \cdot 10^{-255}:\\
\;\;\;\;x + y \cdot b\\
\mathbf{elif}\;z \leq 2.6 \cdot 10^{+46}:\\
\;\;\;\;x - t \cdot a\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.99999999999999982e-21 or 2.60000000000000013e46 < z Initial program 91.2%
associate-+l-91.2%
*-commutative91.2%
*-commutative91.2%
sub-neg91.2%
metadata-eval91.2%
remove-double-neg91.2%
remove-double-neg91.2%
sub-neg91.2%
metadata-eval91.2%
associate--l+91.2%
Simplified91.2%
Taylor expanded in z around inf 55.7%
sub-neg55.7%
neg-mul-155.7%
distribute-rgt-in55.7%
*-lft-identity55.7%
associate-*r*55.7%
mul-1-neg55.7%
unsub-neg55.7%
Simplified55.7%
if -1.99999999999999982e-21 < z < 4.7999999999999997e-255Initial 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 54.5%
mul-1-neg54.5%
distribute-rgt-neg-in54.5%
Simplified54.5%
Taylor expanded in z around 0 50.1%
Taylor expanded in x around 0 50.1%
if 4.7999999999999997e-255 < z < 2.60000000000000013e46Initial program 96.8%
associate-+l-96.8%
*-commutative96.8%
*-commutative96.8%
sub-neg96.8%
metadata-eval96.8%
remove-double-neg96.8%
remove-double-neg96.8%
sub-neg96.8%
metadata-eval96.8%
associate--l+96.8%
Simplified96.8%
Taylor expanded in t around inf 74.1%
Taylor expanded in a around inf 53.9%
*-commutative53.9%
Simplified53.9%
Taylor expanded in z around 0 51.7%
Final simplification53.2%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.26e+39) (* t b) (if (<= b 2.9e+46) x (* t b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.26e+39) {
tmp = t * b;
} else if (b <= 2.9e+46) {
tmp = x;
} 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 (b <= (-1.26d+39)) then
tmp = t * b
else if (b <= 2.9d+46) then
tmp = x
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 (b <= -1.26e+39) {
tmp = t * b;
} else if (b <= 2.9e+46) {
tmp = x;
} else {
tmp = t * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.26e+39: tmp = t * b elif b <= 2.9e+46: tmp = x else: tmp = t * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.26e+39) tmp = Float64(t * b); elseif (b <= 2.9e+46) tmp = x; else tmp = Float64(t * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.26e+39) tmp = t * b; elseif (b <= 2.9e+46) tmp = x; else tmp = t * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.26e+39], N[(t * b), $MachinePrecision], If[LessEqual[b, 2.9e+46], x, N[(t * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.26 \cdot 10^{+39}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq 2.9 \cdot 10^{+46}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t \cdot b\\
\end{array}
\end{array}
if b < -1.26000000000000001e39 or 2.9000000000000002e46 < 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 t around inf 59.9%
Taylor expanded in b around inf 33.2%
if -1.26000000000000001e39 < b < 2.9000000000000002e46Initial program 99.3%
associate-+l-99.3%
*-commutative99.3%
*-commutative99.3%
sub-neg99.3%
metadata-eval99.3%
remove-double-neg99.3%
remove-double-neg99.3%
sub-neg99.3%
metadata-eval99.3%
associate--l+99.3%
Simplified99.3%
Taylor expanded in x around inf 26.5%
Final simplification29.5%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.8e+39) (* t b) (if (<= b 2.85e+134) (+ z x) (* t b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.8e+39) {
tmp = t * b;
} else if (b <= 2.85e+134) {
tmp = z + x;
} 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 (b <= (-1.8d+39)) then
tmp = t * b
else if (b <= 2.85d+134) then
tmp = z + x
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 (b <= -1.8e+39) {
tmp = t * b;
} else if (b <= 2.85e+134) {
tmp = z + x;
} else {
tmp = t * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.8e+39: tmp = t * b elif b <= 2.85e+134: tmp = z + x else: tmp = t * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.8e+39) tmp = Float64(t * b); elseif (b <= 2.85e+134) tmp = Float64(z + x); else tmp = Float64(t * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.8e+39) tmp = t * b; elseif (b <= 2.85e+134) tmp = z + x; else tmp = t * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.8e+39], N[(t * b), $MachinePrecision], If[LessEqual[b, 2.85e+134], N[(z + x), $MachinePrecision], N[(t * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.8 \cdot 10^{+39}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq 2.85 \cdot 10^{+134}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t \cdot b\\
\end{array}
\end{array}
if b < -1.79999999999999992e39 or 2.85000000000000019e134 < b Initial program 90.4%
associate-+l-90.4%
*-commutative90.4%
*-commutative90.4%
sub-neg90.4%
metadata-eval90.4%
remove-double-neg90.4%
remove-double-neg90.4%
sub-neg90.4%
metadata-eval90.4%
associate--l+90.4%
Simplified90.4%
Taylor expanded in t around inf 57.0%
Taylor expanded in b around inf 36.4%
if -1.79999999999999992e39 < b < 2.85000000000000019e134Initial 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 y around inf 63.7%
mul-1-neg63.7%
distribute-rgt-neg-in63.7%
Simplified63.7%
Taylor expanded in y around 0 36.8%
sub-neg36.8%
neg-mul-136.8%
remove-double-neg36.8%
+-commutative36.8%
Simplified36.8%
Final simplification36.7%
(FPCore (x y z t a b) :precision binary64 (if (<= x -5.0) x (if (<= x 7.5e+18) a x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -5.0) {
tmp = x;
} else if (x <= 7.5e+18) {
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 <= (-5.0d0)) then
tmp = x
else if (x <= 7.5d+18) 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 <= -5.0) {
tmp = x;
} else if (x <= 7.5e+18) {
tmp = a;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -5.0: tmp = x elif x <= 7.5e+18: tmp = a else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -5.0) tmp = x; elseif (x <= 7.5e+18) tmp = a; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -5.0) tmp = x; elseif (x <= 7.5e+18) tmp = a; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -5.0], x, If[LessEqual[x, 7.5e+18], a, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 7.5 \cdot 10^{+18}:\\
\;\;\;\;a\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -5 or 7.5e18 < x Initial program 95.6%
associate-+l-95.6%
*-commutative95.6%
*-commutative95.6%
sub-neg95.6%
metadata-eval95.6%
remove-double-neg95.6%
remove-double-neg95.6%
sub-neg95.6%
metadata-eval95.6%
associate--l+95.6%
Simplified95.6%
Taylor expanded in x around inf 30.5%
if -5 < x < 7.5e18Initial 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 29.8%
Taylor expanded in t around 0 15.5%
Final simplification23.6%
(FPCore (x y z t a b) :precision binary64 (if (<= z -3.8e-36) z (if (<= z 1.05e+108) x z)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= -3.8e-36) {
tmp = z;
} else if (z <= 1.05e+108) {
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 <= (-3.8d-36)) then
tmp = z
else if (z <= 1.05d+108) 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 <= -3.8e-36) {
tmp = z;
} else if (z <= 1.05e+108) {
tmp = x;
} else {
tmp = z;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if z <= -3.8e-36: tmp = z elif z <= 1.05e+108: tmp = x else: tmp = z return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (z <= -3.8e-36) tmp = z; elseif (z <= 1.05e+108) tmp = x; else tmp = z; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (z <= -3.8e-36) tmp = z; elseif (z <= 1.05e+108) tmp = x; else tmp = z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -3.8e-36], z, If[LessEqual[z, 1.05e+108], x, z]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.8 \cdot 10^{-36}:\\
\;\;\;\;z\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{+108}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;z\\
\end{array}
\end{array}
if z < -3.79999999999999971e-36 or 1.05000000000000005e108 < z Initial program 91.3%
associate-+l-91.3%
*-commutative91.3%
*-commutative91.3%
sub-neg91.3%
metadata-eval91.3%
remove-double-neg91.3%
remove-double-neg91.3%
sub-neg91.3%
metadata-eval91.3%
associate--l+91.3%
Simplified91.3%
Taylor expanded in z around inf 56.5%
sub-neg56.5%
neg-mul-156.5%
distribute-rgt-in56.5%
*-lft-identity56.5%
associate-*r*56.5%
mul-1-neg56.5%
unsub-neg56.5%
Simplified56.5%
Taylor expanded in y around 0 20.3%
if -3.79999999999999971e-36 < z < 1.05000000000000005e108Initial 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 x around inf 27.1%
Final simplification24.1%
(FPCore (x y z t a b) :precision binary64 a)
double code(double x, double y, double z, double t, double a, double b) {
return a;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return a;
}
def code(x, y, z, t, a, b): return a
function code(x, y, z, t, a, b) return a end
function tmp = code(x, y, z, t, a, b) tmp = a; end
code[x_, y_, z_, t_, a_, b_] := a
\begin{array}{l}
\\
a
\end{array}
Initial program 94.9%
associate-+l-94.9%
*-commutative94.9%
*-commutative94.9%
sub-neg94.9%
metadata-eval94.9%
remove-double-neg94.9%
remove-double-neg94.9%
sub-neg94.9%
metadata-eval94.9%
associate--l+94.9%
Simplified94.9%
Taylor expanded in a around inf 26.0%
Taylor expanded in t around 0 11.0%
Final simplification11.0%
herbie shell --seed 2023185
(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)))