
(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 26 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 (* a (+ t -1.0))) (t_2 (+ x (* z (- 1.0 y)))))
(if (<= (+ (- t_2 t_1) (* b (- (+ t y) 2.0))) INFINITY)
(- (fma z (- 1.0 y) x) (- t_1 (* b (+ y (- t 2.0)))))
(+ t_2 (* t (- b a))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (t + -1.0);
double t_2 = x + (z * (1.0 - y));
double tmp;
if (((t_2 - t_1) + (b * ((t + y) - 2.0))) <= ((double) INFINITY)) {
tmp = fma(z, (1.0 - y), x) - (t_1 - (b * (y + (t - 2.0))));
} else {
tmp = t_2 + (t * (b - a));
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(t + -1.0)) t_2 = Float64(x + Float64(z * Float64(1.0 - y))) tmp = 0.0 if (Float64(Float64(t_2 - t_1) + Float64(b * Float64(Float64(t + y) - 2.0))) <= Inf) tmp = Float64(fma(z, Float64(1.0 - y), x) - Float64(t_1 - Float64(b * Float64(y + Float64(t - 2.0))))); else tmp = Float64(t_2 + Float64(t * Float64(b - a))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$2 - t$95$1), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision] - N[(t$95$1 - N[(b * N[(y + N[(t - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$2 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(t + -1\right)\\
t_2 := x + z \cdot \left(1 - y\right)\\
\mathbf{if}\;\left(t_2 - t_1\right) + b \cdot \left(\left(t + y\right) - 2\right) \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(z, 1 - y, x\right) - \left(t_1 - b \cdot \left(y + \left(t - 2\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t_2 + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) < +inf.0Initial program 100.0%
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 x around 0 100.0%
fma-def100.0%
sub-neg100.0%
metadata-eval100.0%
*-commutative100.0%
fma-def100.0%
neg-mul-1100.0%
distribute-lft-neg-in100.0%
*-commutative100.0%
fma-def100.0%
neg-sub0100.0%
+-commutative100.0%
associate--r+100.0%
metadata-eval100.0%
Simplified100.0%
if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) Initial program 0.0%
associate-+l-0.0%
*-commutative0.0%
*-commutative0.0%
sub-neg0.0%
metadata-eval0.0%
remove-double-neg0.0%
remove-double-neg0.0%
sub-neg0.0%
metadata-eval0.0%
associate--l+0.0%
Simplified0.0%
Taylor expanded in t around inf 87.5%
Final simplification99.6%
(FPCore (x y z t a b) :precision binary64 (fma a (- 1.0 t) (fma (+ y (+ t -2.0)) b (fma z (- 1.0 y) x))))
double code(double x, double y, double z, double t, double a, double b) {
return fma(a, (1.0 - t), fma((y + (t + -2.0)), b, fma(z, (1.0 - y), x)));
}
function code(x, y, z, t, a, b) return fma(a, Float64(1.0 - t), fma(Float64(y + Float64(t + -2.0)), b, fma(z, Float64(1.0 - y), x))) end
code[x_, y_, z_, t_, a_, b_] := N[(a * N[(1.0 - t), $MachinePrecision] + N[(N[(y + N[(t + -2.0), $MachinePrecision]), $MachinePrecision] * b + N[(z * N[(1.0 - y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(a, 1 - t, \mathsf{fma}\left(y + \left(t + -2\right), b, \mathsf{fma}\left(z, 1 - y, x\right)\right)\right)
\end{array}
Initial program 96.9%
sub-neg96.9%
+-commutative96.9%
associate-+l+96.9%
*-commutative96.9%
distribute-rgt-neg-in96.9%
+-commutative96.9%
fma-def97.6%
neg-sub097.6%
associate--r-97.6%
neg-sub097.6%
+-commutative97.6%
sub-neg97.6%
fma-def99.2%
sub-neg99.2%
associate-+l+99.2%
metadata-eval99.2%
sub-neg99.2%
+-commutative99.2%
Simplified99.2%
Final simplification99.2%
(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 96.9%
+-commutative96.9%
fma-def98.8%
+-commutative98.8%
associate--l+98.8%
sub-neg98.8%
associate-+l-98.8%
fma-neg99.2%
sub-neg99.2%
metadata-eval99.2%
distribute-lft-neg-in99.2%
distribute-lft-neg-in99.2%
remove-double-neg99.2%
sub-neg99.2%
metadata-eval99.2%
Simplified99.2%
Final simplification99.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y))))
(t_2 (+ (- t_1 (* a (+ t -1.0))) (* b (- (+ t y) 2.0)))))
(if (<= t_2 INFINITY) t_2 (+ t_1 (* t (- b a))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = (t_1 - (a * (t + -1.0))) + (b * ((t + y) - 2.0));
double tmp;
if (t_2 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = t_1 + (t * (b - a));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = (t_1 - (a * (t + -1.0))) + (b * ((t + y) - 2.0));
double tmp;
if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = t_2;
} else {
tmp = t_1 + (t * (b - a));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = (t_1 - (a * (t + -1.0))) + (b * ((t + y) - 2.0)) tmp = 0 if t_2 <= math.inf: tmp = t_2 else: tmp = t_1 + (t * (b - a)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z * Float64(1.0 - y))) t_2 = Float64(Float64(t_1 - Float64(a * Float64(t + -1.0))) + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (t_2 <= Inf) tmp = t_2; else tmp = Float64(t_1 + Float64(t * Float64(b - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z * (1.0 - y)); t_2 = (t_1 - (a * (t + -1.0))) + (b * ((t + y) - 2.0)); tmp = 0.0; if (t_2 <= Inf) tmp = t_2; else tmp = t_1 + (t * (b - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t$95$1 - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, Infinity], t$95$2, N[(t$95$1 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := \left(t_1 - a \cdot \left(t + -1\right)\right) + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;t_2 \leq \infty:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1 + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) < +inf.0Initial program 100.0%
if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) Initial program 0.0%
associate-+l-0.0%
*-commutative0.0%
*-commutative0.0%
sub-neg0.0%
metadata-eval0.0%
remove-double-neg0.0%
remove-double-neg0.0%
sub-neg0.0%
metadata-eval0.0%
associate--l+0.0%
Simplified0.0%
Taylor expanded in t around inf 87.5%
Final simplification99.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* b (- (+ t y) 2.0))) (t_2 (* a (- 1.0 t))))
(if (<= b -1.3e+74)
t_1
(if (<= b -2.2e-64)
(* t (- b a))
(if (<= b -7e-85)
(+ z x)
(if (<= b -3e-115)
t_2
(if (<= b -7.2e-252)
(- z (* y z))
(if (<= b 4.8e-154)
t_2
(if (<= b 5.5e-38)
(- x (* y z))
(if (<= b 2.3e+36) t_2 t_1))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = b * ((t + y) - 2.0);
double t_2 = a * (1.0 - t);
double tmp;
if (b <= -1.3e+74) {
tmp = t_1;
} else if (b <= -2.2e-64) {
tmp = t * (b - a);
} else if (b <= -7e-85) {
tmp = z + x;
} else if (b <= -3e-115) {
tmp = t_2;
} else if (b <= -7.2e-252) {
tmp = z - (y * z);
} else if (b <= 4.8e-154) {
tmp = t_2;
} else if (b <= 5.5e-38) {
tmp = x - (y * z);
} else if (b <= 2.3e+36) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = b * ((t + y) - 2.0d0)
t_2 = a * (1.0d0 - t)
if (b <= (-1.3d+74)) then
tmp = t_1
else if (b <= (-2.2d-64)) then
tmp = t * (b - a)
else if (b <= (-7d-85)) then
tmp = z + x
else if (b <= (-3d-115)) then
tmp = t_2
else if (b <= (-7.2d-252)) then
tmp = z - (y * z)
else if (b <= 4.8d-154) then
tmp = t_2
else if (b <= 5.5d-38) then
tmp = x - (y * z)
else if (b <= 2.3d+36) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = b * ((t + y) - 2.0);
double t_2 = a * (1.0 - t);
double tmp;
if (b <= -1.3e+74) {
tmp = t_1;
} else if (b <= -2.2e-64) {
tmp = t * (b - a);
} else if (b <= -7e-85) {
tmp = z + x;
} else if (b <= -3e-115) {
tmp = t_2;
} else if (b <= -7.2e-252) {
tmp = z - (y * z);
} else if (b <= 4.8e-154) {
tmp = t_2;
} else if (b <= 5.5e-38) {
tmp = x - (y * z);
} else if (b <= 2.3e+36) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = b * ((t + y) - 2.0) t_2 = a * (1.0 - t) tmp = 0 if b <= -1.3e+74: tmp = t_1 elif b <= -2.2e-64: tmp = t * (b - a) elif b <= -7e-85: tmp = z + x elif b <= -3e-115: tmp = t_2 elif b <= -7.2e-252: tmp = z - (y * z) elif b <= 4.8e-154: tmp = t_2 elif b <= 5.5e-38: tmp = x - (y * z) elif b <= 2.3e+36: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(b * Float64(Float64(t + y) - 2.0)) t_2 = Float64(a * Float64(1.0 - t)) tmp = 0.0 if (b <= -1.3e+74) tmp = t_1; elseif (b <= -2.2e-64) tmp = Float64(t * Float64(b - a)); elseif (b <= -7e-85) tmp = Float64(z + x); elseif (b <= -3e-115) tmp = t_2; elseif (b <= -7.2e-252) tmp = Float64(z - Float64(y * z)); elseif (b <= 4.8e-154) tmp = t_2; elseif (b <= 5.5e-38) tmp = Float64(x - Float64(y * z)); elseif (b <= 2.3e+36) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = b * ((t + y) - 2.0); t_2 = a * (1.0 - t); tmp = 0.0; if (b <= -1.3e+74) tmp = t_1; elseif (b <= -2.2e-64) tmp = t * (b - a); elseif (b <= -7e-85) tmp = z + x; elseif (b <= -3e-115) tmp = t_2; elseif (b <= -7.2e-252) tmp = z - (y * z); elseif (b <= 4.8e-154) tmp = t_2; elseif (b <= 5.5e-38) tmp = x - (y * z); elseif (b <= 2.3e+36) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.3e+74], t$95$1, If[LessEqual[b, -2.2e-64], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -7e-85], N[(z + x), $MachinePrecision], If[LessEqual[b, -3e-115], t$95$2, If[LessEqual[b, -7.2e-252], N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.8e-154], t$95$2, If[LessEqual[b, 5.5e-38], N[(x - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.3e+36], t$95$2, t$95$1]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(\left(t + y\right) - 2\right)\\
t_2 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;b \leq -1.3 \cdot 10^{+74}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -2.2 \cdot 10^{-64}:\\
\;\;\;\;t \cdot \left(b - a\right)\\
\mathbf{elif}\;b \leq -7 \cdot 10^{-85}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;b \leq -3 \cdot 10^{-115}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -7.2 \cdot 10^{-252}:\\
\;\;\;\;z - y \cdot z\\
\mathbf{elif}\;b \leq 4.8 \cdot 10^{-154}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq 5.5 \cdot 10^{-38}:\\
\;\;\;\;x - y \cdot z\\
\mathbf{elif}\;b \leq 2.3 \cdot 10^{+36}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if b < -1.3e74 or 2.29999999999999996e36 < b Initial program 93.2%
associate-+l-93.2%
*-commutative93.2%
*-commutative93.2%
sub-neg93.2%
metadata-eval93.2%
remove-double-neg93.2%
remove-double-neg93.2%
sub-neg93.2%
metadata-eval93.2%
associate--l+93.2%
Simplified93.2%
Taylor expanded in b around inf 69.8%
if -1.3e74 < b < -2.2e-64Initial program 95.9%
associate-+l-95.9%
*-commutative95.9%
*-commutative95.9%
sub-neg95.9%
metadata-eval95.9%
remove-double-neg95.9%
remove-double-neg95.9%
sub-neg95.9%
metadata-eval95.9%
associate--l+95.9%
Simplified95.9%
Taylor expanded in t around inf 55.0%
if -2.2e-64 < b < -6.99999999999999956e-85Initial program 99.8%
associate-+l-99.8%
*-commutative99.8%
*-commutative99.8%
sub-neg99.8%
metadata-eval99.8%
remove-double-neg99.8%
remove-double-neg99.8%
sub-neg99.8%
metadata-eval99.8%
associate--l+99.8%
Simplified99.8%
Taylor expanded in t around inf 85.8%
Taylor expanded in t around 0 78.9%
Taylor expanded in y around 0 64.8%
cancel-sign-sub-inv64.8%
metadata-eval64.8%
*-lft-identity64.8%
Simplified64.8%
if -6.99999999999999956e-85 < b < -3.0000000000000002e-115 or -7.20000000000000046e-252 < b < 4.79999999999999974e-154 or 5.50000000000000005e-38 < b < 2.29999999999999996e36Initial 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 58.6%
if -3.0000000000000002e-115 < b < -7.20000000000000046e-252Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around inf 53.1%
metadata-eval53.1%
associate--r+53.1%
+-commutative53.1%
neg-sub053.1%
distribute-rgt-neg-in53.1%
*-commutative53.1%
neg-sub053.1%
*-commutative53.1%
distribute-rgt-out53.1%
+-commutative53.1%
associate--r+53.1%
neg-sub053.1%
neg-mul-153.1%
remove-double-neg53.1%
Simplified53.1%
if 4.79999999999999974e-154 < b < 5.50000000000000005e-38Initial 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 88.1%
Taylor expanded in t around 0 72.3%
Taylor expanded in y around inf 64.3%
Final simplification63.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ x (* b (- (+ t y) 2.0))) (* a (- 1.0 t))))
(t_2 (+ x (* z (- 1.0 y)))))
(if (<= b -1.18e+156)
t_1
(if (<= b -1.85)
(+ t_2 (* t (- b a)))
(if (or (<= b -1.15e-51) (not (<= b 3.9e+37)))
t_1
(+ t_2 (- a (* a t))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t));
double t_2 = x + (z * (1.0 - y));
double tmp;
if (b <= -1.18e+156) {
tmp = t_1;
} else if (b <= -1.85) {
tmp = t_2 + (t * (b - a));
} else if ((b <= -1.15e-51) || !(b <= 3.9e+37)) {
tmp = t_1;
} else {
tmp = t_2 + (a - (a * t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x + (b * ((t + y) - 2.0d0))) + (a * (1.0d0 - t))
t_2 = x + (z * (1.0d0 - y))
if (b <= (-1.18d+156)) then
tmp = t_1
else if (b <= (-1.85d0)) then
tmp = t_2 + (t * (b - a))
else if ((b <= (-1.15d-51)) .or. (.not. (b <= 3.9d+37))) then
tmp = t_1
else
tmp = t_2 + (a - (a * t))
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 + (b * ((t + y) - 2.0))) + (a * (1.0 - t));
double t_2 = x + (z * (1.0 - y));
double tmp;
if (b <= -1.18e+156) {
tmp = t_1;
} else if (b <= -1.85) {
tmp = t_2 + (t * (b - a));
} else if ((b <= -1.15e-51) || !(b <= 3.9e+37)) {
tmp = t_1;
} else {
tmp = t_2 + (a - (a * t));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t)) t_2 = x + (z * (1.0 - y)) tmp = 0 if b <= -1.18e+156: tmp = t_1 elif b <= -1.85: tmp = t_2 + (t * (b - a)) elif (b <= -1.15e-51) or not (b <= 3.9e+37): tmp = t_1 else: tmp = t_2 + (a - (a * t)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + Float64(b * Float64(Float64(t + y) - 2.0))) + Float64(a * Float64(1.0 - t))) t_2 = Float64(x + Float64(z * Float64(1.0 - y))) tmp = 0.0 if (b <= -1.18e+156) tmp = t_1; elseif (b <= -1.85) tmp = Float64(t_2 + Float64(t * Float64(b - a))); elseif ((b <= -1.15e-51) || !(b <= 3.9e+37)) tmp = t_1; else tmp = Float64(t_2 + Float64(a - Float64(a * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t)); t_2 = x + (z * (1.0 - y)); tmp = 0.0; if (b <= -1.18e+156) tmp = t_1; elseif (b <= -1.85) tmp = t_2 + (t * (b - a)); elseif ((b <= -1.15e-51) || ~((b <= 3.9e+37))) tmp = t_1; else tmp = t_2 + (a - (a * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.18e+156], t$95$1, If[LessEqual[b, -1.85], N[(t$95$2 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[b, -1.15e-51], N[Not[LessEqual[b, 3.9e+37]], $MachinePrecision]], t$95$1, N[(t$95$2 + N[(a - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + b \cdot \left(\left(t + y\right) - 2\right)\right) + a \cdot \left(1 - t\right)\\
t_2 := x + z \cdot \left(1 - y\right)\\
\mathbf{if}\;b \leq -1.18 \cdot 10^{+156}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -1.85:\\
\;\;\;\;t_2 + t \cdot \left(b - a\right)\\
\mathbf{elif}\;b \leq -1.15 \cdot 10^{-51} \lor \neg \left(b \leq 3.9 \cdot 10^{+37}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2 + \left(a - a \cdot t\right)\\
\end{array}
\end{array}
if b < -1.18e156 or -1.8500000000000001 < b < -1.15000000000000001e-51 or 3.8999999999999999e37 < b Initial program 94.5%
associate-+l-94.5%
*-commutative94.5%
*-commutative94.5%
sub-neg94.5%
metadata-eval94.5%
remove-double-neg94.5%
remove-double-neg94.5%
sub-neg94.5%
metadata-eval94.5%
associate--l+94.5%
Simplified94.5%
Taylor expanded in z around 0 86.9%
if -1.18e156 < b < -1.8500000000000001Initial 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 t around inf 88.5%
if -1.15000000000000001e-51 < b < 3.8999999999999999e37Initial 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 a around inf 96.7%
sub-neg96.7%
metadata-eval96.7%
+-commutative96.7%
*-commutative96.7%
+-commutative96.7%
distribute-lft-in96.7%
*-commutative96.7%
mul-1-neg96.7%
unsub-neg96.7%
*-commutative96.7%
Simplified96.7%
Final simplification92.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- z))) (t_2 (* t (- b a))))
(if (<= t -4.2e+25)
t_2
(if (<= t -2.5e-277)
(+ z x)
(if (<= t 1.1e-299)
t_1
(if (<= t 1.18e-257)
(+ z x)
(if (<= t 2.3e-127)
t_1
(if (<= t 2.4e-97)
(+ z x)
(if (<= t 1.92e+28)
(* a (- 1.0 t))
(if (<= t 1.25e+89) (+ z x) t_2))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * -z;
double t_2 = t * (b - a);
double tmp;
if (t <= -4.2e+25) {
tmp = t_2;
} else if (t <= -2.5e-277) {
tmp = z + x;
} else if (t <= 1.1e-299) {
tmp = t_1;
} else if (t <= 1.18e-257) {
tmp = z + x;
} else if (t <= 2.3e-127) {
tmp = t_1;
} else if (t <= 2.4e-97) {
tmp = z + x;
} else if (t <= 1.92e+28) {
tmp = a * (1.0 - t);
} else if (t <= 1.25e+89) {
tmp = z + x;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y * -z
t_2 = t * (b - a)
if (t <= (-4.2d+25)) then
tmp = t_2
else if (t <= (-2.5d-277)) then
tmp = z + x
else if (t <= 1.1d-299) then
tmp = t_1
else if (t <= 1.18d-257) then
tmp = z + x
else if (t <= 2.3d-127) then
tmp = t_1
else if (t <= 2.4d-97) then
tmp = z + x
else if (t <= 1.92d+28) then
tmp = a * (1.0d0 - t)
else if (t <= 1.25d+89) then
tmp = z + x
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * -z;
double t_2 = t * (b - a);
double tmp;
if (t <= -4.2e+25) {
tmp = t_2;
} else if (t <= -2.5e-277) {
tmp = z + x;
} else if (t <= 1.1e-299) {
tmp = t_1;
} else if (t <= 1.18e-257) {
tmp = z + x;
} else if (t <= 2.3e-127) {
tmp = t_1;
} else if (t <= 2.4e-97) {
tmp = z + x;
} else if (t <= 1.92e+28) {
tmp = a * (1.0 - t);
} else if (t <= 1.25e+89) {
tmp = z + x;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * -z t_2 = t * (b - a) tmp = 0 if t <= -4.2e+25: tmp = t_2 elif t <= -2.5e-277: tmp = z + x elif t <= 1.1e-299: tmp = t_1 elif t <= 1.18e-257: tmp = z + x elif t <= 2.3e-127: tmp = t_1 elif t <= 2.4e-97: tmp = z + x elif t <= 1.92e+28: tmp = a * (1.0 - t) elif t <= 1.25e+89: tmp = z + x else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(-z)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -4.2e+25) tmp = t_2; elseif (t <= -2.5e-277) tmp = Float64(z + x); elseif (t <= 1.1e-299) tmp = t_1; elseif (t <= 1.18e-257) tmp = Float64(z + x); elseif (t <= 2.3e-127) tmp = t_1; elseif (t <= 2.4e-97) tmp = Float64(z + x); elseif (t <= 1.92e+28) tmp = Float64(a * Float64(1.0 - t)); elseif (t <= 1.25e+89) tmp = Float64(z + x); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * -z; t_2 = t * (b - a); tmp = 0.0; if (t <= -4.2e+25) tmp = t_2; elseif (t <= -2.5e-277) tmp = z + x; elseif (t <= 1.1e-299) tmp = t_1; elseif (t <= 1.18e-257) tmp = z + x; elseif (t <= 2.3e-127) tmp = t_1; elseif (t <= 2.4e-97) tmp = z + x; elseif (t <= 1.92e+28) tmp = a * (1.0 - t); elseif (t <= 1.25e+89) tmp = z + x; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * (-z)), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.2e+25], t$95$2, If[LessEqual[t, -2.5e-277], N[(z + x), $MachinePrecision], If[LessEqual[t, 1.1e-299], t$95$1, If[LessEqual[t, 1.18e-257], N[(z + x), $MachinePrecision], If[LessEqual[t, 2.3e-127], t$95$1, If[LessEqual[t, 2.4e-97], N[(z + x), $MachinePrecision], If[LessEqual[t, 1.92e+28], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e+89], N[(z + x), $MachinePrecision], t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(-z\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -4.2 \cdot 10^{+25}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -2.5 \cdot 10^{-277}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 1.1 \cdot 10^{-299}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.18 \cdot 10^{-257}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 2.3 \cdot 10^{-127}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-97}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 1.92 \cdot 10^{+28}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{+89}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -4.1999999999999998e25 or 1.24999999999999996e89 < t Initial program 94.1%
associate-+l-94.1%
*-commutative94.1%
*-commutative94.1%
sub-neg94.1%
metadata-eval94.1%
remove-double-neg94.1%
remove-double-neg94.1%
sub-neg94.1%
metadata-eval94.1%
associate--l+94.1%
Simplified94.1%
Taylor expanded in t around inf 70.9%
if -4.1999999999999998e25 < t < -2.5e-277 or 1.1e-299 < t < 1.1799999999999999e-257 or 2.30000000000000019e-127 < t < 2.4e-97 or 1.91999999999999998e28 < t < 1.24999999999999996e89Initial program 98.8%
associate-+l-98.8%
*-commutative98.8%
*-commutative98.8%
sub-neg98.8%
metadata-eval98.8%
remove-double-neg98.8%
remove-double-neg98.8%
sub-neg98.8%
metadata-eval98.8%
associate--l+98.8%
Simplified98.8%
Taylor expanded in t around inf 58.8%
Taylor expanded in t around 0 54.3%
Taylor expanded in y around 0 41.3%
cancel-sign-sub-inv41.3%
metadata-eval41.3%
*-lft-identity41.3%
Simplified41.3%
if -2.5e-277 < t < 1.1e-299 or 1.1799999999999999e-257 < t < 2.30000000000000019e-127Initial 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 y around inf 61.5%
Taylor expanded in b around 0 45.7%
mul-1-neg45.7%
distribute-rgt-neg-in45.7%
Simplified45.7%
if 2.4e-97 < t < 1.91999999999999998e28Initial 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 54.6%
Final simplification56.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (- a (* a t))))
(t_2 (+ x (* b (- (+ t y) 2.0))))
(t_3 (+ x (* z (- 1.0 y)))))
(if (<= b -7.5e+74)
t_2
(if (<= b -2.85e-69)
(+ x (* t (- b a)))
(if (<= b -4.4e-219)
t_3
(if (<= b 1.7e-178)
t_1
(if (<= b 1.7e-44) t_3 (if (<= b 9e+32) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a - (a * t));
double t_2 = x + (b * ((t + y) - 2.0));
double t_3 = x + (z * (1.0 - y));
double tmp;
if (b <= -7.5e+74) {
tmp = t_2;
} else if (b <= -2.85e-69) {
tmp = x + (t * (b - a));
} else if (b <= -4.4e-219) {
tmp = t_3;
} else if (b <= 1.7e-178) {
tmp = t_1;
} else if (b <= 1.7e-44) {
tmp = t_3;
} else if (b <= 9e+32) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (a - (a * t))
t_2 = x + (b * ((t + y) - 2.0d0))
t_3 = x + (z * (1.0d0 - y))
if (b <= (-7.5d+74)) then
tmp = t_2
else if (b <= (-2.85d-69)) then
tmp = x + (t * (b - a))
else if (b <= (-4.4d-219)) then
tmp = t_3
else if (b <= 1.7d-178) then
tmp = t_1
else if (b <= 1.7d-44) then
tmp = t_3
else if (b <= 9d+32) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a - (a * t));
double t_2 = x + (b * ((t + y) - 2.0));
double t_3 = x + (z * (1.0 - y));
double tmp;
if (b <= -7.5e+74) {
tmp = t_2;
} else if (b <= -2.85e-69) {
tmp = x + (t * (b - a));
} else if (b <= -4.4e-219) {
tmp = t_3;
} else if (b <= 1.7e-178) {
tmp = t_1;
} else if (b <= 1.7e-44) {
tmp = t_3;
} else if (b <= 9e+32) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (a - (a * t)) t_2 = x + (b * ((t + y) - 2.0)) t_3 = x + (z * (1.0 - y)) tmp = 0 if b <= -7.5e+74: tmp = t_2 elif b <= -2.85e-69: tmp = x + (t * (b - a)) elif b <= -4.4e-219: tmp = t_3 elif b <= 1.7e-178: tmp = t_1 elif b <= 1.7e-44: tmp = t_3 elif b <= 9e+32: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(a - Float64(a * t))) t_2 = Float64(x + Float64(b * Float64(Float64(t + y) - 2.0))) t_3 = Float64(x + Float64(z * Float64(1.0 - y))) tmp = 0.0 if (b <= -7.5e+74) tmp = t_2; elseif (b <= -2.85e-69) tmp = Float64(x + Float64(t * Float64(b - a))); elseif (b <= -4.4e-219) tmp = t_3; elseif (b <= 1.7e-178) tmp = t_1; elseif (b <= 1.7e-44) tmp = t_3; elseif (b <= 9e+32) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (a - (a * t)); t_2 = x + (b * ((t + y) - 2.0)); t_3 = x + (z * (1.0 - y)); tmp = 0.0; if (b <= -7.5e+74) tmp = t_2; elseif (b <= -2.85e-69) tmp = x + (t * (b - a)); elseif (b <= -4.4e-219) tmp = t_3; elseif (b <= 1.7e-178) tmp = t_1; elseif (b <= 1.7e-44) tmp = t_3; elseif (b <= 9e+32) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.5e+74], t$95$2, If[LessEqual[b, -2.85e-69], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -4.4e-219], t$95$3, If[LessEqual[b, 1.7e-178], t$95$1, If[LessEqual[b, 1.7e-44], t$95$3, If[LessEqual[b, 9e+32], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(a - a \cdot t\right)\\
t_2 := x + b \cdot \left(\left(t + y\right) - 2\right)\\
t_3 := x + z \cdot \left(1 - y\right)\\
\mathbf{if}\;b \leq -7.5 \cdot 10^{+74}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -2.85 \cdot 10^{-69}:\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\mathbf{elif}\;b \leq -4.4 \cdot 10^{-219}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 1.7 \cdot 10^{-178}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 1.7 \cdot 10^{-44}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 9 \cdot 10^{+32}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -7.5e74 or 9.0000000000000007e32 < b Initial program 93.2%
associate-+l-93.2%
*-commutative93.2%
*-commutative93.2%
sub-neg93.2%
metadata-eval93.2%
remove-double-neg93.2%
remove-double-neg93.2%
sub-neg93.2%
metadata-eval93.2%
associate--l+93.2%
Simplified93.2%
Taylor expanded in z around 0 82.4%
Taylor expanded in a around 0 77.5%
if -7.5e74 < b < -2.85e-69Initial 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 inf 87.9%
Taylor expanded in z around 0 76.2%
if -2.85e-69 < b < -4.3999999999999999e-219 or 1.69999999999999986e-178 < b < 1.70000000000000008e-44Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 81.7%
Taylor expanded in t around 0 66.1%
if -4.3999999999999999e-219 < b < 1.69999999999999986e-178 or 1.70000000000000008e-44 < b < 9.0000000000000007e32Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around 0 76.4%
Taylor expanded in b around 0 75.0%
sub-neg75.0%
metadata-eval75.0%
*-commutative75.0%
distribute-lft-out75.0%
*-commutative75.0%
neg-mul-175.0%
unsub-neg75.0%
*-commutative75.0%
Simplified75.0%
Final simplification74.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ a (+ x (* b (- y 2.0)))))
(t_2 (+ x (* z (- 1.0 y))))
(t_3 (+ t_2 (* t (- b a)))))
(if (<= t -2.8e-38)
t_3
(if (<= t -5.4e-243)
t_1
(if (<= t 4.8e-87) (+ t_2 (* y b)) (if (<= t 0.0003) 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 = x + (z * (1.0 - y));
double t_3 = t_2 + (t * (b - a));
double tmp;
if (t <= -2.8e-38) {
tmp = t_3;
} else if (t <= -5.4e-243) {
tmp = t_1;
} else if (t <= 4.8e-87) {
tmp = t_2 + (y * b);
} else if (t <= 0.0003) {
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 = x + (z * (1.0d0 - y))
t_3 = t_2 + (t * (b - a))
if (t <= (-2.8d-38)) then
tmp = t_3
else if (t <= (-5.4d-243)) then
tmp = t_1
else if (t <= 4.8d-87) then
tmp = t_2 + (y * b)
else if (t <= 0.0003d0) 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 = x + (z * (1.0 - y));
double t_3 = t_2 + (t * (b - a));
double tmp;
if (t <= -2.8e-38) {
tmp = t_3;
} else if (t <= -5.4e-243) {
tmp = t_1;
} else if (t <= 4.8e-87) {
tmp = t_2 + (y * b);
} else if (t <= 0.0003) {
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 = x + (z * (1.0 - y)) t_3 = t_2 + (t * (b - a)) tmp = 0 if t <= -2.8e-38: tmp = t_3 elif t <= -5.4e-243: tmp = t_1 elif t <= 4.8e-87: tmp = t_2 + (y * b) elif t <= 0.0003: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a + Float64(x + Float64(b * Float64(y - 2.0)))) t_2 = Float64(x + Float64(z * Float64(1.0 - y))) t_3 = Float64(t_2 + Float64(t * Float64(b - a))) tmp = 0.0 if (t <= -2.8e-38) tmp = t_3; elseif (t <= -5.4e-243) tmp = t_1; elseif (t <= 4.8e-87) tmp = Float64(t_2 + Float64(y * b)); elseif (t <= 0.0003) 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 = x + (z * (1.0 - y)); t_3 = t_2 + (t * (b - a)); tmp = 0.0; if (t <= -2.8e-38) tmp = t_3; elseif (t <= -5.4e-243) tmp = t_1; elseif (t <= 4.8e-87) tmp = t_2 + (y * b); elseif (t <= 0.0003) tmp = t_1; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a + N[(x + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.8e-38], t$95$3, If[LessEqual[t, -5.4e-243], t$95$1, If[LessEqual[t, 4.8e-87], N[(t$95$2 + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 0.0003], t$95$1, t$95$3]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + \left(x + b \cdot \left(y - 2\right)\right)\\
t_2 := x + z \cdot \left(1 - y\right)\\
t_3 := t_2 + t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.8 \cdot 10^{-38}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq -5.4 \cdot 10^{-243}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 4.8 \cdot 10^{-87}:\\
\;\;\;\;t_2 + y \cdot b\\
\mathbf{elif}\;t \leq 0.0003:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if t < -2.8e-38 or 2.99999999999999974e-4 < t Initial program 94.4%
associate-+l-94.4%
*-commutative94.4%
*-commutative94.4%
sub-neg94.4%
metadata-eval94.4%
remove-double-neg94.4%
remove-double-neg94.4%
sub-neg94.4%
metadata-eval94.4%
associate--l+94.4%
Simplified94.4%
Taylor expanded in t around inf 94.6%
if -2.8e-38 < t < -5.40000000000000021e-243 or 4.7999999999999999e-87 < t < 2.99999999999999974e-4Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in z around 0 83.0%
Taylor expanded in t around 0 81.9%
if -5.40000000000000021e-243 < t < 4.7999999999999999e-87Initial 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 76.3%
mul-1-neg76.3%
distribute-rgt-neg-in76.3%
Simplified76.3%
Final simplification87.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* z (- 1.0 y)))) (t_2 (+ x (* b (- (+ t y) 2.0)))))
(if (<= b -1e+156)
t_2
(if (<= b -1.36e-68)
(+ t_1 (* t (- b a)))
(if (<= b 5.8e+37) (+ t_1 (- a (* a t))) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = x + (b * ((t + y) - 2.0));
double tmp;
if (b <= -1e+156) {
tmp = t_2;
} else if (b <= -1.36e-68) {
tmp = t_1 + (t * (b - a));
} else if (b <= 5.8e+37) {
tmp = t_1 + (a - (a * t));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (z * (1.0d0 - y))
t_2 = x + (b * ((t + y) - 2.0d0))
if (b <= (-1d+156)) then
tmp = t_2
else if (b <= (-1.36d-68)) then
tmp = t_1 + (t * (b - a))
else if (b <= 5.8d+37) then
tmp = t_1 + (a - (a * t))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (z * (1.0 - y));
double t_2 = x + (b * ((t + y) - 2.0));
double tmp;
if (b <= -1e+156) {
tmp = t_2;
} else if (b <= -1.36e-68) {
tmp = t_1 + (t * (b - a));
} else if (b <= 5.8e+37) {
tmp = t_1 + (a - (a * t));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (z * (1.0 - y)) t_2 = x + (b * ((t + y) - 2.0)) tmp = 0 if b <= -1e+156: tmp = t_2 elif b <= -1.36e-68: tmp = t_1 + (t * (b - a)) elif b <= 5.8e+37: tmp = t_1 + (a - (a * t)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(z * Float64(1.0 - y))) t_2 = Float64(x + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (b <= -1e+156) tmp = t_2; elseif (b <= -1.36e-68) tmp = Float64(t_1 + Float64(t * Float64(b - a))); elseif (b <= 5.8e+37) tmp = Float64(t_1 + Float64(a - Float64(a * t))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (z * (1.0 - y)); t_2 = x + (b * ((t + y) - 2.0)); tmp = 0.0; if (b <= -1e+156) tmp = t_2; elseif (b <= -1.36e-68) tmp = t_1 + (t * (b - a)); elseif (b <= 5.8e+37) tmp = t_1 + (a - (a * t)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1e+156], t$95$2, If[LessEqual[b, -1.36e-68], N[(t$95$1 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5.8e+37], N[(t$95$1 + N[(a - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + z \cdot \left(1 - y\right)\\
t_2 := x + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -1 \cdot 10^{+156}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -1.36 \cdot 10^{-68}:\\
\;\;\;\;t_1 + t \cdot \left(b - a\right)\\
\mathbf{elif}\;b \leq 5.8 \cdot 10^{+37}:\\
\;\;\;\;t_1 + \left(a - a \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -9.9999999999999998e155 or 5.79999999999999957e37 < b Initial program 93.7%
associate-+l-93.7%
*-commutative93.7%
*-commutative93.7%
sub-neg93.7%
metadata-eval93.7%
remove-double-neg93.7%
remove-double-neg93.7%
sub-neg93.7%
metadata-eval93.7%
associate--l+93.7%
Simplified93.7%
Taylor expanded in z around 0 86.0%
Taylor expanded in a around 0 82.0%
if -9.9999999999999998e155 < b < -1.36000000000000003e-68Initial program 95.8%
associate-+l-95.8%
*-commutative95.8%
*-commutative95.8%
sub-neg95.8%
metadata-eval95.8%
remove-double-neg95.8%
remove-double-neg95.8%
sub-neg95.8%
metadata-eval95.8%
associate--l+95.8%
Simplified95.8%
Taylor expanded in t around inf 87.3%
if -1.36000000000000003e-68 < b < 5.79999999999999957e37Initial 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 a around inf 97.0%
sub-neg97.0%
metadata-eval97.0%
+-commutative97.0%
*-commutative97.0%
+-commutative97.0%
distribute-lft-in97.0%
*-commutative97.0%
mul-1-neg97.0%
unsub-neg97.0%
*-commutative97.0%
Simplified97.0%
Final simplification90.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
(if (<= t -1.3e+23)
t_2
(if (<= t -3.4e-94)
t_1
(if (<= t -8e-142)
(+ z x)
(if (<= t 3.5e-97)
t_1
(if (<= t 5.5e+28)
(* a (- 1.0 t))
(if (<= t 1.25e+89) (+ z x) t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.3e+23) {
tmp = t_2;
} else if (t <= -3.4e-94) {
tmp = t_1;
} else if (t <= -8e-142) {
tmp = z + x;
} else if (t <= 3.5e-97) {
tmp = t_1;
} else if (t <= 5.5e+28) {
tmp = a * (1.0 - t);
} else if (t <= 1.25e+89) {
tmp = z + x;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y * (b - z)
t_2 = t * (b - a)
if (t <= (-1.3d+23)) then
tmp = t_2
else if (t <= (-3.4d-94)) then
tmp = t_1
else if (t <= (-8d-142)) then
tmp = z + x
else if (t <= 3.5d-97) then
tmp = t_1
else if (t <= 5.5d+28) then
tmp = a * (1.0d0 - t)
else if (t <= 1.25d+89) then
tmp = z + x
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.3e+23) {
tmp = t_2;
} else if (t <= -3.4e-94) {
tmp = t_1;
} else if (t <= -8e-142) {
tmp = z + x;
} else if (t <= 3.5e-97) {
tmp = t_1;
} else if (t <= 5.5e+28) {
tmp = a * (1.0 - t);
} else if (t <= 1.25e+89) {
tmp = z + x;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * (b - z) t_2 = t * (b - a) tmp = 0 if t <= -1.3e+23: tmp = t_2 elif t <= -3.4e-94: tmp = t_1 elif t <= -8e-142: tmp = z + x elif t <= 3.5e-97: tmp = t_1 elif t <= 5.5e+28: tmp = a * (1.0 - t) elif t <= 1.25e+89: tmp = z + x else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(b - z)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.3e+23) tmp = t_2; elseif (t <= -3.4e-94) tmp = t_1; elseif (t <= -8e-142) tmp = Float64(z + x); elseif (t <= 3.5e-97) tmp = t_1; elseif (t <= 5.5e+28) tmp = Float64(a * Float64(1.0 - t)); elseif (t <= 1.25e+89) tmp = Float64(z + x); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * (b - z); t_2 = t * (b - a); tmp = 0.0; if (t <= -1.3e+23) tmp = t_2; elseif (t <= -3.4e-94) tmp = t_1; elseif (t <= -8e-142) tmp = z + x; elseif (t <= 3.5e-97) tmp = t_1; elseif (t <= 5.5e+28) tmp = a * (1.0 - t); elseif (t <= 1.25e+89) tmp = z + x; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.3e+23], t$95$2, If[LessEqual[t, -3.4e-94], t$95$1, If[LessEqual[t, -8e-142], N[(z + x), $MachinePrecision], If[LessEqual[t, 3.5e-97], t$95$1, If[LessEqual[t, 5.5e+28], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e+89], N[(z + x), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b - z\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.3 \cdot 10^{+23}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -3.4 \cdot 10^{-94}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -8 \cdot 10^{-142}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 3.5 \cdot 10^{-97}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{+28}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{+89}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.29999999999999996e23 or 1.24999999999999996e89 < t Initial program 94.1%
associate-+l-94.1%
*-commutative94.1%
*-commutative94.1%
sub-neg94.1%
metadata-eval94.1%
remove-double-neg94.1%
remove-double-neg94.1%
sub-neg94.1%
metadata-eval94.1%
associate--l+94.1%
Simplified94.1%
Taylor expanded in t around inf 70.9%
if -1.29999999999999996e23 < t < -3.3999999999999998e-94 or -8.0000000000000003e-142 < t < 3.50000000000000019e-97Initial 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 46.6%
if -3.3999999999999998e-94 < t < -8.0000000000000003e-142 or 5.5000000000000003e28 < t < 1.24999999999999996e89Initial program 95.9%
associate-+l-95.9%
*-commutative95.9%
*-commutative95.9%
sub-neg95.9%
metadata-eval95.9%
remove-double-neg95.9%
remove-double-neg95.9%
sub-neg95.9%
metadata-eval95.9%
associate--l+95.9%
Simplified95.9%
Taylor expanded in t around inf 81.0%
Taylor expanded in t around 0 67.9%
Taylor expanded in y around 0 60.1%
cancel-sign-sub-inv60.1%
metadata-eval60.1%
*-lft-identity60.1%
Simplified60.1%
if 3.50000000000000019e-97 < t < 5.5000000000000003e28Initial 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 54.6%
Final simplification59.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
(if (<= t -1.05e+21)
t_2
(if (<= t -1.22e-87)
t_1
(if (<= t -1.55e-142)
(+ z x)
(if (<= t 3.8e-97)
t_1
(if (<= t 6.6e+24)
(- a (* a t))
(if (<= t 1.25e+89) (+ z x) t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.05e+21) {
tmp = t_2;
} else if (t <= -1.22e-87) {
tmp = t_1;
} else if (t <= -1.55e-142) {
tmp = z + x;
} else if (t <= 3.8e-97) {
tmp = t_1;
} else if (t <= 6.6e+24) {
tmp = a - (a * t);
} else if (t <= 1.25e+89) {
tmp = z + x;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y * (b - z)
t_2 = t * (b - a)
if (t <= (-1.05d+21)) then
tmp = t_2
else if (t <= (-1.22d-87)) then
tmp = t_1
else if (t <= (-1.55d-142)) then
tmp = z + x
else if (t <= 3.8d-97) then
tmp = t_1
else if (t <= 6.6d+24) then
tmp = a - (a * t)
else if (t <= 1.25d+89) then
tmp = z + x
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.05e+21) {
tmp = t_2;
} else if (t <= -1.22e-87) {
tmp = t_1;
} else if (t <= -1.55e-142) {
tmp = z + x;
} else if (t <= 3.8e-97) {
tmp = t_1;
} else if (t <= 6.6e+24) {
tmp = a - (a * t);
} else if (t <= 1.25e+89) {
tmp = z + x;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * (b - z) t_2 = t * (b - a) tmp = 0 if t <= -1.05e+21: tmp = t_2 elif t <= -1.22e-87: tmp = t_1 elif t <= -1.55e-142: tmp = z + x elif t <= 3.8e-97: tmp = t_1 elif t <= 6.6e+24: tmp = a - (a * t) elif t <= 1.25e+89: tmp = z + x else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(b - z)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.05e+21) tmp = t_2; elseif (t <= -1.22e-87) tmp = t_1; elseif (t <= -1.55e-142) tmp = Float64(z + x); elseif (t <= 3.8e-97) tmp = t_1; elseif (t <= 6.6e+24) tmp = Float64(a - Float64(a * t)); elseif (t <= 1.25e+89) tmp = Float64(z + x); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * (b - z); t_2 = t * (b - a); tmp = 0.0; if (t <= -1.05e+21) tmp = t_2; elseif (t <= -1.22e-87) tmp = t_1; elseif (t <= -1.55e-142) tmp = z + x; elseif (t <= 3.8e-97) tmp = t_1; elseif (t <= 6.6e+24) tmp = a - (a * t); elseif (t <= 1.25e+89) tmp = z + x; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.05e+21], t$95$2, If[LessEqual[t, -1.22e-87], t$95$1, If[LessEqual[t, -1.55e-142], N[(z + x), $MachinePrecision], If[LessEqual[t, 3.8e-97], t$95$1, If[LessEqual[t, 6.6e+24], N[(a - N[(a * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e+89], N[(z + x), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b - z\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.05 \cdot 10^{+21}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.22 \cdot 10^{-87}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.55 \cdot 10^{-142}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{-97}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6.6 \cdot 10^{+24}:\\
\;\;\;\;a - a \cdot t\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{+89}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.05e21 or 1.24999999999999996e89 < t Initial program 94.1%
associate-+l-94.1%
*-commutative94.1%
*-commutative94.1%
sub-neg94.1%
metadata-eval94.1%
remove-double-neg94.1%
remove-double-neg94.1%
sub-neg94.1%
metadata-eval94.1%
associate--l+94.1%
Simplified94.1%
Taylor expanded in t around inf 70.9%
if -1.05e21 < t < -1.2199999999999999e-87 or -1.55e-142 < t < 3.8000000000000001e-97Initial 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 46.6%
if -1.2199999999999999e-87 < t < -1.55e-142 or 6.5999999999999998e24 < t < 1.24999999999999996e89Initial program 95.9%
associate-+l-95.9%
*-commutative95.9%
*-commutative95.9%
sub-neg95.9%
metadata-eval95.9%
remove-double-neg95.9%
remove-double-neg95.9%
sub-neg95.9%
metadata-eval95.9%
associate--l+95.9%
Simplified95.9%
Taylor expanded in t around inf 81.0%
Taylor expanded in t around 0 67.9%
Taylor expanded in y around 0 60.1%
cancel-sign-sub-inv60.1%
metadata-eval60.1%
*-lft-identity60.1%
Simplified60.1%
if 3.8000000000000001e-97 < t < 6.5999999999999998e24Initial 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 x around 0 99.9%
fma-def99.9%
sub-neg99.9%
metadata-eval99.9%
*-commutative99.9%
fma-def99.9%
neg-mul-199.9%
distribute-lft-neg-in99.9%
*-commutative99.9%
fma-def99.9%
neg-sub099.9%
+-commutative99.9%
associate--r+99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in a around inf 54.6%
distribute-rgt-out--54.7%
*-lft-identity54.7%
Simplified54.7%
Final simplification59.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
(if (<= t -1.9e+25)
t_2
(if (<= t -1.9e-93)
t_1
(if (<= t -8e-143)
(+ z x)
(if (<= t 4.2e-97)
t_1
(if (<= t 6.4e+22)
(- a (* a t))
(if (<= t 1.25e+89) (- x (* y z)) t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.9e+25) {
tmp = t_2;
} else if (t <= -1.9e-93) {
tmp = t_1;
} else if (t <= -8e-143) {
tmp = z + x;
} else if (t <= 4.2e-97) {
tmp = t_1;
} else if (t <= 6.4e+22) {
tmp = a - (a * t);
} else if (t <= 1.25e+89) {
tmp = x - (y * z);
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y * (b - z)
t_2 = t * (b - a)
if (t <= (-1.9d+25)) then
tmp = t_2
else if (t <= (-1.9d-93)) then
tmp = t_1
else if (t <= (-8d-143)) then
tmp = z + x
else if (t <= 4.2d-97) then
tmp = t_1
else if (t <= 6.4d+22) then
tmp = a - (a * t)
else if (t <= 1.25d+89) then
tmp = x - (y * z)
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.9e+25) {
tmp = t_2;
} else if (t <= -1.9e-93) {
tmp = t_1;
} else if (t <= -8e-143) {
tmp = z + x;
} else if (t <= 4.2e-97) {
tmp = t_1;
} else if (t <= 6.4e+22) {
tmp = a - (a * t);
} else if (t <= 1.25e+89) {
tmp = x - (y * z);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * (b - z) t_2 = t * (b - a) tmp = 0 if t <= -1.9e+25: tmp = t_2 elif t <= -1.9e-93: tmp = t_1 elif t <= -8e-143: tmp = z + x elif t <= 4.2e-97: tmp = t_1 elif t <= 6.4e+22: tmp = a - (a * t) elif t <= 1.25e+89: tmp = x - (y * z) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(b - z)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.9e+25) tmp = t_2; elseif (t <= -1.9e-93) tmp = t_1; elseif (t <= -8e-143) tmp = Float64(z + x); elseif (t <= 4.2e-97) tmp = t_1; elseif (t <= 6.4e+22) tmp = Float64(a - Float64(a * t)); elseif (t <= 1.25e+89) tmp = Float64(x - Float64(y * z)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * (b - z); t_2 = t * (b - a); tmp = 0.0; if (t <= -1.9e+25) tmp = t_2; elseif (t <= -1.9e-93) tmp = t_1; elseif (t <= -8e-143) tmp = z + x; elseif (t <= 4.2e-97) tmp = t_1; elseif (t <= 6.4e+22) tmp = a - (a * t); elseif (t <= 1.25e+89) tmp = x - (y * z); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.9e+25], t$95$2, If[LessEqual[t, -1.9e-93], t$95$1, If[LessEqual[t, -8e-143], N[(z + x), $MachinePrecision], If[LessEqual[t, 4.2e-97], t$95$1, If[LessEqual[t, 6.4e+22], N[(a - N[(a * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e+89], N[(x - N[(y * z), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b - z\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.9 \cdot 10^{+25}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.9 \cdot 10^{-93}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -8 \cdot 10^{-143}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;t \leq 4.2 \cdot 10^{-97}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6.4 \cdot 10^{+22}:\\
\;\;\;\;a - a \cdot t\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{+89}:\\
\;\;\;\;x - y \cdot z\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.9e25 or 1.24999999999999996e89 < t Initial program 94.1%
associate-+l-94.1%
*-commutative94.1%
*-commutative94.1%
sub-neg94.1%
metadata-eval94.1%
remove-double-neg94.1%
remove-double-neg94.1%
sub-neg94.1%
metadata-eval94.1%
associate--l+94.1%
Simplified94.1%
Taylor expanded in t around inf 70.9%
if -1.9e25 < t < -1.8999999999999999e-93 or -7.9999999999999996e-143 < t < 4.2000000000000002e-97Initial 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 46.6%
if -1.8999999999999999e-93 < t < -7.9999999999999996e-143Initial 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 t around inf 65.1%
Taylor expanded in t around 0 64.0%
Taylor expanded in y around 0 55.4%
cancel-sign-sub-inv55.4%
metadata-eval55.4%
*-lft-identity55.4%
Simplified55.4%
if 4.2000000000000002e-97 < t < 6.4e22Initial 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 x around 0 99.9%
fma-def99.9%
sub-neg99.9%
metadata-eval99.9%
*-commutative99.9%
fma-def99.9%
neg-mul-199.9%
distribute-lft-neg-in99.9%
*-commutative99.9%
fma-def99.9%
neg-sub099.9%
+-commutative99.9%
associate--r+99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in a around inf 57.2%
distribute-rgt-out--57.3%
*-lft-identity57.3%
Simplified57.3%
if 6.4e22 < t < 1.24999999999999996e89Initial 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 t around inf 93.9%
Taylor expanded in t around 0 72.8%
Taylor expanded in y around inf 59.7%
Final simplification59.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- z))))
(if (<= y -1.95e+51)
t_1
(if (<= y -3.5e-62)
(+ z x)
(if (<= y -1.3e-216)
(* a (- t))
(if (<= y 21500000.0)
(+ z x)
(if (or (<= y 1.85e+102) (not (<= y 1.45e+216))) t_1 (* y b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * -z;
double tmp;
if (y <= -1.95e+51) {
tmp = t_1;
} else if (y <= -3.5e-62) {
tmp = z + x;
} else if (y <= -1.3e-216) {
tmp = a * -t;
} else if (y <= 21500000.0) {
tmp = z + x;
} else if ((y <= 1.85e+102) || !(y <= 1.45e+216)) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = y * -z
if (y <= (-1.95d+51)) then
tmp = t_1
else if (y <= (-3.5d-62)) then
tmp = z + x
else if (y <= (-1.3d-216)) then
tmp = a * -t
else if (y <= 21500000.0d0) then
tmp = z + x
else if ((y <= 1.85d+102) .or. (.not. (y <= 1.45d+216))) then
tmp = t_1
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * -z;
double tmp;
if (y <= -1.95e+51) {
tmp = t_1;
} else if (y <= -3.5e-62) {
tmp = z + x;
} else if (y <= -1.3e-216) {
tmp = a * -t;
} else if (y <= 21500000.0) {
tmp = z + x;
} else if ((y <= 1.85e+102) || !(y <= 1.45e+216)) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * -z tmp = 0 if y <= -1.95e+51: tmp = t_1 elif y <= -3.5e-62: tmp = z + x elif y <= -1.3e-216: tmp = a * -t elif y <= 21500000.0: tmp = z + x elif (y <= 1.85e+102) or not (y <= 1.45e+216): tmp = t_1 else: tmp = y * b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(-z)) tmp = 0.0 if (y <= -1.95e+51) tmp = t_1; elseif (y <= -3.5e-62) tmp = Float64(z + x); elseif (y <= -1.3e-216) tmp = Float64(a * Float64(-t)); elseif (y <= 21500000.0) tmp = Float64(z + x); elseif ((y <= 1.85e+102) || !(y <= 1.45e+216)) tmp = t_1; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * -z; tmp = 0.0; if (y <= -1.95e+51) tmp = t_1; elseif (y <= -3.5e-62) tmp = z + x; elseif (y <= -1.3e-216) tmp = a * -t; elseif (y <= 21500000.0) tmp = z + x; elseif ((y <= 1.85e+102) || ~((y <= 1.45e+216))) tmp = t_1; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * (-z)), $MachinePrecision]}, If[LessEqual[y, -1.95e+51], t$95$1, If[LessEqual[y, -3.5e-62], N[(z + x), $MachinePrecision], If[LessEqual[y, -1.3e-216], N[(a * (-t)), $MachinePrecision], If[LessEqual[y, 21500000.0], N[(z + x), $MachinePrecision], If[Or[LessEqual[y, 1.85e+102], N[Not[LessEqual[y, 1.45e+216]], $MachinePrecision]], t$95$1, N[(y * b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(-z\right)\\
\mathbf{if}\;y \leq -1.95 \cdot 10^{+51}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -3.5 \cdot 10^{-62}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;y \leq -1.3 \cdot 10^{-216}:\\
\;\;\;\;a \cdot \left(-t\right)\\
\mathbf{elif}\;y \leq 21500000:\\
\;\;\;\;z + x\\
\mathbf{elif}\;y \leq 1.85 \cdot 10^{+102} \lor \neg \left(y \leq 1.45 \cdot 10^{+216}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -1.94999999999999992e51 or 2.15e7 < y < 1.85000000000000011e102 or 1.45e216 < y Initial 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 y around inf 64.5%
Taylor expanded in b around 0 40.3%
mul-1-neg40.3%
distribute-rgt-neg-in40.3%
Simplified40.3%
if -1.94999999999999992e51 < y < -3.5000000000000001e-62 or -1.2999999999999999e-216 < y < 2.15e7Initial 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 79.0%
Taylor expanded in t around 0 47.5%
Taylor expanded in y around 0 44.3%
cancel-sign-sub-inv44.3%
metadata-eval44.3%
*-lft-identity44.3%
Simplified44.3%
if -3.5000000000000001e-62 < y < -1.2999999999999999e-216Initial 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 51.8%
Taylor expanded in t around inf 39.9%
associate-*r*39.9%
mul-1-neg39.9%
Simplified39.9%
if 1.85000000000000011e102 < y < 1.45e216Initial program 90.0%
associate-+l-90.0%
*-commutative90.0%
*-commutative90.0%
sub-neg90.0%
metadata-eval90.0%
remove-double-neg90.0%
remove-double-neg90.0%
sub-neg90.0%
metadata-eval90.0%
associate--l+90.0%
Simplified90.0%
Taylor expanded in z around 0 66.1%
Taylor expanded in y around inf 51.6%
Final simplification42.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* t (- b a)))) (t_2 (* y (- b z))))
(if (<= y -9e+60)
t_2
(if (<= y -4.8e-287)
t_1
(if (<= y 5.2e-25) (+ x (- a (* a t))) (if (<= y 1.75e+88) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = y * (b - z);
double tmp;
if (y <= -9e+60) {
tmp = t_2;
} else if (y <= -4.8e-287) {
tmp = t_1;
} else if (y <= 5.2e-25) {
tmp = x + (a - (a * t));
} else if (y <= 1.75e+88) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t * (b - a))
t_2 = y * (b - z)
if (y <= (-9d+60)) then
tmp = t_2
else if (y <= (-4.8d-287)) then
tmp = t_1
else if (y <= 5.2d-25) then
tmp = x + (a - (a * t))
else if (y <= 1.75d+88) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = y * (b - z);
double tmp;
if (y <= -9e+60) {
tmp = t_2;
} else if (y <= -4.8e-287) {
tmp = t_1;
} else if (y <= 5.2e-25) {
tmp = x + (a - (a * t));
} else if (y <= 1.75e+88) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (t * (b - a)) t_2 = y * (b - z) tmp = 0 if y <= -9e+60: tmp = t_2 elif y <= -4.8e-287: tmp = t_1 elif y <= 5.2e-25: tmp = x + (a - (a * t)) elif y <= 1.75e+88: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(t * Float64(b - a))) t_2 = Float64(y * Float64(b - z)) tmp = 0.0 if (y <= -9e+60) tmp = t_2; elseif (y <= -4.8e-287) tmp = t_1; elseif (y <= 5.2e-25) tmp = Float64(x + Float64(a - Float64(a * t))); elseif (y <= 1.75e+88) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (t * (b - a)); t_2 = y * (b - z); tmp = 0.0; if (y <= -9e+60) tmp = t_2; elseif (y <= -4.8e-287) tmp = t_1; elseif (y <= 5.2e-25) tmp = x + (a - (a * t)); elseif (y <= 1.75e+88) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9e+60], t$95$2, If[LessEqual[y, -4.8e-287], t$95$1, If[LessEqual[y, 5.2e-25], N[(x + N[(a - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.75e+88], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \left(b - a\right)\\
t_2 := y \cdot \left(b - z\right)\\
\mathbf{if}\;y \leq -9 \cdot 10^{+60}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -4.8 \cdot 10^{-287}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 5.2 \cdot 10^{-25}:\\
\;\;\;\;x + \left(a - a \cdot t\right)\\
\mathbf{elif}\;y \leq 1.75 \cdot 10^{+88}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -9.00000000000000026e60 or 1.7499999999999999e88 < y Initial program 89.7%
associate-+l-89.7%
*-commutative89.7%
*-commutative89.7%
sub-neg89.7%
metadata-eval89.7%
remove-double-neg89.7%
remove-double-neg89.7%
sub-neg89.7%
metadata-eval89.7%
associate--l+89.7%
Simplified89.7%
Taylor expanded in y around inf 76.7%
if -9.00000000000000026e60 < y < -4.79999999999999999e-287 or 5.2e-25 < y < 1.7499999999999999e88Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 80.2%
Taylor expanded in z around 0 64.9%
if -4.79999999999999999e-287 < y < 5.2e-25Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around 0 78.3%
Taylor expanded in b around 0 63.7%
sub-neg63.7%
metadata-eval63.7%
*-commutative63.7%
distribute-lft-out63.7%
*-commutative63.7%
neg-mul-163.7%
unsub-neg63.7%
*-commutative63.7%
Simplified63.7%
Final simplification68.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z x) (* t (- a b)))))
(if (<= t -2.5e+21)
t_1
(if (<= t 1.35e-105)
(+ (+ a x) (* z (- 1.0 y)))
(if (<= t 0.1) (+ a (+ x (* b (- y 2.0)))) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + x) - (t * (a - b));
double tmp;
if (t <= -2.5e+21) {
tmp = t_1;
} else if (t <= 1.35e-105) {
tmp = (a + x) + (z * (1.0 - y));
} else if (t <= 0.1) {
tmp = a + (x + (b * (y - 2.0)));
} 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 + x) - (t * (a - b))
if (t <= (-2.5d+21)) then
tmp = t_1
else if (t <= 1.35d-105) then
tmp = (a + x) + (z * (1.0d0 - y))
else if (t <= 0.1d0) then
tmp = a + (x + (b * (y - 2.0d0)))
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 + x) - (t * (a - b));
double tmp;
if (t <= -2.5e+21) {
tmp = t_1;
} else if (t <= 1.35e-105) {
tmp = (a + x) + (z * (1.0 - y));
} else if (t <= 0.1) {
tmp = a + (x + (b * (y - 2.0)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + x) - (t * (a - b)) tmp = 0 if t <= -2.5e+21: tmp = t_1 elif t <= 1.35e-105: tmp = (a + x) + (z * (1.0 - y)) elif t <= 0.1: tmp = a + (x + (b * (y - 2.0))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + x) - Float64(t * Float64(a - b))) tmp = 0.0 if (t <= -2.5e+21) tmp = t_1; elseif (t <= 1.35e-105) tmp = Float64(Float64(a + x) + Float64(z * Float64(1.0 - y))); elseif (t <= 0.1) tmp = Float64(a + Float64(x + Float64(b * Float64(y - 2.0)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + x) - (t * (a - b)); tmp = 0.0; if (t <= -2.5e+21) tmp = t_1; elseif (t <= 1.35e-105) tmp = (a + x) + (z * (1.0 - y)); elseif (t <= 0.1) tmp = a + (x + (b * (y - 2.0))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + x), $MachinePrecision] - N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.5e+21], t$95$1, If[LessEqual[t, 1.35e-105], N[(N[(a + x), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 0.1], N[(a + N[(x + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + x\right) - t \cdot \left(a - b\right)\\
\mathbf{if}\;t \leq -2.5 \cdot 10^{+21}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{-105}:\\
\;\;\;\;\left(a + x\right) + z \cdot \left(1 - y\right)\\
\mathbf{elif}\;t \leq 0.1:\\
\;\;\;\;a + \left(x + b \cdot \left(y - 2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.5e21 or 0.10000000000000001 < t Initial program 94.2%
associate-+l-94.2%
*-commutative94.2%
*-commutative94.2%
sub-neg94.2%
metadata-eval94.2%
remove-double-neg94.2%
remove-double-neg94.2%
sub-neg94.2%
metadata-eval94.2%
associate--l+94.2%
Simplified94.2%
Taylor expanded in t around inf 94.9%
Taylor expanded in y around 0 84.1%
cancel-sign-sub-inv84.1%
metadata-eval84.1%
*-lft-identity84.1%
+-commutative84.1%
Simplified84.1%
if -2.5e21 < t < 1.34999999999999996e-105Initial 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 70.5%
sub-neg70.5%
metadata-eval70.5%
+-commutative70.5%
*-commutative70.5%
+-commutative70.5%
distribute-lft-in70.5%
*-commutative70.5%
mul-1-neg70.5%
unsub-neg70.5%
*-commutative70.5%
Simplified70.5%
Taylor expanded in t around 0 70.5%
if 1.34999999999999996e-105 < t < 0.10000000000000001Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in z around 0 94.7%
Taylor expanded in t around 0 91.5%
Final simplification79.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z x) (* t (- a b)))))
(if (<= t -2.3e+21)
t_1
(if (<= t 3.8e-87)
(+ (+ x (* z (- 1.0 y))) (* y b))
(if (<= t 0.00045) (+ a (+ x (* b (- y 2.0)))) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + x) - (t * (a - b));
double tmp;
if (t <= -2.3e+21) {
tmp = t_1;
} else if (t <= 3.8e-87) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (t <= 0.00045) {
tmp = a + (x + (b * (y - 2.0)));
} 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 + x) - (t * (a - b))
if (t <= (-2.3d+21)) then
tmp = t_1
else if (t <= 3.8d-87) then
tmp = (x + (z * (1.0d0 - y))) + (y * b)
else if (t <= 0.00045d0) then
tmp = a + (x + (b * (y - 2.0d0)))
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 + x) - (t * (a - b));
double tmp;
if (t <= -2.3e+21) {
tmp = t_1;
} else if (t <= 3.8e-87) {
tmp = (x + (z * (1.0 - y))) + (y * b);
} else if (t <= 0.00045) {
tmp = a + (x + (b * (y - 2.0)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + x) - (t * (a - b)) tmp = 0 if t <= -2.3e+21: tmp = t_1 elif t <= 3.8e-87: tmp = (x + (z * (1.0 - y))) + (y * b) elif t <= 0.00045: tmp = a + (x + (b * (y - 2.0))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + x) - Float64(t * Float64(a - b))) tmp = 0.0 if (t <= -2.3e+21) tmp = t_1; elseif (t <= 3.8e-87) tmp = Float64(Float64(x + Float64(z * Float64(1.0 - y))) + Float64(y * b)); elseif (t <= 0.00045) tmp = Float64(a + Float64(x + Float64(b * Float64(y - 2.0)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + x) - (t * (a - b)); tmp = 0.0; if (t <= -2.3e+21) tmp = t_1; elseif (t <= 3.8e-87) tmp = (x + (z * (1.0 - y))) + (y * b); elseif (t <= 0.00045) tmp = a + (x + (b * (y - 2.0))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + x), $MachinePrecision] - N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.3e+21], t$95$1, If[LessEqual[t, 3.8e-87], N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 0.00045], N[(a + N[(x + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + x\right) - t \cdot \left(a - b\right)\\
\mathbf{if}\;t \leq -2.3 \cdot 10^{+21}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{-87}:\\
\;\;\;\;\left(x + z \cdot \left(1 - y\right)\right) + y \cdot b\\
\mathbf{elif}\;t \leq 0.00045:\\
\;\;\;\;a + \left(x + b \cdot \left(y - 2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.3e21 or 4.4999999999999999e-4 < t Initial program 94.2%
associate-+l-94.2%
*-commutative94.2%
*-commutative94.2%
sub-neg94.2%
metadata-eval94.2%
remove-double-neg94.2%
remove-double-neg94.2%
sub-neg94.2%
metadata-eval94.2%
associate--l+94.2%
Simplified94.2%
Taylor expanded in t around inf 94.9%
Taylor expanded in y around 0 84.1%
cancel-sign-sub-inv84.1%
metadata-eval84.1%
*-lft-identity84.1%
+-commutative84.1%
Simplified84.1%
if -2.3e21 < t < 3.8e-87Initial 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 71.7%
mul-1-neg71.7%
distribute-rgt-neg-in71.7%
Simplified71.7%
if 3.8e-87 < t < 4.4999999999999999e-4Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in z around 0 99.9%
Taylor expanded in t around 0 95.9%
Final simplification79.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t))))
(if (<= a -8.6e+34)
t_1
(if (<= a 7e-206)
(+ z x)
(if (<= a 1.2e-128) (* y (- z)) (if (<= a 2.15e-56) (+ 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 <= -8.6e+34) {
tmp = t_1;
} else if (a <= 7e-206) {
tmp = z + x;
} else if (a <= 1.2e-128) {
tmp = y * -z;
} else if (a <= 2.15e-56) {
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 <= (-8.6d+34)) then
tmp = t_1
else if (a <= 7d-206) then
tmp = z + x
else if (a <= 1.2d-128) then
tmp = y * -z
else if (a <= 2.15d-56) 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 <= -8.6e+34) {
tmp = t_1;
} else if (a <= 7e-206) {
tmp = z + x;
} else if (a <= 1.2e-128) {
tmp = y * -z;
} else if (a <= 2.15e-56) {
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 <= -8.6e+34: tmp = t_1 elif a <= 7e-206: tmp = z + x elif a <= 1.2e-128: tmp = y * -z elif a <= 2.15e-56: 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 <= -8.6e+34) tmp = t_1; elseif (a <= 7e-206) tmp = Float64(z + x); elseif (a <= 1.2e-128) tmp = Float64(y * Float64(-z)); elseif (a <= 2.15e-56) 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 <= -8.6e+34) tmp = t_1; elseif (a <= 7e-206) tmp = z + x; elseif (a <= 1.2e-128) tmp = y * -z; elseif (a <= 2.15e-56) 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, -8.6e+34], t$95$1, If[LessEqual[a, 7e-206], N[(z + x), $MachinePrecision], If[LessEqual[a, 1.2e-128], N[(y * (-z)), $MachinePrecision], If[LessEqual[a, 2.15e-56], 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 -8.6 \cdot 10^{+34}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 7 \cdot 10^{-206}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-128}:\\
\;\;\;\;y \cdot \left(-z\right)\\
\mathbf{elif}\;a \leq 2.15 \cdot 10^{-56}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -8.59999999999999988e34 or 2.1500000000000001e-56 < a Initial 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 a around inf 56.3%
if -8.59999999999999988e34 < a < 6.99999999999999979e-206 or 1.1999999999999999e-128 < a < 2.1500000000000001e-56Initial program 97.1%
associate-+l-97.1%
*-commutative97.1%
*-commutative97.1%
sub-neg97.1%
metadata-eval97.1%
remove-double-neg97.1%
remove-double-neg97.1%
sub-neg97.1%
metadata-eval97.1%
associate--l+97.1%
Simplified97.1%
Taylor expanded in t around inf 79.4%
Taylor expanded in t around 0 55.5%
Taylor expanded in y around 0 36.6%
cancel-sign-sub-inv36.6%
metadata-eval36.6%
*-lft-identity36.6%
Simplified36.6%
if 6.99999999999999979e-206 < a < 1.1999999999999999e-128Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in y around inf 53.8%
Taylor expanded in b around 0 43.6%
mul-1-neg43.6%
distribute-rgt-neg-in43.6%
Simplified43.6%
Final simplification47.4%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -6e+82) (not (<= t 6.5e+31))) (+ x (* t (- b a))) (+ (+ a x) (* z (- 1.0 y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -6e+82) || !(t <= 6.5e+31)) {
tmp = x + (t * (b - a));
} 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 ((t <= (-6d+82)) .or. (.not. (t <= 6.5d+31))) then
tmp = x + (t * (b - a))
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 ((t <= -6e+82) || !(t <= 6.5e+31)) {
tmp = x + (t * (b - a));
} else {
tmp = (a + x) + (z * (1.0 - y));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -6e+82) or not (t <= 6.5e+31): tmp = x + (t * (b - a)) else: tmp = (a + x) + (z * (1.0 - y)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -6e+82) || !(t <= 6.5e+31)) tmp = Float64(x + Float64(t * Float64(b - a))); 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 ((t <= -6e+82) || ~((t <= 6.5e+31))) tmp = x + (t * (b - a)); else tmp = (a + x) + (z * (1.0 - y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -6e+82], N[Not[LessEqual[t, 6.5e+31]], $MachinePrecision]], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a + x), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -6 \cdot 10^{+82} \lor \neg \left(t \leq 6.5 \cdot 10^{+31}\right):\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a + x\right) + z \cdot \left(1 - y\right)\\
\end{array}
\end{array}
if t < -5.99999999999999978e82 or 6.5000000000000004e31 < t Initial program 94.8%
associate-+l-94.8%
*-commutative94.8%
*-commutative94.8%
sub-neg94.8%
metadata-eval94.8%
remove-double-neg94.8%
remove-double-neg94.8%
sub-neg94.8%
metadata-eval94.8%
associate--l+94.8%
Simplified94.8%
Taylor expanded in t around inf 94.3%
Taylor expanded in z around 0 82.0%
if -5.99999999999999978e82 < t < 6.5000000000000004e31Initial program 98.5%
associate-+l-98.5%
*-commutative98.5%
*-commutative98.5%
sub-neg98.5%
metadata-eval98.5%
remove-double-neg98.5%
remove-double-neg98.5%
sub-neg98.5%
metadata-eval98.5%
associate--l+98.5%
Simplified98.5%
Taylor expanded in a around inf 72.0%
sub-neg72.0%
metadata-eval72.0%
+-commutative72.0%
*-commutative72.0%
+-commutative72.0%
distribute-lft-in72.0%
*-commutative72.0%
mul-1-neg72.0%
unsub-neg72.0%
*-commutative72.0%
Simplified72.0%
Taylor expanded in t around 0 68.2%
Final simplification74.5%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -3e+21) (not (<= t 4.8e+31))) (- (+ z x) (* t (- a b))) (+ (+ a x) (* z (- 1.0 y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -3e+21) || !(t <= 4.8e+31)) {
tmp = (z + x) - (t * (a - b));
} 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 ((t <= (-3d+21)) .or. (.not. (t <= 4.8d+31))) then
tmp = (z + x) - (t * (a - b))
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 ((t <= -3e+21) || !(t <= 4.8e+31)) {
tmp = (z + x) - (t * (a - b));
} else {
tmp = (a + x) + (z * (1.0 - y));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -3e+21) or not (t <= 4.8e+31): tmp = (z + x) - (t * (a - b)) else: tmp = (a + x) + (z * (1.0 - y)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -3e+21) || !(t <= 4.8e+31)) tmp = Float64(Float64(z + x) - Float64(t * Float64(a - b))); 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 ((t <= -3e+21) || ~((t <= 4.8e+31))) tmp = (z + x) - (t * (a - b)); else tmp = (a + x) + (z * (1.0 - y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -3e+21], N[Not[LessEqual[t, 4.8e+31]], $MachinePrecision]], N[(N[(z + x), $MachinePrecision] - N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a + x), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3 \cdot 10^{+21} \lor \neg \left(t \leq 4.8 \cdot 10^{+31}\right):\\
\;\;\;\;\left(z + x\right) - t \cdot \left(a - b\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a + x\right) + z \cdot \left(1 - y\right)\\
\end{array}
\end{array}
if t < -3e21 or 4.79999999999999965e31 < t Initial 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 t around inf 95.0%
Taylor expanded in y around 0 85.2%
cancel-sign-sub-inv85.2%
metadata-eval85.2%
*-lft-identity85.2%
+-commutative85.2%
Simplified85.2%
if -3e21 < t < 4.79999999999999965e31Initial 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 a around inf 71.0%
sub-neg71.0%
metadata-eval71.0%
+-commutative71.0%
*-commutative71.0%
+-commutative71.0%
distribute-lft-in71.0%
*-commutative71.0%
mul-1-neg71.0%
unsub-neg71.0%
*-commutative71.0%
Simplified71.0%
Taylor expanded in t around 0 69.0%
Final simplification77.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- z))))
(if (<= y -4.8e+48)
t_1
(if (<= y 1.5e+18)
(+ z x)
(if (or (<= y 2.15e+102) (not (<= y 1.7e+216))) t_1 (* y b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * -z;
double tmp;
if (y <= -4.8e+48) {
tmp = t_1;
} else if (y <= 1.5e+18) {
tmp = z + x;
} else if ((y <= 2.15e+102) || !(y <= 1.7e+216)) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = y * -z
if (y <= (-4.8d+48)) then
tmp = t_1
else if (y <= 1.5d+18) then
tmp = z + x
else if ((y <= 2.15d+102) .or. (.not. (y <= 1.7d+216))) then
tmp = t_1
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * -z;
double tmp;
if (y <= -4.8e+48) {
tmp = t_1;
} else if (y <= 1.5e+18) {
tmp = z + x;
} else if ((y <= 2.15e+102) || !(y <= 1.7e+216)) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * -z tmp = 0 if y <= -4.8e+48: tmp = t_1 elif y <= 1.5e+18: tmp = z + x elif (y <= 2.15e+102) or not (y <= 1.7e+216): tmp = t_1 else: tmp = y * b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(-z)) tmp = 0.0 if (y <= -4.8e+48) tmp = t_1; elseif (y <= 1.5e+18) tmp = Float64(z + x); elseif ((y <= 2.15e+102) || !(y <= 1.7e+216)) tmp = t_1; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * -z; tmp = 0.0; if (y <= -4.8e+48) tmp = t_1; elseif (y <= 1.5e+18) tmp = z + x; elseif ((y <= 2.15e+102) || ~((y <= 1.7e+216))) tmp = t_1; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * (-z)), $MachinePrecision]}, If[LessEqual[y, -4.8e+48], t$95$1, If[LessEqual[y, 1.5e+18], N[(z + x), $MachinePrecision], If[Or[LessEqual[y, 2.15e+102], N[Not[LessEqual[y, 1.7e+216]], $MachinePrecision]], t$95$1, N[(y * b), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(-z\right)\\
\mathbf{if}\;y \leq -4.8 \cdot 10^{+48}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+18}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;y \leq 2.15 \cdot 10^{+102} \lor \neg \left(y \leq 1.7 \cdot 10^{+216}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -4.8000000000000002e48 or 1.5e18 < y < 2.15e102 or 1.70000000000000013e216 < y Initial 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 y around inf 64.5%
Taylor expanded in b around 0 40.3%
mul-1-neg40.3%
distribute-rgt-neg-in40.3%
Simplified40.3%
if -4.8000000000000002e48 < y < 1.5e18Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in t around inf 78.0%
Taylor expanded in t around 0 38.7%
Taylor expanded in y around 0 36.4%
cancel-sign-sub-inv36.4%
metadata-eval36.4%
*-lft-identity36.4%
Simplified36.4%
if 2.15e102 < y < 1.70000000000000013e216Initial program 90.0%
associate-+l-90.0%
*-commutative90.0%
*-commutative90.0%
sub-neg90.0%
metadata-eval90.0%
remove-double-neg90.0%
remove-double-neg90.0%
sub-neg90.0%
metadata-eval90.0%
associate--l+90.0%
Simplified90.0%
Taylor expanded in z around 0 66.1%
Taylor expanded in y around inf 51.6%
Final simplification38.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -4e+60) (not (<= y 3.4e+90))) (* y (- b z)) (+ x (* t (- b a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -4e+60) || !(y <= 3.4e+90)) {
tmp = y * (b - z);
} else {
tmp = x + (t * (b - a));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-4d+60)) .or. (.not. (y <= 3.4d+90))) then
tmp = y * (b - z)
else
tmp = x + (t * (b - a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -4e+60) || !(y <= 3.4e+90)) {
tmp = y * (b - z);
} else {
tmp = x + (t * (b - a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -4e+60) or not (y <= 3.4e+90): tmp = y * (b - z) else: tmp = x + (t * (b - a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -4e+60) || !(y <= 3.4e+90)) tmp = Float64(y * Float64(b - z)); else tmp = Float64(x + Float64(t * Float64(b - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -4e+60) || ~((y <= 3.4e+90))) tmp = y * (b - z); else tmp = x + (t * (b - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -4e+60], N[Not[LessEqual[y, 3.4e+90]], $MachinePrecision]], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4 \cdot 10^{+60} \lor \neg \left(y \leq 3.4 \cdot 10^{+90}\right):\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{else}:\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if y < -3.9999999999999998e60 or 3.40000000000000018e90 < y Initial program 89.7%
associate-+l-89.7%
*-commutative89.7%
*-commutative89.7%
sub-neg89.7%
metadata-eval89.7%
remove-double-neg89.7%
remove-double-neg89.7%
sub-neg89.7%
metadata-eval89.7%
associate--l+89.7%
Simplified89.7%
Taylor expanded in y around inf 76.7%
if -3.9999999999999998e60 < y < 3.40000000000000018e90Initial 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 79.0%
Taylor expanded in z around 0 61.2%
Final simplification65.9%
(FPCore (x y z t a b) :precision binary64 (if (<= y -1.35e+56) (* y b) (if (<= y 3.2e+62) x (* y b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -1.35e+56) {
tmp = y * b;
} else if (y <= 3.2e+62) {
tmp = x;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (y <= (-1.35d+56)) then
tmp = y * b
else if (y <= 3.2d+62) then
tmp = x
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -1.35e+56) {
tmp = y * b;
} else if (y <= 3.2e+62) {
tmp = x;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -1.35e+56: tmp = y * b elif y <= 3.2e+62: tmp = x else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -1.35e+56) tmp = Float64(y * b); elseif (y <= 3.2e+62) tmp = x; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -1.35e+56) tmp = y * b; elseif (y <= 3.2e+62) tmp = x; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -1.35e+56], N[(y * b), $MachinePrecision], If[LessEqual[y, 3.2e+62], x, N[(y * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.35 \cdot 10^{+56}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;y \leq 3.2 \cdot 10^{+62}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -1.35000000000000005e56 or 3.19999999999999984e62 < y Initial program 90.7%
associate-+l-90.7%
*-commutative90.7%
*-commutative90.7%
sub-neg90.7%
metadata-eval90.7%
remove-double-neg90.7%
remove-double-neg90.7%
sub-neg90.7%
metadata-eval90.7%
associate--l+90.7%
Simplified90.7%
Taylor expanded in z around 0 57.2%
Taylor expanded in y around inf 36.1%
if -1.35000000000000005e56 < y < 3.19999999999999984e62Initial 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 x around inf 22.0%
Final simplification26.7%
(FPCore (x y z t a b) :precision binary64 (if (<= y -9.4e+55) (* y b) (if (<= y 1.75e+62) (+ z x) (* y b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -9.4e+55) {
tmp = y * b;
} else if (y <= 1.75e+62) {
tmp = z + x;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (y <= (-9.4d+55)) then
tmp = y * b
else if (y <= 1.75d+62) then
tmp = z + x
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -9.4e+55) {
tmp = y * b;
} else if (y <= 1.75e+62) {
tmp = z + x;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -9.4e+55: tmp = y * b elif y <= 1.75e+62: tmp = z + x else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -9.4e+55) tmp = Float64(y * b); elseif (y <= 1.75e+62) tmp = Float64(z + x); else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -9.4e+55) tmp = y * b; elseif (y <= 1.75e+62) tmp = z + x; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -9.4e+55], N[(y * b), $MachinePrecision], If[LessEqual[y, 1.75e+62], N[(z + x), $MachinePrecision], N[(y * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.4 \cdot 10^{+55}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;y \leq 1.75 \cdot 10^{+62}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -9.4000000000000001e55 or 1.74999999999999992e62 < 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 z around 0 56.6%
Taylor expanded in y around inf 35.7%
if -9.4000000000000001e55 < y < 1.74999999999999992e62Initial 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 79.4%
Taylor expanded in t around 0 40.1%
Taylor expanded in y around 0 33.9%
cancel-sign-sub-inv33.9%
metadata-eval33.9%
*-lft-identity33.9%
Simplified33.9%
Final simplification34.5%
(FPCore (x y z t a b) :precision binary64 (if (<= x -5.9e+29) x (if (<= x 9.5e+52) a x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -5.9e+29) {
tmp = x;
} else if (x <= 9.5e+52) {
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.9d+29)) then
tmp = x
else if (x <= 9.5d+52) 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.9e+29) {
tmp = x;
} else if (x <= 9.5e+52) {
tmp = a;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -5.9e+29: tmp = x elif x <= 9.5e+52: tmp = a else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -5.9e+29) tmp = x; elseif (x <= 9.5e+52) 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.9e+29) tmp = x; elseif (x <= 9.5e+52) tmp = a; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -5.9e+29], x, If[LessEqual[x, 9.5e+52], a, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.9 \cdot 10^{+29}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{+52}:\\
\;\;\;\;a\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -5.8999999999999999e29 or 9.49999999999999994e52 < x Initial program 94.6%
associate-+l-94.6%
*-commutative94.6%
*-commutative94.6%
sub-neg94.6%
metadata-eval94.6%
remove-double-neg94.6%
remove-double-neg94.6%
sub-neg94.6%
metadata-eval94.6%
associate--l+94.6%
Simplified94.6%
Taylor expanded in x around inf 31.5%
if -5.8999999999999999e29 < x < 9.49999999999999994e52Initial 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 a around inf 42.6%
Taylor expanded in t around 0 17.5%
Final simplification23.7%
(FPCore (x y z t a b) :precision binary64 a)
double code(double x, double y, double z, double t, double a, double b) {
return a;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return a;
}
def code(x, y, z, t, a, b): return a
function code(x, y, z, t, a, b) return a end
function tmp = code(x, y, z, t, a, b) tmp = a; end
code[x_, y_, z_, t_, a_, b_] := a
\begin{array}{l}
\\
a
\end{array}
Initial program 96.9%
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 a around inf 32.3%
Taylor expanded in t around 0 11.8%
Final simplification11.8%
herbie shell --seed 2023199
(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)))