
(FPCore (x y z t a b) :precision binary64 (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((x - ((y - 1.0d0) * z)) - ((t - 1.0d0) * a)) + (((y + t) - 2.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
def code(x, y, z, t, a, b): return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a)) + Float64(Float64(Float64(y + t) - 2.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x - N[(N[(y - 1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[(t - 1.0), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 27 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((x - ((y - 1.0d0) * z)) - ((t - 1.0d0) * a)) + (((y + t) - 2.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
}
def code(x, y, z, t, a, b): return ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a)) + Float64(Float64(Float64(y + t) - 2.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x - N[(N[(y - 1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[(t - 1.0), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b
\end{array}
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1
(+ (+ (- x (* (+ y -1.0) z)) (* a (- 1.0 t))) (* b (- (+ t y) 2.0)))))
(if (<= t_1 INFINITY) t_1 (+ (+ x z) (* t (- b a))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((x - ((y + -1.0) * z)) + (a * (1.0 - t))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = (x + z) + (t * (b - a));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((x - ((y + -1.0) * z)) + (a * (1.0 - t))) + (b * ((t + y) - 2.0));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = (x + z) + (t * (b - a));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = ((x - ((y + -1.0) * z)) + (a * (1.0 - t))) + (b * ((t + y) - 2.0)) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = (x + z) + (t * (b - a)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + Float64(a * Float64(1.0 - t))) + Float64(b * Float64(Float64(t + y) - 2.0))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(Float64(x + z) + Float64(t * Float64(b - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = ((x - ((y + -1.0) * z)) + (a * (1.0 - t))) + (b * ((t + y) - 2.0)); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = (x + z) + (t * (b - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[(x + z), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(x - \left(y + -1\right) \cdot z\right) + a \cdot \left(1 - t\right)\right) + b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\left(x + z\right) + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) < +inf.0Initial program 100.0%
if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) b)) Initial program 0.0%
associate-+l-0.0%
*-commutative0.0%
*-commutative0.0%
sub-neg0.0%
metadata-eval0.0%
remove-double-neg0.0%
remove-double-neg0.0%
sub-neg0.0%
metadata-eval0.0%
associate--l+0.0%
Simplified0.0%
Taylor expanded in t around inf 50.0%
Taylor expanded in y around 0 83.3%
cancel-sign-sub-inv83.3%
metadata-eval83.3%
*-lft-identity83.3%
+-commutative83.3%
Simplified83.3%
Final simplification99.6%
(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 97.6%
+-commutative97.6%
fma-def98.8%
+-commutative98.8%
associate--l+98.8%
sub-neg98.8%
associate-+l-98.8%
fma-neg98.8%
sub-neg98.8%
metadata-eval98.8%
distribute-lft-neg-in98.8%
distribute-lft-neg-in98.8%
remove-double-neg98.8%
sub-neg98.8%
metadata-eval98.8%
Simplified98.8%
Final simplification98.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* t (- b a)))) (t_2 (* y (- b z))))
(if (<= y -3.9e+56)
t_2
(if (<= y -9.8e-243)
t_1
(if (<= y 4.4e-290)
(+ (+ x z) (* b -2.0))
(if (<= y 5.8e-225)
t_1
(if (<= y 2.8e-30) (+ x (+ z a)) (if (<= y 3.3e+97) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = y * (b - z);
double tmp;
if (y <= -3.9e+56) {
tmp = t_2;
} else if (y <= -9.8e-243) {
tmp = t_1;
} else if (y <= 4.4e-290) {
tmp = (x + z) + (b * -2.0);
} else if (y <= 5.8e-225) {
tmp = t_1;
} else if (y <= 2.8e-30) {
tmp = x + (z + a);
} else if (y <= 3.3e+97) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t * (b - a))
t_2 = y * (b - z)
if (y <= (-3.9d+56)) then
tmp = t_2
else if (y <= (-9.8d-243)) then
tmp = t_1
else if (y <= 4.4d-290) then
tmp = (x + z) + (b * (-2.0d0))
else if (y <= 5.8d-225) then
tmp = t_1
else if (y <= 2.8d-30) then
tmp = x + (z + a)
else if (y <= 3.3d+97) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = y * (b - z);
double tmp;
if (y <= -3.9e+56) {
tmp = t_2;
} else if (y <= -9.8e-243) {
tmp = t_1;
} else if (y <= 4.4e-290) {
tmp = (x + z) + (b * -2.0);
} else if (y <= 5.8e-225) {
tmp = t_1;
} else if (y <= 2.8e-30) {
tmp = x + (z + a);
} else if (y <= 3.3e+97) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (t * (b - a)) t_2 = y * (b - z) tmp = 0 if y <= -3.9e+56: tmp = t_2 elif y <= -9.8e-243: tmp = t_1 elif y <= 4.4e-290: tmp = (x + z) + (b * -2.0) elif y <= 5.8e-225: tmp = t_1 elif y <= 2.8e-30: tmp = x + (z + a) elif y <= 3.3e+97: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(t * Float64(b - a))) t_2 = Float64(y * Float64(b - z)) tmp = 0.0 if (y <= -3.9e+56) tmp = t_2; elseif (y <= -9.8e-243) tmp = t_1; elseif (y <= 4.4e-290) tmp = Float64(Float64(x + z) + Float64(b * -2.0)); elseif (y <= 5.8e-225) tmp = t_1; elseif (y <= 2.8e-30) tmp = Float64(x + Float64(z + a)); elseif (y <= 3.3e+97) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (t * (b - a)); t_2 = y * (b - z); tmp = 0.0; if (y <= -3.9e+56) tmp = t_2; elseif (y <= -9.8e-243) tmp = t_1; elseif (y <= 4.4e-290) tmp = (x + z) + (b * -2.0); elseif (y <= 5.8e-225) tmp = t_1; elseif (y <= 2.8e-30) tmp = x + (z + a); elseif (y <= 3.3e+97) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.9e+56], t$95$2, If[LessEqual[y, -9.8e-243], t$95$1, If[LessEqual[y, 4.4e-290], N[(N[(x + z), $MachinePrecision] + N[(b * -2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.8e-225], t$95$1, If[LessEqual[y, 2.8e-30], N[(x + N[(z + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.3e+97], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \left(b - a\right)\\
t_2 := y \cdot \left(b - z\right)\\
\mathbf{if}\;y \leq -3.9 \cdot 10^{+56}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -9.8 \cdot 10^{-243}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 4.4 \cdot 10^{-290}:\\
\;\;\;\;\left(x + z\right) + b \cdot -2\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{-225}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 2.8 \cdot 10^{-30}:\\
\;\;\;\;x + \left(z + a\right)\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+97}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -3.89999999999999994e56 or 3.3000000000000001e97 < y Initial program 95.4%
associate-+l-95.4%
*-commutative95.4%
*-commutative95.4%
sub-neg95.4%
metadata-eval95.4%
remove-double-neg95.4%
remove-double-neg95.4%
sub-neg95.4%
metadata-eval95.4%
associate--l+95.4%
Simplified95.4%
Taylor expanded in y around inf 74.4%
if -3.89999999999999994e56 < y < -9.8e-243 or 4.4000000000000002e-290 < y < 5.7999999999999996e-225 or 2.79999999999999988e-30 < y < 3.3000000000000001e97Initial program 98.9%
associate-+l-98.9%
*-commutative98.9%
*-commutative98.9%
sub-neg98.9%
metadata-eval98.9%
remove-double-neg98.9%
remove-double-neg98.9%
sub-neg98.9%
metadata-eval98.9%
associate--l+98.9%
Simplified98.9%
Taylor expanded in t around inf 81.7%
Taylor expanded in z around 0 64.6%
if -9.8e-243 < y < 4.4000000000000002e-290Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
+-commutative99.9%
fma-def99.9%
neg-sub099.9%
associate--r-99.9%
neg-sub099.9%
+-commutative99.9%
sub-neg99.9%
fma-def99.9%
sub-neg99.9%
associate-+l+99.9%
metadata-eval99.9%
sub-neg99.9%
+-commutative99.9%
Simplified99.9%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 87.9%
Taylor expanded in a around 0 81.9%
if 5.7999999999999996e-225 < y < 2.79999999999999988e-30Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 77.6%
Taylor expanded in b around 0 68.6%
associate-+r+68.6%
Simplified68.6%
Final simplification70.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ x a) (* t a))) (t_2 (- x (* (+ y -1.0) z))))
(if (<= z -1.7e+119)
t_2
(if (<= z -3.9e-200)
(+ x (* t (- b a)))
(if (<= z -1.9e-268)
(* b (- (+ t y) 2.0))
(if (<= z 1.2e-213)
t_1
(if (<= z 1.7e-174)
(* (- y 2.0) b)
(if (<= z 2.9e-28) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + a) - (t * a);
double t_2 = x - ((y + -1.0) * z);
double tmp;
if (z <= -1.7e+119) {
tmp = t_2;
} else if (z <= -3.9e-200) {
tmp = x + (t * (b - a));
} else if (z <= -1.9e-268) {
tmp = b * ((t + y) - 2.0);
} else if (z <= 1.2e-213) {
tmp = t_1;
} else if (z <= 1.7e-174) {
tmp = (y - 2.0) * b;
} else if (z <= 2.9e-28) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x + a) - (t * a)
t_2 = x - ((y + (-1.0d0)) * z)
if (z <= (-1.7d+119)) then
tmp = t_2
else if (z <= (-3.9d-200)) then
tmp = x + (t * (b - a))
else if (z <= (-1.9d-268)) then
tmp = b * ((t + y) - 2.0d0)
else if (z <= 1.2d-213) then
tmp = t_1
else if (z <= 1.7d-174) then
tmp = (y - 2.0d0) * b
else if (z <= 2.9d-28) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + a) - (t * a);
double t_2 = x - ((y + -1.0) * z);
double tmp;
if (z <= -1.7e+119) {
tmp = t_2;
} else if (z <= -3.9e-200) {
tmp = x + (t * (b - a));
} else if (z <= -1.9e-268) {
tmp = b * ((t + y) - 2.0);
} else if (z <= 1.2e-213) {
tmp = t_1;
} else if (z <= 1.7e-174) {
tmp = (y - 2.0) * b;
} else if (z <= 2.9e-28) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + a) - (t * a) t_2 = x - ((y + -1.0) * z) tmp = 0 if z <= -1.7e+119: tmp = t_2 elif z <= -3.9e-200: tmp = x + (t * (b - a)) elif z <= -1.9e-268: tmp = b * ((t + y) - 2.0) elif z <= 1.2e-213: tmp = t_1 elif z <= 1.7e-174: tmp = (y - 2.0) * b elif z <= 2.9e-28: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + a) - Float64(t * a)) t_2 = Float64(x - Float64(Float64(y + -1.0) * z)) tmp = 0.0 if (z <= -1.7e+119) tmp = t_2; elseif (z <= -3.9e-200) tmp = Float64(x + Float64(t * Float64(b - a))); elseif (z <= -1.9e-268) tmp = Float64(b * Float64(Float64(t + y) - 2.0)); elseif (z <= 1.2e-213) tmp = t_1; elseif (z <= 1.7e-174) tmp = Float64(Float64(y - 2.0) * b); elseif (z <= 2.9e-28) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + a) - (t * a); t_2 = x - ((y + -1.0) * z); tmp = 0.0; if (z <= -1.7e+119) tmp = t_2; elseif (z <= -3.9e-200) tmp = x + (t * (b - a)); elseif (z <= -1.9e-268) tmp = b * ((t + y) - 2.0); elseif (z <= 1.2e-213) tmp = t_1; elseif (z <= 1.7e-174) tmp = (y - 2.0) * b; elseif (z <= 2.9e-28) 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 + a), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.7e+119], t$95$2, If[LessEqual[z, -3.9e-200], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.9e-268], N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.2e-213], t$95$1, If[LessEqual[z, 1.7e-174], N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[z, 2.9e-28], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + a\right) - t \cdot a\\
t_2 := x - \left(y + -1\right) \cdot z\\
\mathbf{if}\;z \leq -1.7 \cdot 10^{+119}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -3.9 \cdot 10^{-200}:\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\mathbf{elif}\;z \leq -1.9 \cdot 10^{-268}:\\
\;\;\;\;b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{-213}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{-174}:\\
\;\;\;\;\left(y - 2\right) \cdot b\\
\mathbf{elif}\;z \leq 2.9 \cdot 10^{-28}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -1.70000000000000007e119 or 2.90000000000000013e-28 < z Initial program 96.3%
associate-+l-96.3%
*-commutative96.3%
*-commutative96.3%
sub-neg96.3%
metadata-eval96.3%
remove-double-neg96.3%
remove-double-neg96.3%
sub-neg96.3%
metadata-eval96.3%
associate--l+96.3%
Simplified96.3%
Taylor expanded in t around inf 88.1%
Taylor expanded in t around 0 76.2%
if -1.70000000000000007e119 < z < -3.89999999999999999e-200Initial program 98.5%
associate-+l-98.5%
*-commutative98.5%
*-commutative98.5%
sub-neg98.5%
metadata-eval98.5%
remove-double-neg98.5%
remove-double-neg98.5%
sub-neg98.5%
metadata-eval98.5%
associate--l+98.5%
Simplified98.5%
Taylor expanded in t around inf 73.4%
Taylor expanded in z around 0 60.6%
if -3.89999999999999999e-200 < z < -1.9000000000000001e-268Initial 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 72.6%
if -1.9000000000000001e-268 < z < 1.19999999999999998e-213 or 1.7000000000000001e-174 < z < 2.90000000000000013e-28Initial program 98.0%
associate-+l-98.0%
*-commutative98.0%
*-commutative98.0%
sub-neg98.0%
metadata-eval98.0%
remove-double-neg98.0%
remove-double-neg98.0%
sub-neg98.0%
metadata-eval98.0%
associate--l+98.0%
Simplified98.0%
Taylor expanded in a around inf 73.6%
sub-neg73.6%
metadata-eval73.6%
*-commutative73.6%
distribute-rgt-in73.6%
*-commutative73.6%
mul-1-neg73.6%
unsub-neg73.6%
Simplified73.6%
Taylor expanded in z around 0 70.0%
if 1.19999999999999998e-213 < z < 1.7000000000000001e-174Initial 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 93.9%
Taylor expanded in t around 0 93.9%
Final simplification71.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* t (- b a))))
(t_2 (* y (- b z)))
(t_3 (+ a (+ (+ x z) (* b -2.0)))))
(if (<= y -2.4e+56)
t_2
(if (<= y -2.35e-138)
t_1
(if (<= y 3.4e-290)
t_3
(if (<= y 4.5e-227)
t_1
(if (<= y 6.5e-14) t_3 (if (<= y 4.8e+93) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = y * (b - z);
double t_3 = a + ((x + z) + (b * -2.0));
double tmp;
if (y <= -2.4e+56) {
tmp = t_2;
} else if (y <= -2.35e-138) {
tmp = t_1;
} else if (y <= 3.4e-290) {
tmp = t_3;
} else if (y <= 4.5e-227) {
tmp = t_1;
} else if (y <= 6.5e-14) {
tmp = t_3;
} else if (y <= 4.8e+93) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (t * (b - a))
t_2 = y * (b - z)
t_3 = a + ((x + z) + (b * (-2.0d0)))
if (y <= (-2.4d+56)) then
tmp = t_2
else if (y <= (-2.35d-138)) then
tmp = t_1
else if (y <= 3.4d-290) then
tmp = t_3
else if (y <= 4.5d-227) then
tmp = t_1
else if (y <= 6.5d-14) then
tmp = t_3
else if (y <= 4.8d+93) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = y * (b - z);
double t_3 = a + ((x + z) + (b * -2.0));
double tmp;
if (y <= -2.4e+56) {
tmp = t_2;
} else if (y <= -2.35e-138) {
tmp = t_1;
} else if (y <= 3.4e-290) {
tmp = t_3;
} else if (y <= 4.5e-227) {
tmp = t_1;
} else if (y <= 6.5e-14) {
tmp = t_3;
} else if (y <= 4.8e+93) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (t * (b - a)) t_2 = y * (b - z) t_3 = a + ((x + z) + (b * -2.0)) tmp = 0 if y <= -2.4e+56: tmp = t_2 elif y <= -2.35e-138: tmp = t_1 elif y <= 3.4e-290: tmp = t_3 elif y <= 4.5e-227: tmp = t_1 elif y <= 6.5e-14: tmp = t_3 elif y <= 4.8e+93: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(t * Float64(b - a))) t_2 = Float64(y * Float64(b - z)) t_3 = Float64(a + Float64(Float64(x + z) + Float64(b * -2.0))) tmp = 0.0 if (y <= -2.4e+56) tmp = t_2; elseif (y <= -2.35e-138) tmp = t_1; elseif (y <= 3.4e-290) tmp = t_3; elseif (y <= 4.5e-227) tmp = t_1; elseif (y <= 6.5e-14) tmp = t_3; elseif (y <= 4.8e+93) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (t * (b - a)); t_2 = y * (b - z); t_3 = a + ((x + z) + (b * -2.0)); tmp = 0.0; if (y <= -2.4e+56) tmp = t_2; elseif (y <= -2.35e-138) tmp = t_1; elseif (y <= 3.4e-290) tmp = t_3; elseif (y <= 4.5e-227) tmp = t_1; elseif (y <= 6.5e-14) tmp = t_3; elseif (y <= 4.8e+93) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(a + N[(N[(x + z), $MachinePrecision] + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.4e+56], t$95$2, If[LessEqual[y, -2.35e-138], t$95$1, If[LessEqual[y, 3.4e-290], t$95$3, If[LessEqual[y, 4.5e-227], t$95$1, If[LessEqual[y, 6.5e-14], t$95$3, If[LessEqual[y, 4.8e+93], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \left(b - a\right)\\
t_2 := y \cdot \left(b - z\right)\\
t_3 := a + \left(\left(x + z\right) + b \cdot -2\right)\\
\mathbf{if}\;y \leq -2.4 \cdot 10^{+56}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -2.35 \cdot 10^{-138}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 3.4 \cdot 10^{-290}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-227}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 6.5 \cdot 10^{-14}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq 4.8 \cdot 10^{+93}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -2.40000000000000013e56 or 4.80000000000000021e93 < y Initial program 95.4%
associate-+l-95.4%
*-commutative95.4%
*-commutative95.4%
sub-neg95.4%
metadata-eval95.4%
remove-double-neg95.4%
remove-double-neg95.4%
sub-neg95.4%
metadata-eval95.4%
associate--l+95.4%
Simplified95.4%
Taylor expanded in y around inf 74.4%
if -2.40000000000000013e56 < y < -2.3500000000000001e-138 or 3.39999999999999984e-290 < y < 4.49999999999999993e-227 or 6.5000000000000001e-14 < y < 4.80000000000000021e93Initial program 98.7%
associate-+l-98.7%
*-commutative98.7%
*-commutative98.7%
sub-neg98.7%
metadata-eval98.7%
remove-double-neg98.7%
remove-double-neg98.7%
sub-neg98.7%
metadata-eval98.7%
associate--l+98.7%
Simplified98.7%
Taylor expanded in t around inf 86.2%
Taylor expanded in z around 0 69.2%
if -2.3500000000000001e-138 < y < 3.39999999999999984e-290 or 4.49999999999999993e-227 < y < 6.5000000000000001e-14Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 75.9%
Final simplification73.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* t (- b a)))) (t_2 (+ a (+ (+ x z) (* b -2.0)))))
(if (<= y -4.6e+56)
(- (* y b) (* y z))
(if (<= y -5.8e-138)
t_1
(if (<= y 1.5e-289)
t_2
(if (<= y 4.2e-227)
t_1
(if (<= y 2.7e-13) t_2 (if (<= y 4.1e+92) t_1 (* y (- b z))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = a + ((x + z) + (b * -2.0));
double tmp;
if (y <= -4.6e+56) {
tmp = (y * b) - (y * z);
} else if (y <= -5.8e-138) {
tmp = t_1;
} else if (y <= 1.5e-289) {
tmp = t_2;
} else if (y <= 4.2e-227) {
tmp = t_1;
} else if (y <= 2.7e-13) {
tmp = t_2;
} else if (y <= 4.1e+92) {
tmp = t_1;
} else {
tmp = y * (b - z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t * (b - a))
t_2 = a + ((x + z) + (b * (-2.0d0)))
if (y <= (-4.6d+56)) then
tmp = (y * b) - (y * z)
else if (y <= (-5.8d-138)) then
tmp = t_1
else if (y <= 1.5d-289) then
tmp = t_2
else if (y <= 4.2d-227) then
tmp = t_1
else if (y <= 2.7d-13) then
tmp = t_2
else if (y <= 4.1d+92) then
tmp = t_1
else
tmp = y * (b - z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (t * (b - a));
double t_2 = a + ((x + z) + (b * -2.0));
double tmp;
if (y <= -4.6e+56) {
tmp = (y * b) - (y * z);
} else if (y <= -5.8e-138) {
tmp = t_1;
} else if (y <= 1.5e-289) {
tmp = t_2;
} else if (y <= 4.2e-227) {
tmp = t_1;
} else if (y <= 2.7e-13) {
tmp = t_2;
} else if (y <= 4.1e+92) {
tmp = t_1;
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (t * (b - a)) t_2 = a + ((x + z) + (b * -2.0)) tmp = 0 if y <= -4.6e+56: tmp = (y * b) - (y * z) elif y <= -5.8e-138: tmp = t_1 elif y <= 1.5e-289: tmp = t_2 elif y <= 4.2e-227: tmp = t_1 elif y <= 2.7e-13: tmp = t_2 elif y <= 4.1e+92: tmp = t_1 else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(t * Float64(b - a))) t_2 = Float64(a + Float64(Float64(x + z) + Float64(b * -2.0))) tmp = 0.0 if (y <= -4.6e+56) tmp = Float64(Float64(y * b) - Float64(y * z)); elseif (y <= -5.8e-138) tmp = t_1; elseif (y <= 1.5e-289) tmp = t_2; elseif (y <= 4.2e-227) tmp = t_1; elseif (y <= 2.7e-13) tmp = t_2; elseif (y <= 4.1e+92) tmp = t_1; else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (t * (b - a)); t_2 = a + ((x + z) + (b * -2.0)); tmp = 0.0; if (y <= -4.6e+56) tmp = (y * b) - (y * z); elseif (y <= -5.8e-138) tmp = t_1; elseif (y <= 1.5e-289) tmp = t_2; elseif (y <= 4.2e-227) tmp = t_1; elseif (y <= 2.7e-13) tmp = t_2; elseif (y <= 4.1e+92) 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[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a + N[(N[(x + z), $MachinePrecision] + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.6e+56], N[(N[(y * b), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -5.8e-138], t$95$1, If[LessEqual[y, 1.5e-289], t$95$2, If[LessEqual[y, 4.2e-227], t$95$1, If[LessEqual[y, 2.7e-13], t$95$2, If[LessEqual[y, 4.1e+92], t$95$1, N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \left(b - a\right)\\
t_2 := a + \left(\left(x + z\right) + b \cdot -2\right)\\
\mathbf{if}\;y \leq -4.6 \cdot 10^{+56}:\\
\;\;\;\;y \cdot b - y \cdot z\\
\mathbf{elif}\;y \leq -5.8 \cdot 10^{-138}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{-289}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{-227}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{-13}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 4.1 \cdot 10^{+92}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if y < -4.60000000000000029e56Initial program 96.4%
associate-+l-96.4%
*-commutative96.4%
*-commutative96.4%
sub-neg96.4%
metadata-eval96.4%
remove-double-neg96.4%
remove-double-neg96.4%
sub-neg96.4%
metadata-eval96.4%
associate--l+96.4%
Simplified96.4%
Taylor expanded in y around inf 78.5%
Taylor expanded in b around 0 78.5%
if -4.60000000000000029e56 < y < -5.79999999999999946e-138 or 1.4999999999999999e-289 < y < 4.1999999999999999e-227 or 2.70000000000000011e-13 < y < 4.10000000000000024e92Initial program 98.7%
associate-+l-98.7%
*-commutative98.7%
*-commutative98.7%
sub-neg98.7%
metadata-eval98.7%
remove-double-neg98.7%
remove-double-neg98.7%
sub-neg98.7%
metadata-eval98.7%
associate--l+98.7%
Simplified98.7%
Taylor expanded in t around inf 86.2%
Taylor expanded in z around 0 69.2%
if -5.79999999999999946e-138 < y < 1.4999999999999999e-289 or 4.1999999999999999e-227 < y < 2.70000000000000011e-13Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 75.9%
if 4.10000000000000024e92 < y 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 y around inf 70.1%
Final simplification73.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ x z) (* b (- t 2.0)))))
(if (<= y -1.5e+36)
(- (* y b) (* y z))
(if (<= y 2.15e-100)
t_1
(if (<= y 1.5e-29)
(+ a (+ (+ x z) (* b -2.0)))
(if (<= y 4.1e-13)
t_1
(if (<= y 3.35e+127)
(+ x (* t (- b a)))
(if (<= y 1e+178) (- x (* (+ y -1.0) z)) (* y (- b z))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + z) + (b * (t - 2.0));
double tmp;
if (y <= -1.5e+36) {
tmp = (y * b) - (y * z);
} else if (y <= 2.15e-100) {
tmp = t_1;
} else if (y <= 1.5e-29) {
tmp = a + ((x + z) + (b * -2.0));
} else if (y <= 4.1e-13) {
tmp = t_1;
} else if (y <= 3.35e+127) {
tmp = x + (t * (b - a));
} else if (y <= 1e+178) {
tmp = x - ((y + -1.0) * z);
} else {
tmp = y * (b - z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = (x + z) + (b * (t - 2.0d0))
if (y <= (-1.5d+36)) then
tmp = (y * b) - (y * z)
else if (y <= 2.15d-100) then
tmp = t_1
else if (y <= 1.5d-29) then
tmp = a + ((x + z) + (b * (-2.0d0)))
else if (y <= 4.1d-13) then
tmp = t_1
else if (y <= 3.35d+127) then
tmp = x + (t * (b - a))
else if (y <= 1d+178) then
tmp = x - ((y + (-1.0d0)) * z)
else
tmp = y * (b - z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + z) + (b * (t - 2.0));
double tmp;
if (y <= -1.5e+36) {
tmp = (y * b) - (y * z);
} else if (y <= 2.15e-100) {
tmp = t_1;
} else if (y <= 1.5e-29) {
tmp = a + ((x + z) + (b * -2.0));
} else if (y <= 4.1e-13) {
tmp = t_1;
} else if (y <= 3.35e+127) {
tmp = x + (t * (b - a));
} else if (y <= 1e+178) {
tmp = x - ((y + -1.0) * z);
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + z) + (b * (t - 2.0)) tmp = 0 if y <= -1.5e+36: tmp = (y * b) - (y * z) elif y <= 2.15e-100: tmp = t_1 elif y <= 1.5e-29: tmp = a + ((x + z) + (b * -2.0)) elif y <= 4.1e-13: tmp = t_1 elif y <= 3.35e+127: tmp = x + (t * (b - a)) elif y <= 1e+178: tmp = x - ((y + -1.0) * z) else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + z) + Float64(b * Float64(t - 2.0))) tmp = 0.0 if (y <= -1.5e+36) tmp = Float64(Float64(y * b) - Float64(y * z)); elseif (y <= 2.15e-100) tmp = t_1; elseif (y <= 1.5e-29) tmp = Float64(a + Float64(Float64(x + z) + Float64(b * -2.0))); elseif (y <= 4.1e-13) tmp = t_1; elseif (y <= 3.35e+127) tmp = Float64(x + Float64(t * Float64(b - a))); elseif (y <= 1e+178) tmp = Float64(x - Float64(Float64(y + -1.0) * z)); else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + z) + (b * (t - 2.0)); tmp = 0.0; if (y <= -1.5e+36) tmp = (y * b) - (y * z); elseif (y <= 2.15e-100) tmp = t_1; elseif (y <= 1.5e-29) tmp = a + ((x + z) + (b * -2.0)); elseif (y <= 4.1e-13) tmp = t_1; elseif (y <= 3.35e+127) tmp = x + (t * (b - a)); elseif (y <= 1e+178) tmp = x - ((y + -1.0) * z); else tmp = y * (b - z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + z), $MachinePrecision] + N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.5e+36], N[(N[(y * b), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.15e-100], t$95$1, If[LessEqual[y, 1.5e-29], N[(a + N[(N[(x + z), $MachinePrecision] + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.1e-13], t$95$1, If[LessEqual[y, 3.35e+127], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1e+178], N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + z\right) + b \cdot \left(t - 2\right)\\
\mathbf{if}\;y \leq -1.5 \cdot 10^{+36}:\\
\;\;\;\;y \cdot b - y \cdot z\\
\mathbf{elif}\;y \leq 2.15 \cdot 10^{-100}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{-29}:\\
\;\;\;\;a + \left(\left(x + z\right) + b \cdot -2\right)\\
\mathbf{elif}\;y \leq 4.1 \cdot 10^{-13}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 3.35 \cdot 10^{+127}:\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\mathbf{elif}\;y \leq 10^{+178}:\\
\;\;\;\;x - \left(y + -1\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if y < -1.5e36Initial program 96.6%
associate-+l-96.6%
*-commutative96.6%
*-commutative96.6%
sub-neg96.6%
metadata-eval96.6%
remove-double-neg96.6%
remove-double-neg96.6%
sub-neg96.6%
metadata-eval96.6%
associate--l+96.6%
Simplified96.6%
Taylor expanded in y around inf 77.5%
Taylor expanded in b around 0 77.6%
if -1.5e36 < y < 2.14999999999999999e-100 or 1.5000000000000001e-29 < y < 4.1000000000000002e-13Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
+-commutative99.9%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 97.2%
Taylor expanded in a around 0 72.6%
if 2.14999999999999999e-100 < y < 1.5000000000000001e-29Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 86.5%
if 4.1000000000000002e-13 < y < 3.3499999999999998e127Initial program 94.2%
associate-+l-94.2%
*-commutative94.2%
*-commutative94.2%
sub-neg94.2%
metadata-eval94.2%
remove-double-neg94.2%
remove-double-neg94.2%
sub-neg94.2%
metadata-eval94.2%
associate--l+94.2%
Simplified94.2%
Taylor expanded in t around inf 71.9%
Taylor expanded in z around 0 58.2%
if 3.3499999999999998e127 < y < 1.0000000000000001e178Initial program 94.7%
associate-+l-94.7%
*-commutative94.7%
*-commutative94.7%
sub-neg94.7%
metadata-eval94.7%
remove-double-neg94.7%
remove-double-neg94.7%
sub-neg94.7%
metadata-eval94.7%
associate--l+94.7%
Simplified94.7%
Taylor expanded in t around inf 82.5%
Taylor expanded in t around 0 82.0%
if 1.0000000000000001e178 < y Initial program 96.0%
associate-+l-96.0%
*-commutative96.0%
*-commutative96.0%
sub-neg96.0%
metadata-eval96.0%
remove-double-neg96.0%
remove-double-neg96.0%
sub-neg96.0%
metadata-eval96.0%
associate--l+96.0%
Simplified96.0%
Taylor expanded in y around inf 80.3%
Final simplification74.0%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -1.22e-11) (not (<= y 1.1e+52))) (+ (- x (* (+ y -1.0) z)) (* y b)) (+ (+ z (+ x (* b (- t 2.0)))) (* a (- 1.0 t)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -1.22e-11) || !(y <= 1.1e+52)) {
tmp = (x - ((y + -1.0) * z)) + (y * b);
} else {
tmp = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-1.22d-11)) .or. (.not. (y <= 1.1d+52))) then
tmp = (x - ((y + (-1.0d0)) * z)) + (y * b)
else
tmp = (z + (x + (b * (t - 2.0d0)))) + (a * (1.0d0 - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -1.22e-11) || !(y <= 1.1e+52)) {
tmp = (x - ((y + -1.0) * z)) + (y * b);
} else {
tmp = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -1.22e-11) or not (y <= 1.1e+52): tmp = (x - ((y + -1.0) * z)) + (y * b) else: tmp = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -1.22e-11) || !(y <= 1.1e+52)) tmp = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + Float64(y * b)); else tmp = Float64(Float64(z + Float64(x + Float64(b * Float64(t - 2.0)))) + Float64(a * Float64(1.0 - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -1.22e-11) || ~((y <= 1.1e+52))) tmp = (x - ((y + -1.0) * z)) + (y * b); else tmp = (z + (x + (b * (t - 2.0)))) + (a * (1.0 - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -1.22e-11], N[Not[LessEqual[y, 1.1e+52]], $MachinePrecision]], N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision], N[(N[(z + N[(x + N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.22 \cdot 10^{-11} \lor \neg \left(y \leq 1.1 \cdot 10^{+52}\right):\\
\;\;\;\;\left(x - \left(y + -1\right) \cdot z\right) + y \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(z + \left(x + b \cdot \left(t - 2\right)\right)\right) + a \cdot \left(1 - t\right)\\
\end{array}
\end{array}
if y < -1.2200000000000001e-11 or 1.1e52 < y Initial program 95.4%
associate-+l-95.4%
*-commutative95.4%
*-commutative95.4%
sub-neg95.4%
metadata-eval95.4%
remove-double-neg95.4%
remove-double-neg95.4%
sub-neg95.4%
metadata-eval95.4%
associate--l+95.4%
Simplified95.4%
Taylor expanded in y around inf 82.1%
mul-1-neg82.1%
distribute-rgt-neg-in82.1%
Simplified82.1%
if -1.2200000000000001e-11 < y < 1.1e52Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
+-commutative99.9%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 98.2%
Final simplification89.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= z -1.7e+95) (not (<= z 3.2e-73))) (+ (- x (* (+ y -1.0) z)) (* t (- b a))) (+ (+ x (* b (- (+ t y) 2.0))) (* a (- 1.0 t)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -1.7e+95) || !(z <= 3.2e-73)) {
tmp = (x - ((y + -1.0) * z)) + (t * (b - a));
} else {
tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((z <= (-1.7d+95)) .or. (.not. (z <= 3.2d-73))) then
tmp = (x - ((y + (-1.0d0)) * z)) + (t * (b - a))
else
tmp = (x + (b * ((t + y) - 2.0d0))) + (a * (1.0d0 - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -1.7e+95) || !(z <= 3.2e-73)) {
tmp = (x - ((y + -1.0) * z)) + (t * (b - a));
} else {
tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (z <= -1.7e+95) or not (z <= 3.2e-73): tmp = (x - ((y + -1.0) * z)) + (t * (b - a)) else: tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((z <= -1.7e+95) || !(z <= 3.2e-73)) tmp = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + Float64(t * Float64(b - a))); else tmp = Float64(Float64(x + Float64(b * Float64(Float64(t + y) - 2.0))) + Float64(a * Float64(1.0 - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((z <= -1.7e+95) || ~((z <= 3.2e-73))) tmp = (x - ((y + -1.0) * z)) + (t * (b - a)); else tmp = (x + (b * ((t + y) - 2.0))) + (a * (1.0 - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -1.7e+95], N[Not[LessEqual[z, 3.2e-73]], $MachinePrecision]], N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(b * N[(N[(t + y), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.7 \cdot 10^{+95} \lor \neg \left(z \leq 3.2 \cdot 10^{-73}\right):\\
\;\;\;\;\left(x - \left(y + -1\right) \cdot z\right) + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + b \cdot \left(\left(t + y\right) - 2\right)\right) + a \cdot \left(1 - t\right)\\
\end{array}
\end{array}
if z < -1.70000000000000011e95 or 3.19999999999999986e-73 < z Initial 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 89.2%
if -1.70000000000000011e95 < z < 3.19999999999999986e-73Initial 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 z around 0 91.6%
Final simplification90.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (- b a))))
(if (or (<= z -2.3e+125) (not (<= z 8.2e-69)))
(+ (- x (* (+ y -1.0) z)) t_1)
(+ (+ a (+ x (* (- y 2.0) b))) 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 ((z <= -2.3e+125) || !(z <= 8.2e-69)) {
tmp = (x - ((y + -1.0) * z)) + t_1;
} else {
tmp = (a + (x + ((y - 2.0) * b))) + 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 ((z <= (-2.3d+125)) .or. (.not. (z <= 8.2d-69))) then
tmp = (x - ((y + (-1.0d0)) * z)) + t_1
else
tmp = (a + (x + ((y - 2.0d0) * b))) + 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 ((z <= -2.3e+125) || !(z <= 8.2e-69)) {
tmp = (x - ((y + -1.0) * z)) + t_1;
} else {
tmp = (a + (x + ((y - 2.0) * b))) + t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (b - a) tmp = 0 if (z <= -2.3e+125) or not (z <= 8.2e-69): tmp = (x - ((y + -1.0) * z)) + t_1 else: tmp = (a + (x + ((y - 2.0) * b))) + t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(b - a)) tmp = 0.0 if ((z <= -2.3e+125) || !(z <= 8.2e-69)) tmp = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + t_1); else tmp = Float64(Float64(a + Float64(x + Float64(Float64(y - 2.0) * b))) + 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 ((z <= -2.3e+125) || ~((z <= 8.2e-69))) tmp = (x - ((y + -1.0) * z)) + t_1; else tmp = (a + (x + ((y - 2.0) * b))) + 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[Or[LessEqual[z, -2.3e+125], N[Not[LessEqual[z, 8.2e-69]], $MachinePrecision]], N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(a + N[(x + N[(N[(y - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(b - a\right)\\
\mathbf{if}\;z \leq -2.3 \cdot 10^{+125} \lor \neg \left(z \leq 8.2 \cdot 10^{-69}\right):\\
\;\;\;\;\left(x - \left(y + -1\right) \cdot z\right) + t_1\\
\mathbf{else}:\\
\;\;\;\;\left(a + \left(x + \left(y - 2\right) \cdot b\right)\right) + t_1\\
\end{array}
\end{array}
if z < -2.30000000000000013e125 or 8.1999999999999998e-69 < z Initial program 96.5%
associate-+l-96.5%
*-commutative96.5%
*-commutative96.5%
sub-neg96.5%
metadata-eval96.5%
remove-double-neg96.5%
remove-double-neg96.5%
sub-neg96.5%
metadata-eval96.5%
associate--l+96.5%
Simplified96.5%
Taylor expanded in t around inf 89.3%
if -2.30000000000000013e125 < z < 8.1999999999999998e-69Initial program 98.5%
sub-neg98.5%
+-commutative98.5%
associate-+l+98.5%
*-commutative98.5%
distribute-rgt-neg-in98.5%
+-commutative98.5%
fma-def98.6%
neg-sub098.6%
associate--r-98.6%
neg-sub098.6%
+-commutative98.6%
sub-neg98.6%
fma-def98.6%
sub-neg98.6%
associate-+l+98.6%
metadata-eval98.6%
sub-neg98.6%
+-commutative98.6%
Simplified98.6%
Taylor expanded in t around 0 99.3%
Taylor expanded in z around 0 92.1%
Final simplification90.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (- 1.0 y))) (t_2 (* t (- b a))))
(if (<= t -2.2e+97)
t_2
(if (<= t -4.2e-284)
t_1
(if (<= t 6e-297)
(* y b)
(if (<= t 1.75e-205)
(+ x z)
(if (<= t 1.15e-66) t_1 (if (<= t 1.15e+119) (+ x z) t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (1.0 - y);
double t_2 = t * (b - a);
double tmp;
if (t <= -2.2e+97) {
tmp = t_2;
} else if (t <= -4.2e-284) {
tmp = t_1;
} else if (t <= 6e-297) {
tmp = y * b;
} else if (t <= 1.75e-205) {
tmp = x + z;
} else if (t <= 1.15e-66) {
tmp = t_1;
} else if (t <= 1.15e+119) {
tmp = x + z;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = z * (1.0d0 - y)
t_2 = t * (b - a)
if (t <= (-2.2d+97)) then
tmp = t_2
else if (t <= (-4.2d-284)) then
tmp = t_1
else if (t <= 6d-297) then
tmp = y * b
else if (t <= 1.75d-205) then
tmp = x + z
else if (t <= 1.15d-66) then
tmp = t_1
else if (t <= 1.15d+119) then
tmp = x + z
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (1.0 - y);
double t_2 = t * (b - a);
double tmp;
if (t <= -2.2e+97) {
tmp = t_2;
} else if (t <= -4.2e-284) {
tmp = t_1;
} else if (t <= 6e-297) {
tmp = y * b;
} else if (t <= 1.75e-205) {
tmp = x + z;
} else if (t <= 1.15e-66) {
tmp = t_1;
} else if (t <= 1.15e+119) {
tmp = x + z;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z * (1.0 - y) t_2 = t * (b - a) tmp = 0 if t <= -2.2e+97: tmp = t_2 elif t <= -4.2e-284: tmp = t_1 elif t <= 6e-297: tmp = y * b elif t <= 1.75e-205: tmp = x + z elif t <= 1.15e-66: tmp = t_1 elif t <= 1.15e+119: tmp = x + z else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(1.0 - y)) t_2 = Float64(t * Float64(b - a)) tmp = 0.0 if (t <= -2.2e+97) tmp = t_2; elseif (t <= -4.2e-284) tmp = t_1; elseif (t <= 6e-297) tmp = Float64(y * b); elseif (t <= 1.75e-205) tmp = Float64(x + z); elseif (t <= 1.15e-66) tmp = t_1; elseif (t <= 1.15e+119) tmp = Float64(x + z); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z * (1.0 - y); t_2 = t * (b - a); tmp = 0.0; if (t <= -2.2e+97) tmp = t_2; elseif (t <= -4.2e-284) tmp = t_1; elseif (t <= 6e-297) tmp = y * b; elseif (t <= 1.75e-205) tmp = x + z; elseif (t <= 1.15e-66) tmp = t_1; elseif (t <= 1.15e+119) tmp = x + z; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.2e+97], t$95$2, If[LessEqual[t, -4.2e-284], t$95$1, If[LessEqual[t, 6e-297], N[(y * b), $MachinePrecision], If[LessEqual[t, 1.75e-205], N[(x + z), $MachinePrecision], If[LessEqual[t, 1.15e-66], t$95$1, If[LessEqual[t, 1.15e+119], N[(x + z), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(1 - y\right)\\
t_2 := t \cdot \left(b - a\right)\\
\mathbf{if}\;t \leq -2.2 \cdot 10^{+97}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{-284}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-297}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{-205}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-66}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{+119}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -2.2000000000000001e97 or 1.15e119 < t Initial program 91.8%
associate-+l-91.8%
*-commutative91.8%
*-commutative91.8%
sub-neg91.8%
metadata-eval91.8%
remove-double-neg91.8%
remove-double-neg91.8%
sub-neg91.8%
metadata-eval91.8%
associate--l+91.8%
Simplified91.8%
Taylor expanded in t around inf 70.1%
if -2.2000000000000001e97 < t < -4.19999999999999982e-284 or 1.75e-205 < t < 1.14999999999999996e-66Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around inf 47.9%
if -4.19999999999999982e-284 < t < 5.9999999999999999e-297Initial 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 75.6%
Taylor expanded in y around inf 75.7%
if 5.9999999999999999e-297 < t < 1.75e-205 or 1.14999999999999996e-66 < t < 1.15e119Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in t around inf 65.6%
Taylor expanded in t around 0 59.2%
Taylor expanded in y around 0 49.6%
sub-neg49.6%
neg-mul-149.6%
remove-double-neg49.6%
+-commutative49.6%
Simplified49.6%
Final simplification55.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ x a) (* (+ y -1.0) z))) (t_2 (* b (- (+ t y) 2.0))))
(if (<= b -2.45e+62)
t_2
(if (<= b -5e-114)
t_1
(if (<= b -5e-174)
(+ x (* t (- b a)))
(if (<= b 1.82e+177) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + a) - ((y + -1.0) * z);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -2.45e+62) {
tmp = t_2;
} else if (b <= -5e-114) {
tmp = t_1;
} else if (b <= -5e-174) {
tmp = x + (t * (b - a));
} else if (b <= 1.82e+177) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x + a) - ((y + (-1.0d0)) * z)
t_2 = b * ((t + y) - 2.0d0)
if (b <= (-2.45d+62)) then
tmp = t_2
else if (b <= (-5d-114)) then
tmp = t_1
else if (b <= (-5d-174)) then
tmp = x + (t * (b - a))
else if (b <= 1.82d+177) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + a) - ((y + -1.0) * z);
double t_2 = b * ((t + y) - 2.0);
double tmp;
if (b <= -2.45e+62) {
tmp = t_2;
} else if (b <= -5e-114) {
tmp = t_1;
} else if (b <= -5e-174) {
tmp = x + (t * (b - a));
} else if (b <= 1.82e+177) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + a) - ((y + -1.0) * z) t_2 = b * ((t + y) - 2.0) tmp = 0 if b <= -2.45e+62: tmp = t_2 elif b <= -5e-114: tmp = t_1 elif b <= -5e-174: tmp = x + (t * (b - a)) elif b <= 1.82e+177: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + a) - Float64(Float64(y + -1.0) * z)) t_2 = Float64(b * Float64(Float64(t + y) - 2.0)) tmp = 0.0 if (b <= -2.45e+62) tmp = t_2; elseif (b <= -5e-114) tmp = t_1; elseif (b <= -5e-174) tmp = Float64(x + Float64(t * Float64(b - a))); elseif (b <= 1.82e+177) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + a) - ((y + -1.0) * z); t_2 = b * ((t + y) - 2.0); tmp = 0.0; if (b <= -2.45e+62) tmp = t_2; elseif (b <= -5e-114) tmp = t_1; elseif (b <= -5e-174) tmp = x + (t * (b - a)); elseif (b <= 1.82e+177) 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 + a), $MachinePrecision] - 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, -2.45e+62], t$95$2, If[LessEqual[b, -5e-114], t$95$1, If[LessEqual[b, -5e-174], N[(x + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.82e+177], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + a\right) - \left(y + -1\right) \cdot z\\
t_2 := b \cdot \left(\left(t + y\right) - 2\right)\\
\mathbf{if}\;b \leq -2.45 \cdot 10^{+62}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -5 \cdot 10^{-114}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -5 \cdot 10^{-174}:\\
\;\;\;\;x + t \cdot \left(b - a\right)\\
\mathbf{elif}\;b \leq 1.82 \cdot 10^{+177}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -2.4499999999999998e62 or 1.82e177 < b Initial program 95.6%
associate-+l-95.6%
*-commutative95.6%
*-commutative95.6%
sub-neg95.6%
metadata-eval95.6%
remove-double-neg95.6%
remove-double-neg95.6%
sub-neg95.6%
metadata-eval95.6%
associate--l+95.6%
Simplified95.6%
Taylor expanded in b around inf 76.9%
if -2.4499999999999998e62 < b < -4.99999999999999989e-114 or -5.0000000000000002e-174 < b < 1.82e177Initial 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 a around inf 84.7%
sub-neg84.7%
metadata-eval84.7%
*-commutative84.7%
distribute-rgt-in84.7%
*-commutative84.7%
mul-1-neg84.7%
unsub-neg84.7%
Simplified84.7%
Taylor expanded in t around 0 73.5%
if -4.99999999999999989e-114 < b < -5.0000000000000002e-174Initial 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 100.0%
Taylor expanded in z around 0 81.0%
Final simplification74.8%
(FPCore (x y z t a b) :precision binary64 (if (or (<= z -9e-146) (not (<= z 4.4e-127))) (+ (- x (* (+ y -1.0) z)) (* t (- b a))) (+ (+ x (* y b)) (* a (- 1.0 t)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -9e-146) || !(z <= 4.4e-127)) {
tmp = (x - ((y + -1.0) * z)) + (t * (b - a));
} else {
tmp = (x + (y * b)) + (a * (1.0 - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((z <= (-9d-146)) .or. (.not. (z <= 4.4d-127))) then
tmp = (x - ((y + (-1.0d0)) * z)) + (t * (b - a))
else
tmp = (x + (y * b)) + (a * (1.0d0 - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -9e-146) || !(z <= 4.4e-127)) {
tmp = (x - ((y + -1.0) * z)) + (t * (b - a));
} else {
tmp = (x + (y * b)) + (a * (1.0 - t));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (z <= -9e-146) or not (z <= 4.4e-127): tmp = (x - ((y + -1.0) * z)) + (t * (b - a)) else: tmp = (x + (y * b)) + (a * (1.0 - t)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((z <= -9e-146) || !(z <= 4.4e-127)) tmp = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + Float64(t * Float64(b - a))); else tmp = Float64(Float64(x + Float64(y * b)) + Float64(a * Float64(1.0 - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((z <= -9e-146) || ~((z <= 4.4e-127))) tmp = (x - ((y + -1.0) * z)) + (t * (b - a)); else tmp = (x + (y * b)) + (a * (1.0 - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -9e-146], N[Not[LessEqual[z, 4.4e-127]], $MachinePrecision]], N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9 \cdot 10^{-146} \lor \neg \left(z \leq 4.4 \cdot 10^{-127}\right):\\
\;\;\;\;\left(x - \left(y + -1\right) \cdot z\right) + t \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + y \cdot b\right) + a \cdot \left(1 - t\right)\\
\end{array}
\end{array}
if z < -9.0000000000000001e-146 or 4.4000000000000003e-127 < z Initial program 97.2%
associate-+l-97.2%
*-commutative97.2%
*-commutative97.2%
sub-neg97.2%
metadata-eval97.2%
remove-double-neg97.2%
remove-double-neg97.2%
sub-neg97.2%
metadata-eval97.2%
associate--l+97.2%
Simplified97.2%
Taylor expanded in t around inf 83.4%
if -9.0000000000000001e-146 < z < 4.4000000000000003e-127Initial program 98.7%
associate-+l-98.7%
*-commutative98.7%
*-commutative98.7%
sub-neg98.7%
metadata-eval98.7%
remove-double-neg98.7%
remove-double-neg98.7%
sub-neg98.7%
metadata-eval98.7%
associate--l+98.7%
Simplified98.7%
Taylor expanded in z around 0 98.7%
Taylor expanded in y around inf 86.8%
Final simplification84.5%
(FPCore (x y z t a b)
:precision binary64
(if (<= y -1.35e+56)
(- (* y b) (* y z))
(if (<= y 3.05e+127)
(+ (+ x z) (* t (- b a)))
(if (<= y 1.1e+178) (- (+ x a) (* (+ y -1.0) z)) (* y (- b z))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -1.35e+56) {
tmp = (y * b) - (y * z);
} else if (y <= 3.05e+127) {
tmp = (x + z) + (t * (b - a));
} else if (y <= 1.1e+178) {
tmp = (x + a) - ((y + -1.0) * z);
} else {
tmp = y * (b - z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (y <= (-1.35d+56)) then
tmp = (y * b) - (y * z)
else if (y <= 3.05d+127) then
tmp = (x + z) + (t * (b - a))
else if (y <= 1.1d+178) then
tmp = (x + a) - ((y + (-1.0d0)) * z)
else
tmp = y * (b - z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -1.35e+56) {
tmp = (y * b) - (y * z);
} else if (y <= 3.05e+127) {
tmp = (x + z) + (t * (b - a));
} else if (y <= 1.1e+178) {
tmp = (x + a) - ((y + -1.0) * z);
} else {
tmp = y * (b - z);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -1.35e+56: tmp = (y * b) - (y * z) elif y <= 3.05e+127: tmp = (x + z) + (t * (b - a)) elif y <= 1.1e+178: tmp = (x + a) - ((y + -1.0) * z) else: tmp = y * (b - z) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -1.35e+56) tmp = Float64(Float64(y * b) - Float64(y * z)); elseif (y <= 3.05e+127) tmp = Float64(Float64(x + z) + Float64(t * Float64(b - a))); elseif (y <= 1.1e+178) tmp = Float64(Float64(x + a) - Float64(Float64(y + -1.0) * z)); else tmp = Float64(y * Float64(b - z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -1.35e+56) tmp = (y * b) - (y * z); elseif (y <= 3.05e+127) tmp = (x + z) + (t * (b - a)); elseif (y <= 1.1e+178) tmp = (x + a) - ((y + -1.0) * z); else tmp = y * (b - z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -1.35e+56], N[(N[(y * b), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.05e+127], N[(N[(x + z), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.1e+178], N[(N[(x + a), $MachinePrecision] - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.35 \cdot 10^{+56}:\\
\;\;\;\;y \cdot b - y \cdot z\\
\mathbf{elif}\;y \leq 3.05 \cdot 10^{+127}:\\
\;\;\;\;\left(x + z\right) + t \cdot \left(b - a\right)\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{+178}:\\
\;\;\;\;\left(x + a\right) - \left(y + -1\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(b - z\right)\\
\end{array}
\end{array}
if y < -1.35000000000000005e56Initial program 96.4%
associate-+l-96.4%
*-commutative96.4%
*-commutative96.4%
sub-neg96.4%
metadata-eval96.4%
remove-double-neg96.4%
remove-double-neg96.4%
sub-neg96.4%
metadata-eval96.4%
associate--l+96.4%
Simplified96.4%
Taylor expanded in y around inf 78.5%
Taylor expanded in b around 0 78.5%
if -1.35000000000000005e56 < y < 3.05000000000000023e127Initial program 98.6%
associate-+l-98.6%
*-commutative98.6%
*-commutative98.6%
sub-neg98.6%
metadata-eval98.6%
remove-double-neg98.6%
remove-double-neg98.6%
sub-neg98.6%
metadata-eval98.6%
associate--l+98.6%
Simplified98.6%
Taylor expanded in t around inf 78.1%
Taylor expanded in y around 0 73.2%
cancel-sign-sub-inv73.2%
metadata-eval73.2%
*-lft-identity73.2%
+-commutative73.2%
Simplified73.2%
if 3.05000000000000023e127 < y < 1.09999999999999999e178Initial 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 a around inf 89.7%
sub-neg89.7%
metadata-eval89.7%
*-commutative89.7%
distribute-rgt-in89.7%
*-commutative89.7%
mul-1-neg89.7%
unsub-neg89.7%
Simplified89.7%
Taylor expanded in t around 0 89.7%
if 1.09999999999999999e178 < y Initial program 96.0%
associate-+l-96.0%
*-commutative96.0%
*-commutative96.0%
sub-neg96.0%
metadata-eval96.0%
remove-double-neg96.0%
remove-double-neg96.0%
sub-neg96.0%
metadata-eval96.0%
associate--l+96.0%
Simplified96.0%
Taylor expanded in y around inf 80.3%
Final simplification76.3%
(FPCore (x y z t a b) :precision binary64 (if (or (<= z -2.3e+118) (not (<= z 2.9e-28))) (- (+ x a) (* (+ y -1.0) z)) (+ (+ x (* y b)) (* a (- 1.0 t)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -2.3e+118) || !(z <= 2.9e-28)) {
tmp = (x + a) - ((y + -1.0) * z);
} else {
tmp = (x + (y * b)) + (a * (1.0 - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((z <= (-2.3d+118)) .or. (.not. (z <= 2.9d-28))) then
tmp = (x + a) - ((y + (-1.0d0)) * z)
else
tmp = (x + (y * b)) + (a * (1.0d0 - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -2.3e+118) || !(z <= 2.9e-28)) {
tmp = (x + a) - ((y + -1.0) * z);
} else {
tmp = (x + (y * b)) + (a * (1.0 - t));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (z <= -2.3e+118) or not (z <= 2.9e-28): tmp = (x + a) - ((y + -1.0) * z) else: tmp = (x + (y * b)) + (a * (1.0 - t)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((z <= -2.3e+118) || !(z <= 2.9e-28)) tmp = Float64(Float64(x + a) - Float64(Float64(y + -1.0) * z)); else tmp = Float64(Float64(x + Float64(y * b)) + Float64(a * Float64(1.0 - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((z <= -2.3e+118) || ~((z <= 2.9e-28))) tmp = (x + a) - ((y + -1.0) * z); else tmp = (x + (y * b)) + (a * (1.0 - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -2.3e+118], N[Not[LessEqual[z, 2.9e-28]], $MachinePrecision]], N[(N[(x + a), $MachinePrecision] - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.3 \cdot 10^{+118} \lor \neg \left(z \leq 2.9 \cdot 10^{-28}\right):\\
\;\;\;\;\left(x + a\right) - \left(y + -1\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;\left(x + y \cdot b\right) + a \cdot \left(1 - t\right)\\
\end{array}
\end{array}
if z < -2.30000000000000016e118 or 2.90000000000000013e-28 < z Initial program 96.3%
associate-+l-96.3%
*-commutative96.3%
*-commutative96.3%
sub-neg96.3%
metadata-eval96.3%
remove-double-neg96.3%
remove-double-neg96.3%
sub-neg96.3%
metadata-eval96.3%
associate--l+96.3%
Simplified96.3%
Taylor expanded in a around inf 86.4%
sub-neg86.4%
metadata-eval86.4%
*-commutative86.4%
distribute-rgt-in86.4%
*-commutative86.4%
mul-1-neg86.4%
unsub-neg86.4%
Simplified86.4%
Taylor expanded in t around 0 80.3%
if -2.30000000000000016e118 < z < 2.90000000000000013e-28Initial program 98.6%
associate-+l-98.6%
*-commutative98.6%
*-commutative98.6%
sub-neg98.6%
metadata-eval98.6%
remove-double-neg98.6%
remove-double-neg98.6%
sub-neg98.6%
metadata-eval98.6%
associate--l+98.6%
Simplified98.6%
Taylor expanded in z around 0 91.0%
Taylor expanded in y around inf 76.0%
Final simplification77.8%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -1.22e-11) (not (<= y 8.8e+48))) (+ (- x (* (+ y -1.0) z)) (* y b)) (+ (+ x z) (* t (- b a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -1.22e-11) || !(y <= 8.8e+48)) {
tmp = (x - ((y + -1.0) * z)) + (y * b);
} else {
tmp = (x + z) + (t * (b - a));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-1.22d-11)) .or. (.not. (y <= 8.8d+48))) then
tmp = (x - ((y + (-1.0d0)) * z)) + (y * b)
else
tmp = (x + z) + (t * (b - a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -1.22e-11) || !(y <= 8.8e+48)) {
tmp = (x - ((y + -1.0) * z)) + (y * b);
} else {
tmp = (x + z) + (t * (b - a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -1.22e-11) or not (y <= 8.8e+48): tmp = (x - ((y + -1.0) * z)) + (y * b) else: tmp = (x + z) + (t * (b - a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -1.22e-11) || !(y <= 8.8e+48)) tmp = Float64(Float64(x - Float64(Float64(y + -1.0) * z)) + Float64(y * b)); else tmp = Float64(Float64(x + z) + Float64(t * Float64(b - a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -1.22e-11) || ~((y <= 8.8e+48))) tmp = (x - ((y + -1.0) * z)) + (y * b); else tmp = (x + z) + (t * (b - a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -1.22e-11], N[Not[LessEqual[y, 8.8e+48]], $MachinePrecision]], N[(N[(x - N[(N[(y + -1.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision], N[(N[(x + z), $MachinePrecision] + N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.22 \cdot 10^{-11} \lor \neg \left(y \leq 8.8 \cdot 10^{+48}\right):\\
\;\;\;\;\left(x - \left(y + -1\right) \cdot z\right) + y \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(x + z\right) + t \cdot \left(b - a\right)\\
\end{array}
\end{array}
if y < -1.2200000000000001e-11 or 8.7999999999999997e48 < y Initial program 95.5%
associate-+l-95.5%
*-commutative95.5%
*-commutative95.5%
sub-neg95.5%
metadata-eval95.5%
remove-double-neg95.5%
remove-double-neg95.5%
sub-neg95.5%
metadata-eval95.5%
associate--l+95.5%
Simplified95.5%
Taylor expanded in y around inf 81.5%
mul-1-neg81.5%
distribute-rgt-neg-in81.5%
Simplified81.5%
if -1.2200000000000001e-11 < y < 8.7999999999999997e48Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in t around inf 78.8%
Taylor expanded in y around 0 78.2%
cancel-sign-sub-inv78.2%
metadata-eval78.2%
*-lft-identity78.2%
+-commutative78.2%
Simplified78.2%
Final simplification79.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))))
(if (<= y -1.8e+35)
t_1
(if (<= y 1e-27)
(+ x (+ z a))
(if (<= y 1.16e+50) (* t (- b a)) (if (<= y 8.8e+51) a 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 <= -1.8e+35) {
tmp = t_1;
} else if (y <= 1e-27) {
tmp = x + (z + a);
} else if (y <= 1.16e+50) {
tmp = t * (b - a);
} else if (y <= 8.8e+51) {
tmp = a;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = y * (b - z)
if (y <= (-1.8d+35)) then
tmp = t_1
else if (y <= 1d-27) then
tmp = x + (z + a)
else if (y <= 1.16d+50) then
tmp = t * (b - a)
else if (y <= 8.8d+51) then
tmp = a
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (b - z);
double tmp;
if (y <= -1.8e+35) {
tmp = t_1;
} else if (y <= 1e-27) {
tmp = x + (z + a);
} else if (y <= 1.16e+50) {
tmp = t * (b - a);
} else if (y <= 8.8e+51) {
tmp = a;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * (b - z) tmp = 0 if y <= -1.8e+35: tmp = t_1 elif y <= 1e-27: tmp = x + (z + a) elif y <= 1.16e+50: tmp = t * (b - a) elif y <= 8.8e+51: tmp = a 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 <= -1.8e+35) tmp = t_1; elseif (y <= 1e-27) tmp = Float64(x + Float64(z + a)); elseif (y <= 1.16e+50) tmp = Float64(t * Float64(b - a)); elseif (y <= 8.8e+51) tmp = a; 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 <= -1.8e+35) tmp = t_1; elseif (y <= 1e-27) tmp = x + (z + a); elseif (y <= 1.16e+50) tmp = t * (b - a); elseif (y <= 8.8e+51) tmp = a; 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, -1.8e+35], t$95$1, If[LessEqual[y, 1e-27], N[(x + N[(z + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.16e+50], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.8e+51], a, t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b - z\right)\\
\mathbf{if}\;y \leq -1.8 \cdot 10^{+35}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 10^{-27}:\\
\;\;\;\;x + \left(z + a\right)\\
\mathbf{elif}\;y \leq 1.16 \cdot 10^{+50}:\\
\;\;\;\;t \cdot \left(b - a\right)\\
\mathbf{elif}\;y \leq 8.8 \cdot 10^{+51}:\\
\;\;\;\;a\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -1.8e35 or 8.79999999999999967e51 < y Initial program 95.1%
associate-+l-95.1%
*-commutative95.1%
*-commutative95.1%
sub-neg95.1%
metadata-eval95.1%
remove-double-neg95.1%
remove-double-neg95.1%
sub-neg95.1%
metadata-eval95.1%
associate--l+95.1%
Simplified95.1%
Taylor expanded in y around inf 71.8%
if -1.8e35 < y < 1e-27Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 97.4%
Taylor expanded in t around 0 66.2%
Taylor expanded in b around 0 57.8%
associate-+r+57.8%
Simplified57.8%
if 1e-27 < y < 1.16e50Initial program 99.7%
associate-+l-99.7%
*-commutative99.7%
*-commutative99.7%
sub-neg99.7%
metadata-eval99.7%
remove-double-neg99.7%
remove-double-neg99.7%
sub-neg99.7%
metadata-eval99.7%
associate--l+99.7%
Simplified99.7%
Taylor expanded in t around inf 50.6%
if 1.16e50 < y < 8.79999999999999967e51Initial program 100.0%
sub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 100.0%
Taylor expanded in a around inf 100.0%
Final simplification64.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (- y))))
(if (<= y -4.4e+37)
t_1
(if (<= y 6.5e-75)
(+ x z)
(if (<= y 4.2e+127)
(* a (- 1.0 t))
(if (<= y 2.1e+196) t_1 (* y b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * -y;
double tmp;
if (y <= -4.4e+37) {
tmp = t_1;
} else if (y <= 6.5e-75) {
tmp = x + z;
} else if (y <= 4.2e+127) {
tmp = a * (1.0 - t);
} else if (y <= 2.1e+196) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = z * -y
if (y <= (-4.4d+37)) then
tmp = t_1
else if (y <= 6.5d-75) then
tmp = x + z
else if (y <= 4.2d+127) then
tmp = a * (1.0d0 - t)
else if (y <= 2.1d+196) then
tmp = t_1
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * -y;
double tmp;
if (y <= -4.4e+37) {
tmp = t_1;
} else if (y <= 6.5e-75) {
tmp = x + z;
} else if (y <= 4.2e+127) {
tmp = a * (1.0 - t);
} else if (y <= 2.1e+196) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z * -y tmp = 0 if y <= -4.4e+37: tmp = t_1 elif y <= 6.5e-75: tmp = x + z elif y <= 4.2e+127: tmp = a * (1.0 - t) elif y <= 2.1e+196: tmp = t_1 else: tmp = y * b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(-y)) tmp = 0.0 if (y <= -4.4e+37) tmp = t_1; elseif (y <= 6.5e-75) tmp = Float64(x + z); elseif (y <= 4.2e+127) tmp = Float64(a * Float64(1.0 - t)); elseif (y <= 2.1e+196) tmp = t_1; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z * -y; tmp = 0.0; if (y <= -4.4e+37) tmp = t_1; elseif (y <= 6.5e-75) tmp = x + z; elseif (y <= 4.2e+127) tmp = a * (1.0 - t); elseif (y <= 2.1e+196) tmp = t_1; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * (-y)), $MachinePrecision]}, If[LessEqual[y, -4.4e+37], t$95$1, If[LessEqual[y, 6.5e-75], N[(x + z), $MachinePrecision], If[LessEqual[y, 4.2e+127], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.1e+196], t$95$1, N[(y * b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(-y\right)\\
\mathbf{if}\;y \leq -4.4 \cdot 10^{+37}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 6.5 \cdot 10^{-75}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{+127}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{elif}\;y \leq 2.1 \cdot 10^{+196}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -4.4000000000000001e37 or 4.19999999999999983e127 < y < 2.10000000000000015e196Initial program 95.1%
associate-+l-95.1%
*-commutative95.1%
*-commutative95.1%
sub-neg95.1%
metadata-eval95.1%
remove-double-neg95.1%
remove-double-neg95.1%
sub-neg95.1%
metadata-eval95.1%
associate--l+95.1%
Simplified95.1%
Taylor expanded in z around inf 53.1%
Taylor expanded in y around inf 53.1%
mul-1-neg53.1%
*-commutative53.1%
distribute-rgt-neg-in53.1%
Simplified53.1%
if -4.4000000000000001e37 < y < 6.5000000000000002e-75Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in t around inf 83.1%
Taylor expanded in t around 0 51.3%
Taylor expanded in y around 0 49.5%
sub-neg49.5%
neg-mul-149.5%
remove-double-neg49.5%
+-commutative49.5%
Simplified49.5%
if 6.5000000000000002e-75 < y < 4.19999999999999983e127Initial 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 a around inf 39.3%
if 2.10000000000000015e196 < y Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 61.1%
Taylor expanded in y around inf 61.2%
Final simplification49.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (- y))))
(if (<= y -5.8e+35)
t_1
(if (<= y 4.2e-41)
(+ x z)
(if (<= y 3.05e+127) (* t (- b a)) (if (<= y 7.5e+200) t_1 (* y b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * -y;
double tmp;
if (y <= -5.8e+35) {
tmp = t_1;
} else if (y <= 4.2e-41) {
tmp = x + z;
} else if (y <= 3.05e+127) {
tmp = t * (b - a);
} else if (y <= 7.5e+200) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = z * -y
if (y <= (-5.8d+35)) then
tmp = t_1
else if (y <= 4.2d-41) then
tmp = x + z
else if (y <= 3.05d+127) then
tmp = t * (b - a)
else if (y <= 7.5d+200) then
tmp = t_1
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * -y;
double tmp;
if (y <= -5.8e+35) {
tmp = t_1;
} else if (y <= 4.2e-41) {
tmp = x + z;
} else if (y <= 3.05e+127) {
tmp = t * (b - a);
} else if (y <= 7.5e+200) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z * -y tmp = 0 if y <= -5.8e+35: tmp = t_1 elif y <= 4.2e-41: tmp = x + z elif y <= 3.05e+127: tmp = t * (b - a) elif y <= 7.5e+200: tmp = t_1 else: tmp = y * b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(-y)) tmp = 0.0 if (y <= -5.8e+35) tmp = t_1; elseif (y <= 4.2e-41) tmp = Float64(x + z); elseif (y <= 3.05e+127) tmp = Float64(t * Float64(b - a)); elseif (y <= 7.5e+200) tmp = t_1; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z * -y; tmp = 0.0; if (y <= -5.8e+35) tmp = t_1; elseif (y <= 4.2e-41) tmp = x + z; elseif (y <= 3.05e+127) tmp = t * (b - a); elseif (y <= 7.5e+200) tmp = t_1; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * (-y)), $MachinePrecision]}, If[LessEqual[y, -5.8e+35], t$95$1, If[LessEqual[y, 4.2e-41], N[(x + z), $MachinePrecision], If[LessEqual[y, 3.05e+127], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7.5e+200], t$95$1, N[(y * b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(-y\right)\\
\mathbf{if}\;y \leq -5.8 \cdot 10^{+35}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{-41}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;y \leq 3.05 \cdot 10^{+127}:\\
\;\;\;\;t \cdot \left(b - a\right)\\
\mathbf{elif}\;y \leq 7.5 \cdot 10^{+200}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -5.79999999999999989e35 or 3.05000000000000023e127 < y < 7.50000000000000062e200Initial program 95.1%
associate-+l-95.1%
*-commutative95.1%
*-commutative95.1%
sub-neg95.1%
metadata-eval95.1%
remove-double-neg95.1%
remove-double-neg95.1%
sub-neg95.1%
metadata-eval95.1%
associate--l+95.1%
Simplified95.1%
Taylor expanded in z around inf 53.1%
Taylor expanded in y around inf 53.1%
mul-1-neg53.1%
*-commutative53.1%
distribute-rgt-neg-in53.1%
Simplified53.1%
if -5.79999999999999989e35 < y < 4.20000000000000025e-41Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in t around inf 82.1%
Taylor expanded in t around 0 50.9%
Taylor expanded in y around 0 49.1%
sub-neg49.1%
neg-mul-149.1%
remove-double-neg49.1%
+-commutative49.1%
Simplified49.1%
if 4.20000000000000025e-41 < y < 3.05000000000000023e127Initial 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 t around inf 43.4%
if 7.50000000000000062e200 < y Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 61.1%
Taylor expanded in y around inf 61.2%
Final simplification50.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (- b z))))
(if (<= y -1.05e+35)
t_1
(if (<= y 2.5e-75) (+ x z) (if (<= y 1e+53) (* a (- 1.0 t)) 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 <= -1.05e+35) {
tmp = t_1;
} else if (y <= 2.5e-75) {
tmp = x + z;
} else if (y <= 1e+53) {
tmp = a * (1.0 - t);
} 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 <= (-1.05d+35)) then
tmp = t_1
else if (y <= 2.5d-75) then
tmp = x + z
else if (y <= 1d+53) then
tmp = a * (1.0d0 - t)
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 <= -1.05e+35) {
tmp = t_1;
} else if (y <= 2.5e-75) {
tmp = x + z;
} else if (y <= 1e+53) {
tmp = a * (1.0 - t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * (b - z) tmp = 0 if y <= -1.05e+35: tmp = t_1 elif y <= 2.5e-75: tmp = x + z elif y <= 1e+53: tmp = a * (1.0 - t) 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 <= -1.05e+35) tmp = t_1; elseif (y <= 2.5e-75) tmp = Float64(x + z); elseif (y <= 1e+53) tmp = Float64(a * Float64(1.0 - t)); 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 <= -1.05e+35) tmp = t_1; elseif (y <= 2.5e-75) tmp = x + z; elseif (y <= 1e+53) tmp = a * (1.0 - t); 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, -1.05e+35], t$95$1, If[LessEqual[y, 2.5e-75], N[(x + z), $MachinePrecision], If[LessEqual[y, 1e+53], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b - z\right)\\
\mathbf{if}\;y \leq -1.05 \cdot 10^{+35}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{-75}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;y \leq 10^{+53}:\\
\;\;\;\;a \cdot \left(1 - t\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -1.0499999999999999e35 or 9.9999999999999999e52 < y Initial program 95.1%
associate-+l-95.1%
*-commutative95.1%
*-commutative95.1%
sub-neg95.1%
metadata-eval95.1%
remove-double-neg95.1%
remove-double-neg95.1%
sub-neg95.1%
metadata-eval95.1%
associate--l+95.1%
Simplified95.1%
Taylor expanded in y around inf 71.8%
if -1.0499999999999999e35 < y < 2.49999999999999989e-75Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in t around inf 83.1%
Taylor expanded in t around 0 51.3%
Taylor expanded in y around 0 49.5%
sub-neg49.5%
neg-mul-149.5%
remove-double-neg49.5%
+-commutative49.5%
Simplified49.5%
if 2.49999999999999989e-75 < y < 9.9999999999999999e52Initial program 99.8%
associate-+l-99.8%
*-commutative99.8%
*-commutative99.8%
sub-neg99.8%
metadata-eval99.8%
remove-double-neg99.8%
remove-double-neg99.8%
sub-neg99.8%
metadata-eval99.8%
associate--l+99.8%
Simplified99.8%
Taylor expanded in a around inf 43.1%
Final simplification59.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (- y))))
(if (<= y -1.15e+37)
t_1
(if (<= y 2.5e+23) (+ x z) (if (<= y 2.5e+198) t_1 (* y b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * -y;
double tmp;
if (y <= -1.15e+37) {
tmp = t_1;
} else if (y <= 2.5e+23) {
tmp = x + z;
} else if (y <= 2.5e+198) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = z * -y
if (y <= (-1.15d+37)) then
tmp = t_1
else if (y <= 2.5d+23) then
tmp = x + z
else if (y <= 2.5d+198) then
tmp = t_1
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * -y;
double tmp;
if (y <= -1.15e+37) {
tmp = t_1;
} else if (y <= 2.5e+23) {
tmp = x + z;
} else if (y <= 2.5e+198) {
tmp = t_1;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z * -y tmp = 0 if y <= -1.15e+37: tmp = t_1 elif y <= 2.5e+23: tmp = x + z elif y <= 2.5e+198: tmp = t_1 else: tmp = y * b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(-y)) tmp = 0.0 if (y <= -1.15e+37) tmp = t_1; elseif (y <= 2.5e+23) tmp = Float64(x + z); elseif (y <= 2.5e+198) tmp = t_1; else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z * -y; tmp = 0.0; if (y <= -1.15e+37) tmp = t_1; elseif (y <= 2.5e+23) tmp = x + z; elseif (y <= 2.5e+198) tmp = t_1; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * (-y)), $MachinePrecision]}, If[LessEqual[y, -1.15e+37], t$95$1, If[LessEqual[y, 2.5e+23], N[(x + z), $MachinePrecision], If[LessEqual[y, 2.5e+198], t$95$1, N[(y * b), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(-y\right)\\
\mathbf{if}\;y \leq -1.15 \cdot 10^{+37}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{+23}:\\
\;\;\;\;x + z\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{+198}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -1.15000000000000001e37 or 2.5e23 < y < 2.50000000000000024e198Initial program 94.4%
associate-+l-94.4%
*-commutative94.4%
*-commutative94.4%
sub-neg94.4%
metadata-eval94.4%
remove-double-neg94.4%
remove-double-neg94.4%
sub-neg94.4%
metadata-eval94.4%
associate--l+94.4%
Simplified94.4%
Taylor expanded in z around inf 46.7%
Taylor expanded in y around inf 46.7%
mul-1-neg46.7%
*-commutative46.7%
distribute-rgt-neg-in46.7%
Simplified46.7%
if -1.15000000000000001e37 < y < 2.5e23Initial program 99.9%
associate-+l-99.9%
*-commutative99.9%
*-commutative99.9%
sub-neg99.9%
metadata-eval99.9%
remove-double-neg99.9%
remove-double-neg99.9%
sub-neg99.9%
metadata-eval99.9%
associate--l+99.9%
Simplified99.9%
Taylor expanded in t around inf 79.6%
Taylor expanded in t around 0 47.5%
Taylor expanded in y around 0 45.3%
sub-neg45.3%
neg-mul-145.3%
remove-double-neg45.3%
+-commutative45.3%
Simplified45.3%
if 2.50000000000000024e198 < y Initial program 100.0%
associate-+l-100.0%
*-commutative100.0%
*-commutative100.0%
sub-neg100.0%
metadata-eval100.0%
remove-double-neg100.0%
remove-double-neg100.0%
sub-neg100.0%
metadata-eval100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in b around inf 61.1%
Taylor expanded in y around inf 61.2%
Final simplification47.2%
(FPCore (x y z t a b) :precision binary64 (if (<= y -8200000000.0) (* y b) (if (<= y 1e-27) (+ z a) (if (<= y 1.85e+92) (* t b) (* y b)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -8200000000.0) {
tmp = y * b;
} else if (y <= 1e-27) {
tmp = z + a;
} else if (y <= 1.85e+92) {
tmp = t * b;
} else {
tmp = y * b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (y <= (-8200000000.0d0)) then
tmp = y * b
else if (y <= 1d-27) then
tmp = z + a
else if (y <= 1.85d+92) then
tmp = t * b
else
tmp = y * b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -8200000000.0) {
tmp = y * b;
} else if (y <= 1e-27) {
tmp = z + a;
} else if (y <= 1.85e+92) {
tmp = t * b;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -8200000000.0: tmp = y * b elif y <= 1e-27: tmp = z + a elif y <= 1.85e+92: tmp = t * b else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -8200000000.0) tmp = Float64(y * b); elseif (y <= 1e-27) tmp = Float64(z + a); elseif (y <= 1.85e+92) tmp = Float64(t * b); else tmp = Float64(y * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -8200000000.0) tmp = y * b; elseif (y <= 1e-27) tmp = z + a; elseif (y <= 1.85e+92) tmp = t * b; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -8200000000.0], N[(y * b), $MachinePrecision], If[LessEqual[y, 1e-27], N[(z + a), $MachinePrecision], If[LessEqual[y, 1.85e+92], N[(t * b), $MachinePrecision], N[(y * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8200000000:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;y \leq 10^{-27}:\\
\;\;\;\;z + a\\
\mathbf{elif}\;y \leq 1.85 \cdot 10^{+92}:\\
\;\;\;\;t \cdot b\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -8.2e9 or 1.84999999999999999e92 < y Initial program 95.7%
associate-+l-95.7%
*-commutative95.7%
*-commutative95.7%
sub-neg95.7%
metadata-eval95.7%
remove-double-neg95.7%
remove-double-neg95.7%
sub-neg95.7%
metadata-eval95.7%
associate--l+95.7%
Simplified95.7%
Taylor expanded in b around inf 37.9%
Taylor expanded in y around inf 36.1%
if -8.2e9 < y < 1e-27Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
associate-+l+100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
+-commutative100.0%
fma-def100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
fma-def100.0%
sub-neg100.0%
associate-+l+100.0%
metadata-eval100.0%
sub-neg100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in y around 0 99.0%
Taylor expanded in t around 0 67.1%
Taylor expanded in z around inf 37.5%
if 1e-27 < y < 1.84999999999999999e92Initial program 96.4%
associate-+l-96.4%
*-commutative96.4%
*-commutative96.4%
sub-neg96.4%
metadata-eval96.4%
remove-double-neg96.4%
remove-double-neg96.4%
sub-neg96.4%
metadata-eval96.4%
associate--l+96.4%
Simplified96.4%
Taylor expanded in b around inf 43.5%
Taylor expanded in t around inf 27.2%
Final simplification35.7%
(FPCore (x y z t a b) :precision binary64 (if (<= x -8e+128) x (if (<= x 1e+56) (* y b) x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -8e+128) {
tmp = x;
} else if (x <= 1e+56) {
tmp = y * 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 <= (-8d+128)) then
tmp = x
else if (x <= 1d+56) then
tmp = y * 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 <= -8e+128) {
tmp = x;
} else if (x <= 1e+56) {
tmp = y * b;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -8e+128: tmp = x elif x <= 1e+56: tmp = y * b else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -8e+128) tmp = x; elseif (x <= 1e+56) tmp = Float64(y * b); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -8e+128) tmp = x; elseif (x <= 1e+56) tmp = y * b; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -8e+128], x, If[LessEqual[x, 1e+56], N[(y * b), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -8 \cdot 10^{+128}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 10^{+56}:\\
\;\;\;\;y \cdot b\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -8.0000000000000006e128 or 1.00000000000000009e56 < x Initial program 98.9%
associate-+l-98.9%
*-commutative98.9%
*-commutative98.9%
sub-neg98.9%
metadata-eval98.9%
remove-double-neg98.9%
remove-double-neg98.9%
sub-neg98.9%
metadata-eval98.9%
associate--l+98.9%
Simplified98.9%
Taylor expanded in x around inf 40.2%
if -8.0000000000000006e128 < x < 1.00000000000000009e56Initial 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 b around inf 39.1%
Taylor expanded in y around inf 24.9%
Final simplification30.6%
(FPCore (x y z t a b) :precision binary64 (if (<= y -2.45e+86) (* y b) (if (<= y 3.5e+94) (+ x z) (* y b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -2.45e+86) {
tmp = y * b;
} else if (y <= 3.5e+94) {
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 (y <= (-2.45d+86)) then
tmp = y * b
else if (y <= 3.5d+94) 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 (y <= -2.45e+86) {
tmp = y * b;
} else if (y <= 3.5e+94) {
tmp = x + z;
} else {
tmp = y * b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -2.45e+86: tmp = y * b elif y <= 3.5e+94: tmp = x + z else: tmp = y * b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -2.45e+86) tmp = Float64(y * b); elseif (y <= 3.5e+94) 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 (y <= -2.45e+86) tmp = y * b; elseif (y <= 3.5e+94) tmp = x + z; else tmp = y * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -2.45e+86], N[(y * b), $MachinePrecision], If[LessEqual[y, 3.5e+94], N[(x + z), $MachinePrecision], N[(y * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.45 \cdot 10^{+86}:\\
\;\;\;\;y \cdot b\\
\mathbf{elif}\;y \leq 3.5 \cdot 10^{+94}:\\
\;\;\;\;x + z\\
\mathbf{else}:\\
\;\;\;\;y \cdot b\\
\end{array}
\end{array}
if y < -2.45e86 or 3.4999999999999997e94 < y Initial program 95.0%
associate-+l-95.0%
*-commutative95.0%
*-commutative95.0%
sub-neg95.0%
metadata-eval95.0%
remove-double-neg95.0%
remove-double-neg95.0%
sub-neg95.0%
metadata-eval95.0%
associate--l+95.0%
Simplified95.0%
Taylor expanded in b around inf 40.3%
Taylor expanded in y around inf 39.5%
if -2.45e86 < y < 3.4999999999999997e94Initial program 99.3%
associate-+l-99.3%
*-commutative99.3%
*-commutative99.3%
sub-neg99.3%
metadata-eval99.3%
remove-double-neg99.3%
remove-double-neg99.3%
sub-neg99.3%
metadata-eval99.3%
associate--l+99.3%
Simplified99.3%
Taylor expanded in t around inf 79.9%
Taylor expanded in t around 0 49.3%
Taylor expanded in y around 0 40.8%
sub-neg40.8%
neg-mul-140.8%
remove-double-neg40.8%
+-commutative40.8%
Simplified40.8%
Final simplification40.3%
(FPCore (x y z t a b) :precision binary64 (if (<= a -7.8e+121) a (if (<= a 1e+41) x a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -7.8e+121) {
tmp = a;
} else if (a <= 1e+41) {
tmp = x;
} else {
tmp = a;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= (-7.8d+121)) then
tmp = a
else if (a <= 1d+41) then
tmp = x
else
tmp = a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -7.8e+121) {
tmp = a;
} else if (a <= 1e+41) {
tmp = x;
} else {
tmp = a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -7.8e+121: tmp = a elif a <= 1e+41: tmp = x else: tmp = a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -7.8e+121) tmp = a; elseif (a <= 1e+41) tmp = x; else tmp = a; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -7.8e+121) tmp = a; elseif (a <= 1e+41) tmp = x; else tmp = a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -7.8e+121], a, If[LessEqual[a, 1e+41], x, a]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -7.8 \cdot 10^{+121}:\\
\;\;\;\;a\\
\mathbf{elif}\;a \leq 10^{+41}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;a\\
\end{array}
\end{array}
if a < -7.79999999999999967e121 or 1.00000000000000001e41 < a Initial program 94.9%
sub-neg94.9%
+-commutative94.9%
associate-+l+94.9%
*-commutative94.9%
distribute-rgt-neg-in94.9%
+-commutative94.9%
fma-def96.2%
neg-sub096.2%
associate--r-96.2%
neg-sub096.2%
+-commutative96.2%
sub-neg96.2%
fma-def97.5%
sub-neg97.5%
associate-+l+97.5%
metadata-eval97.5%
sub-neg97.5%
+-commutative97.5%
Simplified97.5%
Taylor expanded in y around 0 69.3%
Taylor expanded in t around 0 34.8%
Taylor expanded in a around inf 25.1%
if -7.79999999999999967e121 < a < 1.00000000000000001e41Initial program 98.8%
associate-+l-98.8%
*-commutative98.8%
*-commutative98.8%
sub-neg98.8%
metadata-eval98.8%
remove-double-neg98.8%
remove-double-neg98.8%
sub-neg98.8%
metadata-eval98.8%
associate--l+98.8%
Simplified98.8%
Taylor expanded in x around inf 24.2%
Final simplification24.4%
(FPCore (x y z t a b) :precision binary64 (if (<= z -1.5e+150) z (if (<= z 3.15e+41) x z)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= -1.5e+150) {
tmp = z;
} else if (z <= 3.15e+41) {
tmp = x;
} else {
tmp = z;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (z <= (-1.5d+150)) then
tmp = z
else if (z <= 3.15d+41) then
tmp = x
else
tmp = z
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= -1.5e+150) {
tmp = z;
} else if (z <= 3.15e+41) {
tmp = x;
} else {
tmp = z;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if z <= -1.5e+150: tmp = z elif z <= 3.15e+41: tmp = x else: tmp = z return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (z <= -1.5e+150) tmp = z; elseif (z <= 3.15e+41) tmp = x; else tmp = z; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (z <= -1.5e+150) tmp = z; elseif (z <= 3.15e+41) tmp = x; else tmp = z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -1.5e+150], z, If[LessEqual[z, 3.15e+41], x, z]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.5 \cdot 10^{+150}:\\
\;\;\;\;z\\
\mathbf{elif}\;z \leq 3.15 \cdot 10^{+41}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;z\\
\end{array}
\end{array}
if z < -1.50000000000000006e150 or 3.1499999999999999e41 < z 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 z around inf 70.0%
Taylor expanded in y around 0 31.0%
if -1.50000000000000006e150 < z < 3.1499999999999999e41Initial program 98.7%
associate-+l-98.7%
*-commutative98.7%
*-commutative98.7%
sub-neg98.7%
metadata-eval98.7%
remove-double-neg98.7%
remove-double-neg98.7%
sub-neg98.7%
metadata-eval98.7%
associate--l+98.7%
Simplified98.7%
Taylor expanded in x around inf 24.3%
Final simplification26.8%
(FPCore (x y z t a b) :precision binary64 a)
double code(double x, double y, double z, double t, double a, double b) {
return a;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return a;
}
def code(x, y, z, t, a, b): return a
function code(x, y, z, t, a, b) return a end
function tmp = code(x, y, z, t, a, b) tmp = a; end
code[x_, y_, z_, t_, a_, b_] := a
\begin{array}{l}
\\
a
\end{array}
Initial program 97.6%
sub-neg97.6%
+-commutative97.6%
associate-+l+97.6%
*-commutative97.6%
distribute-rgt-neg-in97.6%
+-commutative97.6%
fma-def98.0%
neg-sub098.0%
associate--r-98.0%
neg-sub098.0%
+-commutative98.0%
sub-neg98.0%
fma-def98.4%
sub-neg98.4%
associate-+l+98.4%
metadata-eval98.4%
sub-neg98.4%
+-commutative98.4%
Simplified98.4%
Taylor expanded in y around 0 64.8%
Taylor expanded in t around 0 41.5%
Taylor expanded in a around inf 9.2%
Final simplification9.2%
herbie shell --seed 2023230
(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)))