
(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 (- 1.0 t))))
(if (<= (+ (+ t_1 (- x (* (+ y -1.0) z))) (* b (- (+ t y) 2.0))) INFINITY)
(+ (+ x (- z (* y z))) (+ (* b (+ y (- t 2.0))) t_1))
(* y (- b z)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double tmp;
if (((t_1 + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0))) <= ((double) INFINITY)) {
tmp = (x + (z - (y * z))) + ((b * (y + (t - 2.0))) + t_1);
} else {
tmp = y * (b - z);
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double tmp;
if (((t_1 + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0))) <= Double.POSITIVE_INFINITY) {
tmp = (x + (z - (y * z))) + ((b * (y + (t - 2.0))) + t_1);
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) tmp = 0 if ((t_1 + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0))) <= math.inf: tmp = (x + (z - (y * z))) + ((b * (y + (t - 2.0))) + t_1) else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(1.0 - t)) tmp = 0.0 if (Float64(Float64(t_1 + Float64(x - Float64(Float64(y + -1.0) * z))) + Float64(b * Float64(Float64(t + y) - 2.0))) <= Inf) tmp = Float64(Float64(x + Float64(z - Float64(y * z))) + Float64(Float64(b * Float64(y + Float64(t - 2.0))) + t_1)); else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (1.0 - t); tmp = 0.0; if (((t_1 + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0))) <= Inf) tmp = (x + (z - (y * z))) + ((b * (y + (t - 2.0))) + t_1); else tmp = y * (b - z); 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[N[(N[(t$95$1 + N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(x + N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(b * N[(y + N[(t - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;\left(t_1 + \left(x - \left(y + -1\right) \cdot z\right)\right) + b \cdot \left(\left(t + y\right) - 2\right) \leq \infty:\\
\;\;\;\;\left(x + \left(z - y \cdot z\right)\right) + \left(b \cdot \left(y + \left(t - 2\right)\right) + t_1\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) < +inf.0Initial program 100.0%
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 0 100.0%
mul-1-neg100.0%
unsub-neg100.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 y around inf 62.2%
Final simplification98.1%
(FPCore (x y z t a b) :precision binary64 (fma (+ t (- y 2.0)) b (- x (fma (+ y -1.0) z (* a (+ t -1.0))))))
double code(double x, double y, double z, double t, double a, double b) {
return fma((t + (y - 2.0)), b, (x - fma((y + -1.0), z, (a * (t + -1.0)))));
}
function code(x, y, z, t, a, b) return fma(Float64(t + Float64(y - 2.0)), b, Float64(x - fma(Float64(y + -1.0), z, Float64(a * Float64(t + -1.0))))) end
code[x_, y_, z_, t_, a_, b_] := N[(N[(t + N[(y - 2.0), $MachinePrecision]), $MachinePrecision] * b + N[(x - N[(N[(y + -1.0), $MachinePrecision] * z + N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(t + \left(y - 2\right), b, x - \mathsf{fma}\left(y + -1, z, a \cdot \left(t + -1\right)\right)\right)
\end{array}
Initial program 94.9%
+-commutative94.9%
fma-def96.5%
+-commutative96.5%
associate--l+96.5%
sub-neg96.5%
associate-+l-96.5%
fma-neg96.9%
sub-neg96.9%
metadata-eval96.9%
distribute-lft-neg-in96.9%
distribute-lft-neg-in96.9%
remove-double-neg96.9%
sub-neg96.9%
metadata-eval96.9%
Simplified96.9%
Final simplification96.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1
(+ (+ (* a (- 1.0 t)) (- x (* (+ y -1.0) z))) (* b (- (+ t y) 2.0)))))
(if (<= t_1 INFINITY) t_1 (* y (- b z)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((a * (1.0 - t)) + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = y * (b - z);
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((a * (1.0 - t)) + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = ((a * (1.0 - t)) + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0)) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(a * Float64(1.0 - t)) + Float64(x - Float64(Float64(y + -1.0) * z))) + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = ((a * (1.0 - t)) + (x - ((y + -1.0) * z))) + (b * ((t + y) - 2.0)); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = y * (b - z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision] + N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot \left(1 - t\right) + \left(x - \left(y + -1\right) \cdot z\right)\right) + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) < +inf.0Initial program 100.0%
if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) Initial program 0.0%
associate-+l-0.0%
*-commutative0.0%
*-commutative0.0%
sub-neg0.0%
metadata-eval0.0%
remove-double-neg0.0%
remove-double-neg0.0%
sub-neg0.0%
metadata-eval0.0%
associate--l+0.0%
Simplified0.0%
Taylor expanded in y around inf 62.2%
Final simplification98.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (- x (* (+ y -1.0) z)) (* t (- b a))))
(t_2 (* b (- (+ t y) 2.0))))
(if (<= b -4e+194)
t_2
(if (<= b -9.2e-244)
t_1
(if (<= b 4.2e-216)
(+ (* a (- 1.0 t)) (+ x z))
(if (<= b 9.2e+117) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x - ((y + -1.0) * z)) + (t * (b - a));
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -4e+194) {
tmp = t_2;
} else if (b <= -9.2e-244) {
tmp = t_1;
} else if (b <= 4.2e-216) {
tmp = (a * (1.0 - t)) + (x + z);
} else if (b <= 9.2e+117) {
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 - ((y + (-1.0d0)) * z)) + (t * (b - a))
t_2 = b * ((t + y) - 2.0d0)
if (b <= (-4d+194)) then
tmp = t_2
else if (b <= (-9.2d-244)) then
tmp = t_1
else if (b <= 4.2d-216) then
tmp = (a * (1.0d0 - t)) + (x + z)
else if (b <= 9.2d+117) 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 - ((y + -1.0) * z)) + (t * (b - a));
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -4e+194) {
tmp = t_2;
} else if (b <= -9.2e-244) {
tmp = t_1;
} else if (b <= 4.2e-216) {
tmp = (a * (1.0 - t)) + (x + z);
} else if (b <= 9.2e+117) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x - ((y + -1.0) * z)) + (t * (b - a)) t_2 = b * ((t + y) - 2.0) tmp = 0 if b <= -4e+194: tmp = t_2 elif b <= -9.2e-244: tmp = t_1 elif b <= 4.2e-216: tmp = (a * (1.0 - t)) + (x + z) elif b <= 9.2e+117: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + Float64(t * Float64(b - a))) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -4e+194) tmp = t_2; elseif (b <= -9.2e-244) tmp = t_1; elseif (b <= 4.2e-216) tmp = Float64(Float64(a * Float64(1.0 - t)) + Float64(x + z)); elseif (b <= 9.2e+117) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x - ((y + -1.0) * z)) + (t * (b - a)); t_2 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -4e+194) tmp = t_2; elseif (b <= -9.2e-244) tmp = t_1; elseif (b <= 4.2e-216) tmp = (a * (1.0 - t)) + (x + z); elseif (b <= 9.2e+117) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4e+194], t$95$2, If[LessEqual[b, -9.2e-244], t$95$1, If[LessEqual[b, 4.2e-216], N[(N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.2e+117], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x - \left(y + -1\right) \cdot z\right) + t \cdot \left(b - a\right)\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -4 \cdot 10^{+194}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -9.2 \cdot 10^{-244}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 4.2 \cdot 10^{-216}:\\
\;\;\;\;a \cdot \left(1 - t\right) + \left(x + z\right)\\
\mathbf{elif}\;b \leq 9.2 \cdot 10^{+117}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -3.99999999999999978e194 or 9.19999999999999951e117 < b Initial program 83.9%
associate-+l-83.9%
*-commutative83.9%
*-commutative83.9%
sub-neg83.9%
metadata-eval83.9%
remove-double-neg83.9%
remove-double-neg83.9%
sub-neg83.9%
metadata-eval83.9%
associate--l+83.9%
Simplified83.9%
Taylor expanded in b around inf 87.0%
if -3.99999999999999978e194 < b < -9.2e-244 or 4.2000000000000003e-216 < b < 9.19999999999999951e117Initial program 98.2%
associate-+l-98.2%
*-commutative98.2%
*-commutative98.2%
sub-neg98.2%
metadata-eval98.2%
remove-double-neg98.2%
remove-double-neg98.2%
sub-neg98.2%
metadata-eval98.2%
associate--l+98.2%
Simplified98.2%
Taylor expanded in t around inf 80.1%
if -9.2e-244 < b < 4.2000000000000003e-216Initial program 97.2%
associate-+l-97.2%
*-commutative97.2%
*-commutative97.2%
sub-neg97.2%
metadata-eval97.2%
remove-double-neg97.2%
remove-double-neg97.2%
sub-neg97.2%
metadata-eval97.2%
associate--l+97.2%
Simplified97.2%
Taylor expanded in y around 0 97.2%
mul-1-neg97.2%
unsub-neg97.2%
Simplified97.2%
Taylor expanded in y around 0 94.5%
Taylor expanded in b around 0 94.5%
Final simplification83.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (- x (* (+ y -1.0) z)) (* t a))) (t_2 (* b (- (+ t y) 2.0))))
(if (<= b -1.6e+143)
t_2
(if (<= b -7.4e-240)
t_1
(if (<= b 4.2e-216)
(+ (* a (- 1.0 t)) (+ x z))
(if (<= b 1.8e+116) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x - ((y + -1.0) * z)) - (t * a);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -1.6e+143) {
tmp = t_2;
} else if (b <= -7.4e-240) {
tmp = t_1;
} else if (b <= 4.2e-216) {
tmp = (a * (1.0 - t)) + (x + z);
} else if (b <= 1.8e+116) {
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 - ((y + (-1.0d0)) * z)) - (t * a)
t_2 = b * ((t + y) - 2.0d0)
if (b <= (-1.6d+143)) then
tmp = t_2
else if (b <= (-7.4d-240)) then
tmp = t_1
else if (b <= 4.2d-216) then
tmp = (a * (1.0d0 - t)) + (x + z)
else if (b <= 1.8d+116) 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 - ((y + -1.0) * z)) - (t * a);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -1.6e+143) {
tmp = t_2;
} else if (b <= -7.4e-240) {
tmp = t_1;
} else if (b <= 4.2e-216) {
tmp = (a * (1.0 - t)) + (x + z);
} else if (b <= 1.8e+116) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x - ((y + -1.0) * z)) - (t * a) t_2 = b * ((t + y) - 2.0) tmp = 0 if b <= -1.6e+143: tmp = t_2 elif b <= -7.4e-240: tmp = t_1 elif b <= 4.2e-216: tmp = (a * (1.0 - t)) + (x + z) elif b <= 1.8e+116: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) - Float64(t * a)) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -1.6e+143) tmp = t_2; elseif (b <= -7.4e-240) tmp = t_1; elseif (b <= 4.2e-216) tmp = Float64(Float64(a * Float64(1.0 - t)) + Float64(x + z)); elseif (b <= 1.8e+116) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x - ((y + -1.0) * z)) - (t * a); t_2 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -1.6e+143) tmp = t_2; elseif (b <= -7.4e-240) tmp = t_1; elseif (b <= 4.2e-216) tmp = (a * (1.0 - t)) + (x + z); elseif (b <= 1.8e+116) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.6e+143], t$95$2, If[LessEqual[b, -7.4e-240], t$95$1, If[LessEqual[b, 4.2e-216], N[(N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.8e+116], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x - \left(y + -1\right) \cdot z\right) - t \cdot a\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -1.6 \cdot 10^{+143}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -7.4 \cdot 10^{-240}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 4.2 \cdot 10^{-216}:\\
\;\;\;\;a \cdot \left(1 - t\right) + \left(x + z\right)\\
\mathbf{elif}\;b \leq 1.8 \cdot 10^{+116}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -1.60000000000000008e143 or 1.79999999999999985e116 < b Initial program 86.5%
associate-+l-86.5%
*-commutative86.5%
*-commutative86.5%
sub-neg86.5%
metadata-eval86.5%
remove-double-neg86.5%
remove-double-neg86.5%
sub-neg86.5%
metadata-eval86.5%
associate--l+86.5%
Simplified86.5%
Taylor expanded in b around inf 81.9%
if -1.60000000000000008e143 < b < -7.4000000000000003e-240 or 4.2000000000000003e-216 < b < 1.79999999999999985e116Initial program 98.0%
associate-+l-98.0%
*-commutative98.0%
*-commutative98.0%
sub-neg98.0%
metadata-eval98.0%
remove-double-neg98.0%
remove-double-neg98.0%
sub-neg98.0%
metadata-eval98.0%
associate--l+98.0%
Simplified98.0%
Taylor expanded in t around inf 81.2%
Taylor expanded in a around inf 75.9%
*-commutative75.9%
Simplified75.9%
if -7.4000000000000003e-240 < b < 4.2000000000000003e-216Initial program 97.2%
associate-+l-97.2%
*-commutative97.2%
*-commutative97.2%
sub-neg97.2%
metadata-eval97.2%
remove-double-neg97.2%
remove-double-neg97.2%
sub-neg97.2%
metadata-eval97.2%
associate--l+97.2%
Simplified97.2%
Taylor expanded in y around 0 97.2%
mul-1-neg97.2%
unsub-neg97.2%
Simplified97.2%
Taylor expanded in y around 0 94.5%
Taylor expanded in b around 0 94.5%
Final simplification80.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (* (+ y -1.0) z))) (t_2 (* b (- (+ t y) 2.0))))
(if (<= b -3.2e+192)
t_2
(if (<= b -2.02e-81)
(+ t_1 (* t (- b a)))
(if (<= b 1.9e+116) (+ t_1 (- a (* t a))) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - ((y + -1.0) * z);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -3.2e+192) {
tmp = t_2;
} else if (b <= -2.02e-81) {
tmp = t_1 + (t * (b - a));
} else if (b <= 1.9e+116) {
tmp = t_1 + (a - (t * a));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x - ((y + (-1.0d0)) * z)
t_2 = b * ((t + y) - 2.0d0)
if (b <= (-3.2d+192)) then
tmp = t_2
else if (b <= (-2.02d-81)) then
tmp = t_1 + (t * (b - a))
else if (b <= 1.9d+116) then
tmp = t_1 + (a - (t * a))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - ((y + -1.0) * z);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -3.2e+192) {
tmp = t_2;
} else if (b <= -2.02e-81) {
tmp = t_1 + (t * (b - a));
} else if (b <= 1.9e+116) {
tmp = t_1 + (a - (t * a));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x - ((y + -1.0) * z) t_2 = b * ((t + y) - 2.0) tmp = 0 if b <= -3.2e+192: tmp = t_2 elif b <= -2.02e-81: tmp = t_1 + (t * (b - a)) elif b <= 1.9e+116: tmp = t_1 + (a - (t * a)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x - Float64(Float64(y + -1.0) * z)) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -3.2e+192) tmp = t_2; elseif (b <= -2.02e-81) tmp = Float64(t_1 + Float64(t * Float64(b - a))); elseif (b <= 1.9e+116) tmp = Float64(t_1 + Float64(a - Float64(t * a))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x - ((y + -1.0) * z); t_2 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -3.2e+192) tmp = t_2; elseif (b <= -2.02e-81) tmp = t_1 + (t * (b - a)); elseif (b <= 1.9e+116) tmp = t_1 + (a - (t * a)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.2e+192], t$95$2, If[LessEqual[b, -2.02e-81], N[(t$95$1 + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.9e+116], N[(t$95$1 + N[(a - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \left(y + -1\right) \cdot z\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -3.2 \cdot 10^{+192}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -2.02 \cdot 10^{-81}:\\
\;\;\;\;t_1 + t \cdot \left(b - a\right)\\
\mathbf{elif}\;b \leq 1.9 \cdot 10^{+116}:\\
\;\;\;\;t_1 + \left(a - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -3.20000000000000023e192 or 1.8999999999999999e116 < b Initial program 83.9%
associate-+l-83.9%
*-commutative83.9%
*-commutative83.9%
sub-neg83.9%
metadata-eval83.9%
remove-double-neg83.9%
remove-double-neg83.9%
sub-neg83.9%
metadata-eval83.9%
associate--l+83.9%
Simplified83.9%
Taylor expanded in b around inf 87.0%
if -3.20000000000000023e192 < b < -2.02000000000000006e-81Initial program 96.6%
associate-+l-96.6%
*-commutative96.6%
*-commutative96.6%
sub-neg96.6%
metadata-eval96.6%
remove-double-neg96.6%
remove-double-neg96.6%
sub-neg96.6%
metadata-eval96.6%
associate--l+96.6%
Simplified96.6%
Taylor expanded in t around inf 74.1%
if -2.02000000000000006e-81 < b < 1.8999999999999999e116Initial 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 92.7%
sub-neg92.7%
metadata-eval92.7%
+-commutative92.7%
*-commutative92.7%
+-commutative92.7%
distribute-rgt-in92.7%
fma-def92.7%
mul-1-neg92.7%
fma-neg92.7%
Simplified92.7%
Final simplification87.2%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.05e-135)
(+ (* a (- 1.0 t)) (+ z (+ x (* b (- t 2.0)))))
(if (<= b 1.05e+117)
(+ (- x (* (+ y -1.0) z)) (- a (* t a)))
(* b (- (+ t y) 2.0)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.05e-135) {
tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0))));
} else if (b <= 1.05e+117) {
tmp = (x - ((y + -1.0) * z)) + (a - (t * a));
} else {
tmp = b * ((t + y) - 2.0);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-2.05d-135)) then
tmp = (a * (1.0d0 - t)) + (z + (x + (b * (t - 2.0d0))))
else if (b <= 1.05d+117) then
tmp = (x - ((y + (-1.0d0)) * z)) + (a - (t * a))
else
tmp = b * ((t + y) - 2.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.05e-135) {
tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0))));
} else if (b <= 1.05e+117) {
tmp = (x - ((y + -1.0) * z)) + (a - (t * a));
} else {
tmp = b * ((t + y) - 2.0);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.05e-135: tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0)))) elif b <= 1.05e+117: tmp = (x - ((y + -1.0) * z)) + (a - (t * a)) else: tmp = b * ((t + y) - 2.0) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.05e-135) tmp = Float64(Float64(a * Float64(1.0 - t)) + Float64(z + Float64(x + Float64(b * Float64(t - 2.0))))); elseif (b <= 1.05e+117) tmp = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + Float64(a - Float64(t * a))); else tmp = Float64(b * Float64(Float64(t + y) - 2.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.05e-135) tmp = (a * (1.0 - t)) + (z + (x + (b * (t - 2.0)))); elseif (b <= 1.05e+117) tmp = (x - ((y + -1.0) * z)) + (a - (t * a)); else tmp = b * ((t + y) - 2.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.05e-135], N[(N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision] + N[(z + N[(x + N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.05e+117], N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(a - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.05 \cdot 10^{-135}:\\
\;\;\;\;a \cdot \left(1 - t\right) + \left(z + \left(x + b \cdot \left(t - 2\right)\right)\right)\\
\mathbf{elif}\;b \leq 1.05 \cdot 10^{+117}:\\
\;\;\;\;\left(x - \left(y + -1\right) \cdot z\right) + \left(a - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\end{array}
\end{array}
if b < -2.05000000000000005e-135Initial program 94.9%
sub-neg94.9%
+-commutative94.9%
associate-+l+94.9%
*-commutative94.9%
distribute-rgt-neg-in94.9%
+-commutative94.9%
fma-def94.9%
neg-sub094.9%
associate--r-94.9%
neg-sub094.9%
+-commutative94.9%
sub-neg94.9%
fma-def95.9%
sub-neg95.9%
associate-+l+95.9%
metadata-eval95.9%
sub-neg95.9%
+-commutative95.9%
Simplified95.9%
Taylor expanded in y around 0 79.1%
if -2.05000000000000005e-135 < b < 1.0500000000000001e117Initial program 98.4%
associate-+l-98.4%
*-commutative98.4%
*-commutative98.4%
sub-neg98.4%
metadata-eval98.4%
remove-double-neg98.4%
remove-double-neg98.4%
sub-neg98.4%
metadata-eval98.4%
associate--l+98.4%
Simplified98.4%
Taylor expanded in a around inf 93.3%
sub-neg93.3%
metadata-eval93.3%
+-commutative93.3%
*-commutative93.3%
+-commutative93.3%
distribute-rgt-in93.3%
fma-def93.3%
mul-1-neg93.3%
fma-neg93.3%
Simplified93.3%
if 1.0500000000000001e117 < b Initial program 81.2%
associate-+l-81.2%
*-commutative81.2%
*-commutative81.2%
sub-neg81.2%
metadata-eval81.2%
remove-double-neg81.2%
remove-double-neg81.2%
sub-neg81.2%
metadata-eval81.2%
associate--l+81.2%
Simplified81.2%
Taylor expanded in b around inf 83.3%
Final simplification86.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (* t a))) (t_2 (* b (- (+ t y) 2.0))))
(if (<= b -3e+122)
t_2
(if (<= b -3.7e-150)
t_1
(if (<= b -3.6e-206) (- x (* y z)) (if (<= b 1.7e+116) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - (t * a);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -3e+122) {
tmp = t_2;
} else if (b <= -3.7e-150) {
tmp = t_1;
} else if (b <= -3.6e-206) {
tmp = x - (y * z);
} else if (b <= 1.7e+116) {
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 * a)
t_2 = b * ((t + y) - 2.0d0)
if (b <= (-3d+122)) then
tmp = t_2
else if (b <= (-3.7d-150)) then
tmp = t_1
else if (b <= (-3.6d-206)) then
tmp = x - (y * z)
else if (b <= 1.7d+116) 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 * a);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -3e+122) {
tmp = t_2;
} else if (b <= -3.7e-150) {
tmp = t_1;
} else if (b <= -3.6e-206) {
tmp = x - (y * z);
} else if (b <= 1.7e+116) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x - (t * a) t_2 = b * ((t + y) - 2.0) tmp = 0 if b <= -3e+122: tmp = t_2 elif b <= -3.7e-150: tmp = t_1 elif b <= -3.6e-206: tmp = x - (y * z) elif b <= 1.7e+116: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x - Float64(t * a)) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -3e+122) tmp = t_2; elseif (b <= -3.7e-150) tmp = t_1; elseif (b <= -3.6e-206) tmp = Float64(x - Float64(y * z)); elseif (b <= 1.7e+116) 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 * a); t_2 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -3e+122) tmp = t_2; elseif (b <= -3.7e-150) tmp = t_1; elseif (b <= -3.6e-206) tmp = x - (y * z); elseif (b <= 1.7e+116) 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 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3e+122], t$95$2, If[LessEqual[b, -3.7e-150], t$95$1, If[LessEqual[b, -3.6e-206], N[(x - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.7e+116], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - t \cdot a\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -3 \cdot 10^{+122}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -3.7 \cdot 10^{-150}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -3.6 \cdot 10^{-206}:\\
\;\;\;\;x - y \cdot z\\
\mathbf{elif}\;b \leq 1.7 \cdot 10^{+116}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -2.99999999999999986e122 or 1.70000000000000011e116 < b Initial program 86.5%
associate-+l-86.5%
*-commutative86.5%
*-commutative86.5%
sub-neg86.5%
metadata-eval86.5%
remove-double-neg86.5%
remove-double-neg86.5%
sub-neg86.5%
metadata-eval86.5%
associate--l+86.5%
Simplified86.5%
Taylor expanded in b around inf 79.7%
if -2.99999999999999986e122 < b < -3.70000000000000001e-150 or -3.59999999999999994e-206 < b < 1.70000000000000011e116Initial program 98.2%
associate-+l-98.2%
*-commutative98.2%
*-commutative98.2%
sub-neg98.2%
metadata-eval98.2%
remove-double-neg98.2%
remove-double-neg98.2%
sub-neg98.2%
metadata-eval98.2%
associate--l+98.2%
Simplified98.2%
Taylor expanded in t around inf 80.5%
Taylor expanded in a around inf 76.3%
*-commutative76.3%
Simplified76.3%
Taylor expanded in z around 0 56.8%
*-commutative56.8%
Simplified56.8%
if -3.70000000000000001e-150 < b < -3.59999999999999994e-206Initial 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 74.7%
Taylor expanded in t around 0 61.2%
Taylor expanded in y around inf 61.0%
Final simplification63.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* t (- b a)))) (t_2 (* b (- (+ t y) 2.0))))
(if (<= b -8.8e+149)
t_2
(if (<= b -6.2e-150)
t_1
(if (<= b -2.2e-205) (- x (* y z)) (if (<= b 1.55e+117) 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 = b * ((t + y) - 2.0);
double tmp;
if (b <= -8.8e+149) {
tmp = t_2;
} else if (b <= -6.2e-150) {
tmp = t_1;
} else if (b <= -2.2e-205) {
tmp = x - (y * z);
} else if (b <= 1.55e+117) {
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 = b * ((t + y) - 2.0d0)
if (b <= (-8.8d+149)) then
tmp = t_2
else if (b <= (-6.2d-150)) then
tmp = t_1
else if (b <= (-2.2d-205)) then
tmp = x - (y * z)
else if (b <= 1.55d+117) 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 = b * ((t + y) - 2.0);
double tmp;
if (b <= -8.8e+149) {
tmp = t_2;
} else if (b <= -6.2e-150) {
tmp = t_1;
} else if (b <= -2.2e-205) {
tmp = x - (y * z);
} else if (b <= 1.55e+117) {
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 = b * ((t + y) - 2.0) tmp = 0 if b <= -8.8e+149: tmp = t_2 elif b <= -6.2e-150: tmp = t_1 elif b <= -2.2e-205: tmp = x - (y * z) elif b <= 1.55e+117: 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(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -8.8e+149) tmp = t_2; elseif (b <= -6.2e-150) tmp = t_1; elseif (b <= -2.2e-205) tmp = Float64(x - Float64(y * z)); elseif (b <= 1.55e+117) 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 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -8.8e+149) tmp = t_2; elseif (b <= -6.2e-150) tmp = t_1; elseif (b <= -2.2e-205) tmp = x - (y * z); elseif (b <= 1.55e+117) 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[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -8.8e+149], t$95$2, If[LessEqual[b, -6.2e-150], t$95$1, If[LessEqual[b, -2.2e-205], N[(x - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.55e+117], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \left(b - a\right)\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -8.8 \cdot 10^{+149}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -6.2 \cdot 10^{-150}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -2.2 \cdot 10^{-205}:\\
\;\;\;\;x - y \cdot z\\
\mathbf{elif}\;b \leq 1.55 \cdot 10^{+117}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -8.8e149 or 1.54999999999999988e117 < b Initial program 86.3%
associate-+l-86.3%
*-commutative86.3%
*-commutative86.3%
sub-neg86.3%
metadata-eval86.3%
remove-double-neg86.3%
remove-double-neg86.3%
sub-neg86.3%
metadata-eval86.3%
associate--l+86.3%
Simplified86.3%
Taylor expanded in b around inf 81.7%
if -8.8e149 < b < -6.19999999999999996e-150 or -2.20000000000000009e-205 < b < 1.54999999999999988e117Initial program 97.7%
associate-+l-97.7%
*-commutative97.7%
*-commutative97.7%
sub-neg97.7%
metadata-eval97.7%
remove-double-neg97.7%
remove-double-neg97.7%
sub-neg97.7%
metadata-eval97.7%
associate--l+97.7%
Simplified97.7%
Taylor expanded in t around inf 80.8%
Taylor expanded in z around 0 61.2%
if -6.19999999999999996e-150 < b < -2.20000000000000009e-205Initial 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 74.7%
Taylor expanded in t around 0 61.2%
Taylor expanded in y around inf 61.0%
Final simplification66.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (* (+ y -1.0) z))) (t_2 (+ x (* t (- b a)))))
(if (<= t -2.3e+20)
t_2
(if (<= t -1.85e-193)
t_1
(if (<= t 8e-249) (* (- y 2.0) b) (if (<= t 2.8e+15) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - ((y + -1.0) * z);
double t_2 = x + (t * (b - a));
double tmp;
if (t <= -2.3e+20) {
tmp = t_2;
} else if (t <= -1.85e-193) {
tmp = t_1;
} else if (t <= 8e-249) {
tmp = (y - 2.0) * b;
} else if (t <= 2.8e+15) {
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 - ((y + (-1.0d0)) * z)
t_2 = x + (t * (b - a))
if (t <= (-2.3d+20)) then
tmp = t_2
else if (t <= (-1.85d-193)) then
tmp = t_1
else if (t <= 8d-249) then
tmp = (y - 2.0d0) * b
else if (t <= 2.8d+15) 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 - ((y + -1.0) * z);
double t_2 = x + (t * (b - a));
double tmp;
if (t <= -2.3e+20) {
tmp = t_2;
} else if (t <= -1.85e-193) {
tmp = t_1;
} else if (t <= 8e-249) {
tmp = (y - 2.0) * b;
} else if (t <= 2.8e+15) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x - ((y + -1.0) * z) t_2 = x + (t * (b - a)) tmp = 0 if t <= -2.3e+20: tmp = t_2 elif t <= -1.85e-193: tmp = t_1 elif t <= 8e-249: tmp = (y - 2.0) * b elif t <= 2.8e+15: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x - Float64(Float64(y + -1.0) * z)) t_2 = Float64(x + Float64(t * Float64(b - a))) tmp = 0.0 if (t <= -2.3e+20) tmp = t_2; elseif (t <= -1.85e-193) tmp = t_1; elseif (t <= 8e-249) tmp = Float64(Float64(y - 2.0) * b); elseif (t <= 2.8e+15) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x - ((y + -1.0) * z); t_2 = x + (t * (b - a)); tmp = 0.0; if (t <= -2.3e+20) tmp = t_2; elseif (t <= -1.85e-193) tmp = t_1; elseif (t <= 8e-249) tmp = (y - 2.0) * b; elseif (t <= 2.8e+15) 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[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.3e+20], t$95$2, If[LessEqual[t, -1.85e-193], t$95$1, If[LessEqual[t, 8e-249], N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[t, 2.8e+15], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \left(y + -1\right) \cdot z\\
t_2 := x + t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.3 \cdot 10^{+20}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.85 \cdot 10^{-193}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-249}:\\
\;\;\;\;\left(y - 2\right) \cdot b\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{+15}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -2.3e20 or 2.8e15 < t Initial program 92.3%
associate-+l-92.3%
*-commutative92.3%
*-commutative92.3%
sub-neg92.3%
metadata-eval92.3%
remove-double-neg92.3%
remove-double-neg92.3%
sub-neg92.3%
metadata-eval92.3%
associate--l+92.3%
Simplified92.3%
Taylor expanded in t around inf 94.9%
Taylor expanded in z around 0 83.3%
if -2.3e20 < t < -1.8500000000000001e-193 or 8.00000000000000043e-249 < t < 2.8e15Initial program 97.0%
associate-+l-97.0%
*-commutative97.0%
*-commutative97.0%
sub-neg97.0%
metadata-eval97.0%
remove-double-neg97.0%
remove-double-neg97.0%
sub-neg97.0%
metadata-eval97.0%
associate--l+97.0%
Simplified97.0%
Taylor expanded in t around inf 59.5%
Taylor expanded in t around 0 57.8%
if -1.8500000000000001e-193 < t < 8.00000000000000043e-249Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in b around inf 52.5%
Taylor expanded in t around 0 52.5%
Final simplification68.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))))
(if (<= y -2.65e+147)
t_1
(if (<= y -8.5e-154)
(- (+ x z) (* t a))
(if (<= y 4.2e+59) (+ (* b (- t 2.0)) (+ x z)) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double tmp;
if (y <= -2.65e+147) {
tmp = t_1;
} else if (y <= -8.5e-154) {
tmp = (x + z) - (t * a);
} else if (y <= 4.2e+59) {
tmp = (b * (t - 2.0)) + (x + z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = y * (b - z)
if (y <= (-2.65d+147)) then
tmp = t_1
else if (y <= (-8.5d-154)) then
tmp = (x + z) - (t * a)
else if (y <= 4.2d+59) then
tmp = (b * (t - 2.0d0)) + (x + z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double tmp;
if (y <= -2.65e+147) {
tmp = t_1;
} else if (y <= -8.5e-154) {
tmp = (x + z) - (t * a);
} else if (y <= 4.2e+59) {
tmp = (b * (t - 2.0)) + (x + z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * (b - z) tmp = 0 if y <= -2.65e+147: tmp = t_1 elif y <= -8.5e-154: tmp = (x + z) - (t * a) elif y <= 4.2e+59: tmp = (b * (t - 2.0)) + (x + z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(b - z)) tmp = 0.0 if (y <= -2.65e+147) tmp = t_1; elseif (y <= -8.5e-154) tmp = Float64(Float64(x + z) - Float64(t * a)); elseif (y <= 4.2e+59) tmp = Float64(Float64(b * Float64(t - 2.0)) + Float64(x + z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * (b - z); tmp = 0.0; if (y <= -2.65e+147) tmp = t_1; elseif (y <= -8.5e-154) tmp = (x + z) - (t * a); elseif (y <= 4.2e+59) tmp = (b * (t - 2.0)) + (x + z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.65e+147], t$95$1, If[LessEqual[y, -8.5e-154], N[(N[(x + z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.2e+59], N[(N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b - z\right)\\
\mathbf{if}\;y \leq -2.65 \cdot 10^{+147}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -8.5 \cdot 10^{-154}:\\
\;\;\;\;\left(x + z\right) - t \cdot a\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{+59}:\\
\;\;\;\;b \cdot \left(t - 2\right) + \left(x + z\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -2.6500000000000001e147 or 4.19999999999999968e59 < y Initial program 87.5%
associate-+l-87.5%
*-commutative87.5%
*-commutative87.5%
sub-neg87.5%
metadata-eval87.5%
remove-double-neg87.5%
remove-double-neg87.5%
sub-neg87.5%
metadata-eval87.5%
associate--l+87.5%
Simplified87.5%
Taylor expanded in y around inf 67.6%
if -2.6500000000000001e147 < y < -8.4999999999999996e-154Initial program 96.7%
associate-+l-96.7%
*-commutative96.7%
*-commutative96.7%
sub-neg96.7%
metadata-eval96.7%
remove-double-neg96.7%
remove-double-neg96.7%
sub-neg96.7%
metadata-eval96.7%
associate--l+96.7%
Simplified96.7%
Taylor expanded in t around inf 81.1%
Taylor expanded in a around inf 79.5%
*-commutative79.5%
Simplified79.5%
Taylor expanded in y around 0 71.0%
neg-mul-171.0%
sub-neg71.0%
remove-double-neg71.0%
+-commutative71.0%
Simplified71.0%
if -8.4999999999999996e-154 < y < 4.19999999999999968e59Initial program 99.1%
associate-+l-99.1%
*-commutative99.1%
*-commutative99.1%
sub-neg99.1%
metadata-eval99.1%
remove-double-neg99.1%
remove-double-neg99.1%
sub-neg99.1%
metadata-eval99.1%
associate--l+99.1%
Simplified99.1%
Taylor expanded in y around 0 99.1%
mul-1-neg99.1%
unsub-neg99.1%
Simplified99.1%
Taylor expanded in y around 0 97.1%
Taylor expanded in a around 0 73.3%
Final simplification70.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* b (- (+ t y) 2.0))))
(if (<= b -3.1e+148)
t_1
(if (<= b -3.8e-82)
(- (+ x z) (* t (- a b)))
(if (<= b 2.3e+116) (+ (* a (- 1.0 t)) (+ x z)) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = b * ((t + y) - 2.0);
double tmp;
if (b <= -3.1e+148) {
tmp = t_1;
} else if (b <= -3.8e-82) {
tmp = (x + z) - (t * (a - b));
} else if (b <= 2.3e+116) {
tmp = (a * (1.0 - t)) + (x + z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((t + y) - 2.0d0)
if (b <= (-3.1d+148)) then
tmp = t_1
else if (b <= (-3.8d-82)) then
tmp = (x + z) - (t * (a - b))
else if (b <= 2.3d+116) then
tmp = (a * (1.0d0 - t)) + (x + z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = b * ((t + y) - 2.0);
double tmp;
if (b <= -3.1e+148) {
tmp = t_1;
} else if (b <= -3.8e-82) {
tmp = (x + z) - (t * (a - b));
} else if (b <= 2.3e+116) {
tmp = (a * (1.0 - t)) + (x + z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = b * ((t + y) - 2.0) tmp = 0 if b <= -3.1e+148: tmp = t_1 elif b <= -3.8e-82: tmp = (x + z) - (t * (a - b)) elif b <= 2.3e+116: tmp = (a * (1.0 - t)) + (x + z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -3.1e+148) tmp = t_1; elseif (b <= -3.8e-82) tmp = Float64(Float64(x + z) - Float64(t * Float64(a - b))); elseif (b <= 2.3e+116) tmp = Float64(Float64(a * Float64(1.0 - t)) + Float64(x + z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -3.1e+148) tmp = t_1; elseif (b <= -3.8e-82) tmp = (x + z) - (t * (a - b)); elseif (b <= 2.3e+116) tmp = (a * (1.0 - t)) + (x + z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.1e+148], t$95$1, If[LessEqual[b, -3.8e-82], N[(N[(x + z), $MachinePrecision] - N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.3e+116], N[(N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision] + N[(x + z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -3.1 \cdot 10^{+148}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -3.8 \cdot 10^{-82}:\\
\;\;\;\;\left(x + z\right) - t \cdot \left(a - b\right)\\
\mathbf{elif}\;b \leq 2.3 \cdot 10^{+116}:\\
\;\;\;\;a \cdot \left(1 - t\right) + \left(x + z\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if b < -3.09999999999999975e148 or 2.29999999999999995e116 < b Initial program 86.3%
associate-+l-86.3%
*-commutative86.3%
*-commutative86.3%
sub-neg86.3%
metadata-eval86.3%
remove-double-neg86.3%
remove-double-neg86.3%
sub-neg86.3%
metadata-eval86.3%
associate--l+86.3%
Simplified86.3%
Taylor expanded in b around inf 81.7%
if -3.09999999999999975e148 < b < -3.8000000000000002e-82Initial 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 76.6%
Taylor expanded in y around 0 66.8%
neg-mul-150.6%
sub-neg50.6%
remove-double-neg50.6%
+-commutative50.6%
Simplified66.8%
if -3.8000000000000002e-82 < b < 2.29999999999999995e116Initial 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 y around 0 98.6%
mul-1-neg98.6%
unsub-neg98.6%
Simplified98.6%
Taylor expanded in y around 0 82.5%
Taylor expanded in b around 0 78.5%
Final simplification77.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (- 1.0 t))))
(if (<= a -1.75e+82)
t_1
(if (<= a 1.95e-188)
(+ x z)
(if (<= a 1.35e-120)
(* b (- t 2.0))
(if (<= a 2.25e-41) (+ x z) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double tmp;
if (a <= -1.75e+82) {
tmp = t_1;
} else if (a <= 1.95e-188) {
tmp = x + z;
} else if (a <= 1.35e-120) {
tmp = b * (t - 2.0);
} else if (a <= 2.25e-41) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = a * (1.0d0 - t)
if (a <= (-1.75d+82)) then
tmp = t_1
else if (a <= 1.95d-188) then
tmp = x + z
else if (a <= 1.35d-120) then
tmp = b * (t - 2.0d0)
else if (a <= 2.25d-41) then
tmp = x + z
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (1.0 - t);
double tmp;
if (a <= -1.75e+82) {
tmp = t_1;
} else if (a <= 1.95e-188) {
tmp = x + z;
} else if (a <= 1.35e-120) {
tmp = b * (t - 2.0);
} else if (a <= 2.25e-41) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (1.0 - t) tmp = 0 if a <= -1.75e+82: tmp = t_1 elif a <= 1.95e-188: tmp = x + z elif a <= 1.35e-120: tmp = b * (t - 2.0) elif a <= 2.25e-41: tmp = x + z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(1.0 - t)) tmp = 0.0 if (a <= -1.75e+82) tmp = t_1; elseif (a <= 1.95e-188) tmp = Float64(x + z); elseif (a <= 1.35e-120) tmp = Float64(b * Float64(t - 2.0)); elseif (a <= 2.25e-41) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (1.0 - t); tmp = 0.0; if (a <= -1.75e+82) tmp = t_1; elseif (a <= 1.95e-188) tmp = x + z; elseif (a <= 1.35e-120) tmp = b * (t - 2.0); elseif (a <= 2.25e-41) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.75e+82], t$95$1, If[LessEqual[a, 1.95e-188], N[(x + z), $MachinePrecision], If[LessEqual[a, 1.35e-120], N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.25e-41], N[(x + z), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(1 - t\right)\\
\mathbf{if}\;a \leq -1.75 \cdot 10^{+82}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.95 \cdot 10^{-188}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{-120}:\\
\;\;\;\;b \cdot \left(t - 2\right)\\
\mathbf{elif}\;a \leq 2.25 \cdot 10^{-41}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -1.75e82 or 2.25e-41 < a Initial program 94.3%
associate-+l-94.3%
*-commutative94.3%
*-commutative94.3%
sub-neg94.3%
metadata-eval94.3%
remove-double-neg94.3%
remove-double-neg94.3%
sub-neg94.3%
metadata-eval94.3%
associate--l+94.3%
Simplified94.3%
Taylor expanded in a around inf 61.1%
if -1.75e82 < a < 1.94999999999999988e-188 or 1.3499999999999999e-120 < a < 2.25e-41Initial program 95.0%
associate-+l-95.0%
*-commutative95.0%
*-commutative95.0%
sub-neg95.0%
metadata-eval95.0%
remove-double-neg95.0%
remove-double-neg95.0%
sub-neg95.0%
metadata-eval95.0%
associate--l+95.0%
Simplified95.0%
Taylor expanded in t around inf 75.2%
Taylor expanded in t around 0 57.3%
Taylor expanded in y around 0 43.8%
sub-neg43.8%
neg-mul-143.8%
remove-double-neg43.8%
+-commutative43.8%
Simplified43.8%
if 1.94999999999999988e-188 < a < 1.3499999999999999e-120Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 55.5%
Taylor expanded in y around 0 44.8%
Final simplification52.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -1.95e-25)
t_1
(if (<= t -5.8e-243)
(+ x z)
(if (<= t -1.15e-291) (* y b) (if (<= t 4.7e+17) (+ x z) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_1;
} else if (t <= -5.8e-243) {
tmp = x + z;
} else if (t <= -1.15e-291) {
tmp = y * b;
} else if (t <= 4.7e+17) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-1.95d-25)) then
tmp = t_1
else if (t <= (-5.8d-243)) then
tmp = x + z
else if (t <= (-1.15d-291)) then
tmp = y * b
else if (t <= 4.7d+17) then
tmp = x + z
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_1;
} else if (t <= -5.8e-243) {
tmp = x + z;
} else if (t <= -1.15e-291) {
tmp = y * b;
} else if (t <= 4.7e+17) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -1.95e-25: tmp = t_1 elif t <= -5.8e-243: tmp = x + z elif t <= -1.15e-291: tmp = y * b elif t <= 4.7e+17: tmp = x + z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.95e-25) tmp = t_1; elseif (t <= -5.8e-243) tmp = Float64(x + z); elseif (t <= -1.15e-291) tmp = Float64(y * b); elseif (t <= 4.7e+17) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -1.95e-25) tmp = t_1; elseif (t <= -5.8e-243) tmp = x + z; elseif (t <= -1.15e-291) tmp = y * b; elseif (t <= 4.7e+17) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.95e-25], t$95$1, If[LessEqual[t, -5.8e-243], N[(x + z), $MachinePrecision], If[LessEqual[t, -1.15e-291], N[(y * b), $MachinePrecision], If[LessEqual[t, 4.7e+17], N[(x + z), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.95 \cdot 10^{-25}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -5.8 \cdot 10^{-243}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq -1.15 \cdot 10^{-291}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 4.7 \cdot 10^{+17}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.95e-25 or 4.7e17 < t Initial program 92.7%
associate-+l-92.7%
*-commutative92.7%
*-commutative92.7%
sub-neg92.7%
metadata-eval92.7%
remove-double-neg92.7%
remove-double-neg92.7%
sub-neg92.7%
metadata-eval92.7%
associate--l+92.7%
Simplified92.7%
Taylor expanded in t around inf 71.3%
if -1.95e-25 < t < -5.79999999999999953e-243 or -1.15e-291 < t < 4.7e17Initial program 97.6%
associate-+l-97.6%
*-commutative97.6%
*-commutative97.6%
sub-neg97.6%
metadata-eval97.6%
remove-double-neg97.6%
remove-double-neg97.6%
sub-neg97.6%
metadata-eval97.6%
associate--l+97.6%
Simplified97.6%
Taylor expanded in t around inf 52.8%
Taylor expanded in t around 0 52.8%
Taylor expanded in y around 0 41.6%
sub-neg41.6%
neg-mul-141.6%
remove-double-neg41.6%
+-commutative41.6%
Simplified41.6%
if -5.79999999999999953e-243 < t < -1.15e-291Initial program 88.9%
associate-+l-88.9%
*-commutative88.9%
*-commutative88.9%
sub-neg88.9%
metadata-eval88.9%
remove-double-neg88.9%
remove-double-neg88.9%
sub-neg88.9%
metadata-eval88.9%
associate--l+88.9%
Simplified88.9%
Taylor expanded in b around inf 71.4%
Taylor expanded in y around inf 60.7%
Final simplification56.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -1.95e-25)
t_1
(if (<= t -4.4e-194)
(+ x z)
(if (<= t -1.35e-293) (* y (- b z)) (if (<= t 5.5e+17) (+ x z) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_1;
} else if (t <= -4.4e-194) {
tmp = x + z;
} else if (t <= -1.35e-293) {
tmp = y * (b - z);
} else if (t <= 5.5e+17) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-1.95d-25)) then
tmp = t_1
else if (t <= (-4.4d-194)) then
tmp = x + z
else if (t <= (-1.35d-293)) then
tmp = y * (b - z)
else if (t <= 5.5d+17) then
tmp = x + z
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_1;
} else if (t <= -4.4e-194) {
tmp = x + z;
} else if (t <= -1.35e-293) {
tmp = y * (b - z);
} else if (t <= 5.5e+17) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -1.95e-25: tmp = t_1 elif t <= -4.4e-194: tmp = x + z elif t <= -1.35e-293: tmp = y * (b - z) elif t <= 5.5e+17: tmp = x + z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.95e-25) tmp = t_1; elseif (t <= -4.4e-194) tmp = Float64(x + z); elseif (t <= -1.35e-293) tmp = Float64(y * Float64(b - z)); elseif (t <= 5.5e+17) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -1.95e-25) tmp = t_1; elseif (t <= -4.4e-194) tmp = x + z; elseif (t <= -1.35e-293) tmp = y * (b - z); elseif (t <= 5.5e+17) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.95e-25], t$95$1, If[LessEqual[t, -4.4e-194], N[(x + z), $MachinePrecision], If[LessEqual[t, -1.35e-293], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e+17], N[(x + z), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.95 \cdot 10^{-25}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -4.4 \cdot 10^{-194}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq -1.35 \cdot 10^{-293}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{+17}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.95e-25 or 5.5e17 < t Initial program 92.7%
associate-+l-92.7%
*-commutative92.7%
*-commutative92.7%
sub-neg92.7%
metadata-eval92.7%
remove-double-neg92.7%
remove-double-neg92.7%
sub-neg92.7%
metadata-eval92.7%
associate--l+92.7%
Simplified92.7%
Taylor expanded in t around inf 71.3%
if -1.95e-25 < t < -4.4000000000000003e-194 or -1.35000000000000001e-293 < t < 5.5e17Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in t around inf 54.7%
Taylor expanded in t around 0 54.6%
Taylor expanded in y around 0 42.5%
sub-neg42.5%
neg-mul-142.5%
remove-double-neg42.5%
+-commutative42.5%
Simplified42.5%
if -4.4000000000000003e-194 < t < -1.35000000000000001e-293Initial program 94.7%
associate-+l-94.7%
*-commutative94.7%
*-commutative94.7%
sub-neg94.7%
metadata-eval94.7%
remove-double-neg94.7%
remove-double-neg94.7%
sub-neg94.7%
metadata-eval94.7%
associate--l+94.7%
Simplified94.7%
Taylor expanded in y around inf 51.8%
Final simplification57.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (<= t -1.95e-25)
t_1
(if (<= t -2.25e-195)
(+ x z)
(if (<= t 1.7e-248) (* (- y 2.0) b) (if (<= t 4.5e+17) (+ x z) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_1;
} else if (t <= -2.25e-195) {
tmp = x + z;
} else if (t <= 1.7e-248) {
tmp = (y - 2.0) * b;
} else if (t <= 4.5e+17) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = t * (b - a)
if (t <= (-1.95d-25)) then
tmp = t_1
else if (t <= (-2.25d-195)) then
tmp = x + z
else if (t <= 1.7d-248) then
tmp = (y - 2.0d0) * b
else if (t <= 4.5d+17) then
tmp = x + z
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_1;
} else if (t <= -2.25e-195) {
tmp = x + z;
} else if (t <= 1.7e-248) {
tmp = (y - 2.0) * b;
} else if (t <= 4.5e+17) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if t <= -1.95e-25: tmp = t_1 elif t <= -2.25e-195: tmp = x + z elif t <= 1.7e-248: tmp = (y - 2.0) * b elif t <= 4.5e+17: tmp = x + z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.95e-25) tmp = t_1; elseif (t <= -2.25e-195) tmp = Float64(x + z); elseif (t <= 1.7e-248) tmp = Float64(Float64(y - 2.0) * b); elseif (t <= 4.5e+17) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (b - a); tmp = 0.0; if (t <= -1.95e-25) tmp = t_1; elseif (t <= -2.25e-195) tmp = x + z; elseif (t <= 1.7e-248) tmp = (y - 2.0) * b; elseif (t <= 4.5e+17) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.95e-25], t$95$1, If[LessEqual[t, -2.25e-195], N[(x + z), $MachinePrecision], If[LessEqual[t, 1.7e-248], N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[t, 4.5e+17], N[(x + z), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.95 \cdot 10^{-25}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2.25 \cdot 10^{-195}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq 1.7 \cdot 10^{-248}:\\
\;\;\;\;\left(y - 2\right) \cdot b\\
\mathbf{elif}\;t \leq 4.5 \cdot 10^{+17}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.95e-25 or 4.5e17 < t Initial program 92.7%
associate-+l-92.7%
*-commutative92.7%
*-commutative92.7%
sub-neg92.7%
metadata-eval92.7%
remove-double-neg92.7%
remove-double-neg92.7%
sub-neg92.7%
metadata-eval92.7%
associate--l+92.7%
Simplified92.7%
Taylor expanded in t around inf 71.3%
if -1.95e-25 < t < -2.25e-195 or 1.6999999999999999e-248 < t < 4.5e17Initial program 96.8%
associate-+l-96.8%
*-commutative96.8%
*-commutative96.8%
sub-neg96.8%
metadata-eval96.8%
remove-double-neg96.8%
remove-double-neg96.8%
sub-neg96.8%
metadata-eval96.8%
associate--l+96.8%
Simplified96.8%
Taylor expanded in t around inf 60.4%
Taylor expanded in t around 0 60.2%
Taylor expanded in y around 0 45.7%
sub-neg45.7%
neg-mul-145.7%
remove-double-neg45.7%
+-commutative45.7%
Simplified45.7%
if -2.25e-195 < t < 1.6999999999999999e-248Initial program 97.4%
associate-+l-97.4%
*-commutative97.4%
*-commutative97.4%
sub-neg97.4%
metadata-eval97.4%
remove-double-neg97.4%
remove-double-neg97.4%
sub-neg97.4%
metadata-eval97.4%
associate--l+97.4%
Simplified97.4%
Taylor expanded in b around inf 52.5%
Taylor expanded in t around 0 52.5%
Final simplification59.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- x (* y z))) (t_2 (* t (- b a))))
(if (<= t -1.95e-25)
t_2
(if (<= t -1.25e-195)
t_1
(if (<= t 9.6e-236) (* (- y 2.0) b) (if (<= t 2.8e+18) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x - (y * z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_2;
} else if (t <= -1.25e-195) {
tmp = t_1;
} else if (t <= 9.6e-236) {
tmp = (y - 2.0) * b;
} else if (t <= 2.8e+18) {
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 - (y * z)
t_2 = t * (b - a)
if (t <= (-1.95d-25)) then
tmp = t_2
else if (t <= (-1.25d-195)) then
tmp = t_1
else if (t <= 9.6d-236) then
tmp = (y - 2.0d0) * b
else if (t <= 2.8d+18) 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 - (y * z);
double t_2 = t * (b - a);
double tmp;
if (t <= -1.95e-25) {
tmp = t_2;
} else if (t <= -1.25e-195) {
tmp = t_1;
} else if (t <= 9.6e-236) {
tmp = (y - 2.0) * b;
} else if (t <= 2.8e+18) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x - (y * z) t_2 = t * (b - a) tmp = 0 if t <= -1.95e-25: tmp = t_2 elif t <= -1.25e-195: tmp = t_1 elif t <= 9.6e-236: tmp = (y - 2.0) * b elif t <= 2.8e+18: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x - Float64(y * z)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -1.95e-25) tmp = t_2; elseif (t <= -1.25e-195) tmp = t_1; elseif (t <= 9.6e-236) tmp = Float64(Float64(y - 2.0) * b); elseif (t <= 2.8e+18) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x - (y * z); t_2 = t * (b - a); tmp = 0.0; if (t <= -1.95e-25) tmp = t_2; elseif (t <= -1.25e-195) tmp = t_1; elseif (t <= 9.6e-236) tmp = (y - 2.0) * b; elseif (t <= 2.8e+18) 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[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.95e-25], t$95$2, If[LessEqual[t, -1.25e-195], t$95$1, If[LessEqual[t, 9.6e-236], N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[t, 2.8e+18], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - y \cdot z\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -1.95 \cdot 10^{-25}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.25 \cdot 10^{-195}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 9.6 \cdot 10^{-236}:\\
\;\;\;\;\left(y - 2\right) \cdot b\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{+18}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.95e-25 or 2.8e18 < t Initial program 92.7%
associate-+l-92.7%
*-commutative92.7%
*-commutative92.7%
sub-neg92.7%
metadata-eval92.7%
remove-double-neg92.7%
remove-double-neg92.7%
sub-neg92.7%
metadata-eval92.7%
associate--l+92.7%
Simplified92.7%
Taylor expanded in t around inf 71.3%
if -1.95e-25 < t < -1.25000000000000002e-195 or 9.60000000000000078e-236 < t < 2.8e18Initial program 97.8%
associate-+l-97.8%
*-commutative97.8%
*-commutative97.8%
sub-neg97.8%
metadata-eval97.8%
remove-double-neg97.8%
remove-double-neg97.8%
sub-neg97.8%
metadata-eval97.8%
associate--l+97.8%
Simplified97.8%
Taylor expanded in t around inf 60.8%
Taylor expanded in t around 0 60.7%
Taylor expanded in y around inf 51.3%
if -1.25000000000000002e-195 < t < 9.60000000000000078e-236Initial program 95.2%
associate-+l-95.2%
*-commutative95.2%
*-commutative95.2%
sub-neg95.2%
metadata-eval95.2%
remove-double-neg95.2%
remove-double-neg95.2%
sub-neg95.2%
metadata-eval95.2%
associate--l+95.2%
Simplified95.2%
Taylor expanded in b around inf 50.3%
Taylor expanded in t around 0 50.3%
Final simplification60.8%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -3.4e+148) (not (<= b 9.2e+117))) (* b (- (+ t y) 2.0)) (- (+ x z) (* t (- a b)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -3.4e+148) || !(b <= 9.2e+117)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + z) - (t * (a - b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((b <= (-3.4d+148)) .or. (.not. (b <= 9.2d+117))) then
tmp = b * ((t + y) - 2.0d0)
else
tmp = (x + z) - (t * (a - b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -3.4e+148) || !(b <= 9.2e+117)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + z) - (t * (a - b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -3.4e+148) or not (b <= 9.2e+117): tmp = b * ((t + y) - 2.0) else: tmp = (x + z) - (t * (a - b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -3.4e+148) || !(b <= 9.2e+117)) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); else tmp = Float64(Float64(x + z) - Float64(t * Float64(a - b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -3.4e+148) || ~((b <= 9.2e+117))) tmp = b * ((t + y) - 2.0); else tmp = (x + z) - (t * (a - b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -3.4e+148], N[Not[LessEqual[b, 9.2e+117]], $MachinePrecision]], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x + z), $MachinePrecision] - N[(t * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.4 \cdot 10^{+148} \lor \neg \left(b \leq 9.2 \cdot 10^{+117}\right):\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z\right) - t \cdot \left(a - b\right)\\
\end{array}
\end{array}
if b < -3.4000000000000003e148 or 9.19999999999999951e117 < b Initial program 86.3%
associate-+l-86.3%
*-commutative86.3%
*-commutative86.3%
sub-neg86.3%
metadata-eval86.3%
remove-double-neg86.3%
remove-double-neg86.3%
sub-neg86.3%
metadata-eval86.3%
associate--l+86.3%
Simplified86.3%
Taylor expanded in b around inf 81.7%
if -3.4000000000000003e148 < b < 9.19999999999999951e117Initial program 97.9%
associate-+l-97.9%
*-commutative97.9%
*-commutative97.9%
sub-neg97.9%
metadata-eval97.9%
remove-double-neg97.9%
remove-double-neg97.9%
sub-neg97.9%
metadata-eval97.9%
associate--l+97.9%
Simplified97.9%
Taylor expanded in t around inf 80.4%
Taylor expanded in y around 0 67.2%
neg-mul-162.0%
sub-neg62.0%
remove-double-neg62.0%
+-commutative62.0%
Simplified67.2%
Final simplification71.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (* t a))))
(if (<= t -1.55e+22)
t_1
(if (<= t -1.08e-243)
(+ x z)
(if (<= t -3e-292) (* y b) (if (<= t 2.1e+19) (+ x z) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = -(t * a);
double tmp;
if (t <= -1.55e+22) {
tmp = t_1;
} else if (t <= -1.08e-243) {
tmp = x + z;
} else if (t <= -3e-292) {
tmp = y * b;
} else if (t <= 2.1e+19) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = -(t * a)
if (t <= (-1.55d+22)) then
tmp = t_1
else if (t <= (-1.08d-243)) then
tmp = x + z
else if (t <= (-3d-292)) then
tmp = y * b
else if (t <= 2.1d+19) then
tmp = x + z
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = -(t * a);
double tmp;
if (t <= -1.55e+22) {
tmp = t_1;
} else if (t <= -1.08e-243) {
tmp = x + z;
} else if (t <= -3e-292) {
tmp = y * b;
} else if (t <= 2.1e+19) {
tmp = x + z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = -(t * a) tmp = 0 if t <= -1.55e+22: tmp = t_1 elif t <= -1.08e-243: tmp = x + z elif t <= -3e-292: tmp = y * b elif t <= 2.1e+19: tmp = x + z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(-Float64(t * a)) tmp = 0.0 if (t <= -1.55e+22) tmp = t_1; elseif (t <= -1.08e-243) tmp = Float64(x + z); elseif (t <= -3e-292) tmp = Float64(y * b); elseif (t <= 2.1e+19) tmp = Float64(x + z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = -(t * a); tmp = 0.0; if (t <= -1.55e+22) tmp = t_1; elseif (t <= -1.08e-243) tmp = x + z; elseif (t <= -3e-292) tmp = y * b; elseif (t <= 2.1e+19) tmp = x + z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = (-N[(t * a), $MachinePrecision])}, If[LessEqual[t, -1.55e+22], t$95$1, If[LessEqual[t, -1.08e-243], N[(x + z), $MachinePrecision], If[LessEqual[t, -3e-292], N[(y * b), $MachinePrecision], If[LessEqual[t, 2.1e+19], N[(x + z), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := -t \cdot a\\
\mathbf{if}\;t \leq -1.55 \cdot 10^{+22}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.08 \cdot 10^{-243}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq -3 \cdot 10^{-292}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{+19}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.5500000000000001e22 or 2.1e19 < t Initial program 92.2%
associate-+l-92.2%
*-commutative92.2%
*-commutative92.2%
sub-neg92.2%
metadata-eval92.2%
remove-double-neg92.2%
remove-double-neg92.2%
sub-neg92.2%
metadata-eval92.2%
associate--l+92.2%
Simplified92.2%
Taylor expanded in t around inf 94.8%
Taylor expanded in a around inf 52.9%
mul-1-neg52.9%
*-commutative52.9%
Simplified52.9%
if -1.5500000000000001e22 < t < -1.08e-243 or -3.00000000000000015e-292 < t < 2.1e19Initial program 97.7%
associate-+l-97.7%
*-commutative97.7%
*-commutative97.7%
sub-neg97.7%
metadata-eval97.7%
remove-double-neg97.7%
remove-double-neg97.7%
sub-neg97.7%
metadata-eval97.7%
associate--l+97.7%
Simplified97.7%
Taylor expanded in t around inf 52.8%
Taylor expanded in t around 0 51.5%
Taylor expanded in y around 0 40.7%
sub-neg40.7%
neg-mul-140.7%
remove-double-neg40.7%
+-commutative40.7%
Simplified40.7%
if -1.08e-243 < t < -3.00000000000000015e-292Initial program 88.9%
associate-+l-88.9%
*-commutative88.9%
*-commutative88.9%
sub-neg88.9%
metadata-eval88.9%
remove-double-neg88.9%
remove-double-neg88.9%
sub-neg88.9%
metadata-eval88.9%
associate--l+88.9%
Simplified88.9%
Taylor expanded in b around inf 71.4%
Taylor expanded in y around inf 60.7%
Final simplification46.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -4.1e+136) (not (<= b 1.65e+116))) (* b (- (+ t y) 2.0)) (- (+ x z) (* t a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -4.1e+136) || !(b <= 1.65e+116)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + z) - (t * a);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((b <= (-4.1d+136)) .or. (.not. (b <= 1.65d+116))) then
tmp = b * ((t + y) - 2.0d0)
else
tmp = (x + z) - (t * a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -4.1e+136) || !(b <= 1.65e+116)) {
tmp = b * ((t + y) - 2.0);
} else {
tmp = (x + z) - (t * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -4.1e+136) or not (b <= 1.65e+116): tmp = b * ((t + y) - 2.0) else: tmp = (x + z) - (t * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -4.1e+136) || !(b <= 1.65e+116)) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); else tmp = Float64(Float64(x + z) - Float64(t * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -4.1e+136) || ~((b <= 1.65e+116))) tmp = b * ((t + y) - 2.0); else tmp = (x + z) - (t * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -4.1e+136], N[Not[LessEqual[b, 1.65e+116]], $MachinePrecision]], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x + z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4.1 \cdot 10^{+136} \lor \neg \left(b \leq 1.65 \cdot 10^{+116}\right):\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + z\right) - t \cdot a\\
\end{array}
\end{array}
if b < -4.0999999999999998e136 or 1.6499999999999999e116 < b Initial program 85.9%
associate-+l-85.9%
*-commutative85.9%
*-commutative85.9%
sub-neg85.9%
metadata-eval85.9%
remove-double-neg85.9%
remove-double-neg85.9%
sub-neg85.9%
metadata-eval85.9%
associate--l+85.9%
Simplified85.9%
Taylor expanded in b around inf 81.5%
if -4.0999999999999998e136 < b < 1.6499999999999999e116Initial program 98.4%
associate-+l-98.4%
*-commutative98.4%
*-commutative98.4%
sub-neg98.4%
metadata-eval98.4%
remove-double-neg98.4%
remove-double-neg98.4%
sub-neg98.4%
metadata-eval98.4%
associate--l+98.4%
Simplified98.4%
Taylor expanded in t around inf 79.8%
Taylor expanded in a around inf 76.0%
*-commutative76.0%
Simplified76.0%
Taylor expanded in y around 0 63.0%
neg-mul-163.0%
sub-neg63.0%
remove-double-neg63.0%
+-commutative63.0%
Simplified63.0%
Final simplification68.2%
(FPCore (x y z t a b) :precision binary64 (if (or (<= a -5.8e+84) (not (<= a 2.25e-41))) (* a (- 1.0 t)) (+ x z)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -5.8e+84) || !(a <= 2.25e-41)) {
tmp = a * (1.0 - t);
} else {
tmp = x + z;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((a <= (-5.8d+84)) .or. (.not. (a <= 2.25d-41))) then
tmp = a * (1.0d0 - t)
else
tmp = x + z
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -5.8e+84) || !(a <= 2.25e-41)) {
tmp = a * (1.0 - t);
} else {
tmp = x + z;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (a <= -5.8e+84) or not (a <= 2.25e-41): tmp = a * (1.0 - t) else: tmp = x + z return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((a <= -5.8e+84) || !(a <= 2.25e-41)) tmp = Float64(a * Float64(1.0 - t)); else tmp = Float64(x + z); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((a <= -5.8e+84) || ~((a <= 2.25e-41))) tmp = a * (1.0 - t); else tmp = x + z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[a, -5.8e+84], N[Not[LessEqual[a, 2.25e-41]], $MachinePrecision]], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], N[(x + z), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.8 \cdot 10^{+84} \lor \neg \left(a \leq 2.25 \cdot 10^{-41}\right):\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{else}:\\
\;\;\;\;x + z\\
\end{array}
\end{array}
if a < -5.79999999999999977e84 or 2.25e-41 < a Initial program 94.3%
associate-+l-94.3%
*-commutative94.3%
*-commutative94.3%
sub-neg94.3%
metadata-eval94.3%
remove-double-neg94.3%
remove-double-neg94.3%
sub-neg94.3%
metadata-eval94.3%
associate--l+94.3%
Simplified94.3%
Taylor expanded in a around inf 61.1%
if -5.79999999999999977e84 < a < 2.25e-41Initial program 95.5%
associate-+l-95.5%
*-commutative95.5%
*-commutative95.5%
sub-neg95.5%
metadata-eval95.5%
remove-double-neg95.5%
remove-double-neg95.5%
sub-neg95.5%
metadata-eval95.5%
associate--l+95.5%
Simplified95.5%
Taylor expanded in t around inf 74.3%
Taylor expanded in t around 0 55.4%
Taylor expanded in y around 0 40.3%
sub-neg40.3%
neg-mul-140.3%
remove-double-neg40.3%
+-commutative40.3%
Simplified40.3%
Final simplification50.3%
(FPCore (x y z t a b) :precision binary64 (if (<= x -5.5e+45) x (if (<= x 2.8e+50) (* t b) x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -5.5e+45) {
tmp = x;
} else if (x <= 2.8e+50) {
tmp = t * b;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (x <= (-5.5d+45)) then
tmp = x
else if (x <= 2.8d+50) then
tmp = t * b
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -5.5e+45) {
tmp = x;
} else if (x <= 2.8e+50) {
tmp = t * b;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -5.5e+45: tmp = x elif x <= 2.8e+50: tmp = t * b else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -5.5e+45) tmp = x; elseif (x <= 2.8e+50) tmp = Float64(t * b); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -5.5e+45) tmp = x; elseif (x <= 2.8e+50) tmp = t * b; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -5.5e+45], x, If[LessEqual[x, 2.8e+50], N[(t * b), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.5 \cdot 10^{+45}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 2.8 \cdot 10^{+50}:\\
\;\;\;\;t \cdot b\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -5.5000000000000001e45 or 2.7999999999999998e50 < x Initial program 97.3%
associate-+l-97.3%
*-commutative97.3%
*-commutative97.3%
sub-neg97.3%
metadata-eval97.3%
remove-double-neg97.3%
remove-double-neg97.3%
sub-neg97.3%
metadata-eval97.3%
associate--l+97.3%
Simplified97.3%
Taylor expanded in x around inf 41.9%
if -5.5000000000000001e45 < x < 2.7999999999999998e50Initial program 93.0%
associate-+l-93.0%
*-commutative93.0%
*-commutative93.0%
sub-neg93.0%
metadata-eval93.0%
remove-double-neg93.0%
remove-double-neg93.0%
sub-neg93.0%
metadata-eval93.0%
associate--l+93.0%
Simplified93.0%
Taylor expanded in b around inf 41.5%
Taylor expanded in t around inf 19.6%
Final simplification29.4%
(FPCore (x y z t a b) :precision binary64 (if (<= b -4.6e+136) (* t b) (if (<= b 1.08e+99) x (* y b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -4.6e+136) {
tmp = t * b;
} else if (b <= 1.08e+99) {
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 (b <= (-4.6d+136)) then
tmp = t * b
else if (b <= 1.08d+99) 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 (b <= -4.6e+136) {
tmp = t * b;
} else if (b <= 1.08e+99) {
tmp = x;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -4.6e+136: tmp = t * b elif b <= 1.08e+99: tmp = x else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -4.6e+136) tmp = Float64(t * b); elseif (b <= 1.08e+99) 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 (b <= -4.6e+136) tmp = t * b; elseif (b <= 1.08e+99) tmp = x; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -4.6e+136], N[(t * b), $MachinePrecision], If[LessEqual[b, 1.08e+99], x, N[(y * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4.6 \cdot 10^{+136}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq 1.08 \cdot 10^{+99}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if b < -4.6e136Initial 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 b around inf 80.1%
Taylor expanded in t around inf 41.7%
if -4.6e136 < b < 1.08e99Initial program 98.3%
associate-+l-98.3%
*-commutative98.3%
*-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
remove-double-neg98.3%
remove-double-neg98.3%
sub-neg98.3%
metadata-eval98.3%
associate--l+98.3%
Simplified98.3%
Taylor expanded in x around inf 26.6%
if 1.08e99 < b Initial program 82.8%
associate-+l-82.8%
*-commutative82.8%
*-commutative82.8%
sub-neg82.8%
metadata-eval82.8%
remove-double-neg82.8%
remove-double-neg82.8%
sub-neg82.8%
metadata-eval82.8%
associate--l+82.8%
Simplified82.8%
Taylor expanded in b around inf 79.1%
Taylor expanded in y around inf 47.3%
Final simplification31.8%
(FPCore (x y z t a b) :precision binary64 (if (<= b -6.2e+136) (* t b) (if (<= b 1.9e+117) (+ x z) (* y b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -6.2e+136) {
tmp = t * b;
} else if (b <= 1.9e+117) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-6.2d+136)) then
tmp = t * b
else if (b <= 1.9d+117) then
tmp = x + z
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -6.2e+136) {
tmp = t * b;
} else if (b <= 1.9e+117) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -6.2e+136: tmp = t * b elif b <= 1.9e+117: tmp = x + z else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -6.2e+136) tmp = Float64(t * b); elseif (b <= 1.9e+117) tmp = Float64(x + z); else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -6.2e+136) tmp = t * b; elseif (b <= 1.9e+117) tmp = x + z; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -6.2e+136], N[(t * b), $MachinePrecision], If[LessEqual[b, 1.9e+117], N[(x + z), $MachinePrecision], N[(y * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6.2 \cdot 10^{+136}:\\
\;\;\;\;t \cdot b\\
\mathbf{elif}\;b \leq 1.9 \cdot 10^{+117}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if b < -6.19999999999999967e136Initial 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 b around inf 80.1%
Taylor expanded in t around inf 41.7%
if -6.19999999999999967e136 < b < 1.9000000000000001e117Initial program 98.4%
associate-+l-98.4%
*-commutative98.4%
*-commutative98.4%
sub-neg98.4%
metadata-eval98.4%
remove-double-neg98.4%
remove-double-neg98.4%
sub-neg98.4%
metadata-eval98.4%
associate--l+98.4%
Simplified98.4%
Taylor expanded in t around inf 79.8%
Taylor expanded in t around 0 49.7%
Taylor expanded in y around 0 34.8%
sub-neg34.8%
neg-mul-134.8%
remove-double-neg34.8%
+-commutative34.8%
Simplified34.8%
if 1.9000000000000001e117 < b Initial program 81.2%
associate-+l-81.2%
*-commutative81.2%
*-commutative81.2%
sub-neg81.2%
metadata-eval81.2%
remove-double-neg81.2%
remove-double-neg81.2%
sub-neg81.2%
metadata-eval81.2%
associate--l+81.2%
Simplified81.2%
Taylor expanded in b around inf 83.3%
Taylor expanded in y around inf 48.6%
Final simplification37.6%
(FPCore (x y z t a b) :precision binary64 (if (<= x -1.55e-24) x (if (<= x 1.5e+54) z x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -1.55e-24) {
tmp = x;
} else if (x <= 1.5e+54) {
tmp = z;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (x <= (-1.55d-24)) then
tmp = x
else if (x <= 1.5d+54) then
tmp = z
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -1.55e-24) {
tmp = x;
} else if (x <= 1.5e+54) {
tmp = z;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -1.55e-24: tmp = x elif x <= 1.5e+54: tmp = z else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -1.55e-24) tmp = x; elseif (x <= 1.5e+54) tmp = z; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -1.55e-24) tmp = x; elseif (x <= 1.5e+54) tmp = z; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.55e-24], x, If[LessEqual[x, 1.5e+54], z, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.55 \cdot 10^{-24}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 1.5 \cdot 10^{+54}:\\
\;\;\;\;z\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.55e-24 or 1.4999999999999999e54 < x Initial 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 x around inf 39.7%
if -1.55e-24 < x < 1.4999999999999999e54Initial program 94.0%
associate-+l-94.0%
*-commutative94.0%
*-commutative94.0%
sub-neg94.0%
metadata-eval94.0%
remove-double-neg94.0%
remove-double-neg94.0%
sub-neg94.0%
metadata-eval94.0%
associate--l+94.0%
Simplified94.0%
Taylor expanded in z around inf 26.9%
Taylor expanded in y around 0 11.0%
Final simplification24.8%
(FPCore (x y z t a b) :precision binary64 x)
double code(double x, double y, double z, double t, double a, double b) {
return x;
}
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
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x;
}
def code(x, y, z, t, a, b): return x
function code(x, y, z, t, a, b) return x end
function tmp = code(x, y, z, t, a, b) tmp = x; end
code[x_, y_, z_, t_, a_, b_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 94.9%
associate-+l-94.9%
*-commutative94.9%
*-commutative94.9%
sub-neg94.9%
metadata-eval94.9%
remove-double-neg94.9%
remove-double-neg94.9%
sub-neg94.9%
metadata-eval94.9%
associate--l+94.9%
Simplified94.9%
Taylor expanded in x around inf 20.6%
Final simplification20.6%
herbie shell --seed 2023238
(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)))