
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
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
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 29 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
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
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (or (<= t_1 -5e-285) (not (<= t_1 5e-210)))
(+ x (* (- x t) (/ (- z y) (- a z))))
(+ t (/ (- x t) (/ z (- y a)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if ((t_1 <= -5e-285) || !(t_1 <= 5e-210)) {
tmp = x + ((x - t) * ((z - y) / (a - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = x + ((y - z) * ((t - x) / (a - z)))
if ((t_1 <= (-5d-285)) .or. (.not. (t_1 <= 5d-210))) then
tmp = x + ((x - t) * ((z - y) / (a - z)))
else
tmp = t + ((x - t) / (z / (y - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if ((t_1 <= -5e-285) || !(t_1 <= 5e-210)) {
tmp = x + ((x - t) * ((z - y) / (a - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y - z) * ((t - x) / (a - z))) tmp = 0 if (t_1 <= -5e-285) or not (t_1 <= 5e-210): tmp = x + ((x - t) * ((z - y) / (a - z))) else: tmp = t + ((x - t) / (z / (y - a))) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) tmp = 0.0 if ((t_1 <= -5e-285) || !(t_1 <= 5e-210)) tmp = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y - z) * ((t - x) / (a - z))); tmp = 0.0; if ((t_1 <= -5e-285) || ~((t_1 <= 5e-210))) tmp = x + ((x - t) * ((z - y) / (a - z))); else tmp = t + ((x - t) / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-285], N[Not[LessEqual[t$95$1, 5e-210]], $MachinePrecision]], N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-285} \lor \neg \left(t\_1 \leq 5 \cdot 10^{-210}\right):\\
\;\;\;\;x + \left(x - t\right) \cdot \frac{z - y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -5.00000000000000018e-285 or 5.0000000000000002e-210 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 90.5%
Taylor expanded in y around 0 75.5%
+-commutative75.5%
div-sub76.4%
associate-*r/74.6%
mul-1-neg74.6%
sub-neg74.6%
associate-/l*76.4%
associate-/l*90.3%
div-sub90.5%
associate-/r/94.3%
Simplified94.3%
if -5.00000000000000018e-285 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 5.0000000000000002e-210Initial program 3.7%
Taylor expanded in z around inf 74.8%
associate--l+74.8%
distribute-lft-out--74.8%
div-sub74.8%
mul-1-neg74.8%
unsub-neg74.8%
distribute-rgt-out--74.8%
associate-/l*94.2%
Simplified94.2%
Final simplification94.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- y z) (/ t a))))
(if (<= a -2.55e+160)
x
(if (<= a -59.0)
t_1
(if (<= a 2.8e-242)
(- t (/ t (/ z y)))
(if (<= a 6.2e-55)
(* x (/ (- y a) z))
(if (<= a 1.5e+38)
(/ t (/ (- z a) z))
(if (<= a 1.8e+91)
(/ t (/ a (- y z)))
(if (<= a 1.45e+96)
t
(if (<= a 7.6e+132)
x
(if (<= a 6.2e+160)
t_1
(if (<= a 1.35e+164) (* a (/ (- x) z)) x))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / a);
double tmp;
if (a <= -2.55e+160) {
tmp = x;
} else if (a <= -59.0) {
tmp = t_1;
} else if (a <= 2.8e-242) {
tmp = t - (t / (z / y));
} else if (a <= 6.2e-55) {
tmp = x * ((y - a) / z);
} else if (a <= 1.5e+38) {
tmp = t / ((z - a) / z);
} else if (a <= 1.8e+91) {
tmp = t / (a / (y - z));
} else if (a <= 1.45e+96) {
tmp = t;
} else if (a <= 7.6e+132) {
tmp = x;
} else if (a <= 6.2e+160) {
tmp = t_1;
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = (y - z) * (t / a)
if (a <= (-2.55d+160)) then
tmp = x
else if (a <= (-59.0d0)) then
tmp = t_1
else if (a <= 2.8d-242) then
tmp = t - (t / (z / y))
else if (a <= 6.2d-55) then
tmp = x * ((y - a) / z)
else if (a <= 1.5d+38) then
tmp = t / ((z - a) / z)
else if (a <= 1.8d+91) then
tmp = t / (a / (y - z))
else if (a <= 1.45d+96) then
tmp = t
else if (a <= 7.6d+132) then
tmp = x
else if (a <= 6.2d+160) then
tmp = t_1
else if (a <= 1.35d+164) then
tmp = a * (-x / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / a);
double tmp;
if (a <= -2.55e+160) {
tmp = x;
} else if (a <= -59.0) {
tmp = t_1;
} else if (a <= 2.8e-242) {
tmp = t - (t / (z / y));
} else if (a <= 6.2e-55) {
tmp = x * ((y - a) / z);
} else if (a <= 1.5e+38) {
tmp = t / ((z - a) / z);
} else if (a <= 1.8e+91) {
tmp = t / (a / (y - z));
} else if (a <= 1.45e+96) {
tmp = t;
} else if (a <= 7.6e+132) {
tmp = x;
} else if (a <= 6.2e+160) {
tmp = t_1;
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (y - z) * (t / a) tmp = 0 if a <= -2.55e+160: tmp = x elif a <= -59.0: tmp = t_1 elif a <= 2.8e-242: tmp = t - (t / (z / y)) elif a <= 6.2e-55: tmp = x * ((y - a) / z) elif a <= 1.5e+38: tmp = t / ((z - a) / z) elif a <= 1.8e+91: tmp = t / (a / (y - z)) elif a <= 1.45e+96: tmp = t elif a <= 7.6e+132: tmp = x elif a <= 6.2e+160: tmp = t_1 elif a <= 1.35e+164: tmp = a * (-x / z) else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(y - z) * Float64(t / a)) tmp = 0.0 if (a <= -2.55e+160) tmp = x; elseif (a <= -59.0) tmp = t_1; elseif (a <= 2.8e-242) tmp = Float64(t - Float64(t / Float64(z / y))); elseif (a <= 6.2e-55) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 1.5e+38) tmp = Float64(t / Float64(Float64(z - a) / z)); elseif (a <= 1.8e+91) tmp = Float64(t / Float64(a / Float64(y - z))); elseif (a <= 1.45e+96) tmp = t; elseif (a <= 7.6e+132) tmp = x; elseif (a <= 6.2e+160) tmp = t_1; elseif (a <= 1.35e+164) tmp = Float64(a * Float64(Float64(-x) / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (y - z) * (t / a); tmp = 0.0; if (a <= -2.55e+160) tmp = x; elseif (a <= -59.0) tmp = t_1; elseif (a <= 2.8e-242) tmp = t - (t / (z / y)); elseif (a <= 6.2e-55) tmp = x * ((y - a) / z); elseif (a <= 1.5e+38) tmp = t / ((z - a) / z); elseif (a <= 1.8e+91) tmp = t / (a / (y - z)); elseif (a <= 1.45e+96) tmp = t; elseif (a <= 7.6e+132) tmp = x; elseif (a <= 6.2e+160) tmp = t_1; elseif (a <= 1.35e+164) tmp = a * (-x / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.55e+160], x, If[LessEqual[a, -59.0], t$95$1, If[LessEqual[a, 2.8e-242], N[(t - N[(t / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 6.2e-55], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.5e+38], N[(t / N[(N[(z - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.8e+91], N[(t / N[(a / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.45e+96], t, If[LessEqual[a, 7.6e+132], x, If[LessEqual[a, 6.2e+160], t$95$1, If[LessEqual[a, 1.35e+164], N[(a * N[((-x) / z), $MachinePrecision]), $MachinePrecision], x]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{if}\;a \leq -2.55 \cdot 10^{+160}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -59:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-242}:\\
\;\;\;\;t - \frac{t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 6.2 \cdot 10^{-55}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 1.5 \cdot 10^{+38}:\\
\;\;\;\;\frac{t}{\frac{z - a}{z}}\\
\mathbf{elif}\;a \leq 1.8 \cdot 10^{+91}:\\
\;\;\;\;\frac{t}{\frac{a}{y - z}}\\
\mathbf{elif}\;a \leq 1.45 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 7.6 \cdot 10^{+132}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 6.2 \cdot 10^{+160}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+164}:\\
\;\;\;\;a \cdot \frac{-x}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -2.5500000000000001e160 or 1.44999999999999989e96 < a < 7.60000000000000012e132 or 1.35000000000000003e164 < a Initial program 88.2%
Taylor expanded in a around inf 64.8%
if -2.5500000000000001e160 < a < -59 or 7.60000000000000012e132 < a < 6.1999999999999996e160Initial program 87.8%
Taylor expanded in x around 0 37.5%
associate-/l*52.1%
associate-/r/52.3%
Simplified52.3%
Taylor expanded in a around inf 41.3%
if -59 < a < 2.79999999999999983e-242Initial program 70.8%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub79.0%
mul-1-neg79.0%
unsub-neg79.0%
distribute-rgt-out--79.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 75.0%
Taylor expanded in t around inf 61.4%
associate-/l*65.3%
Simplified65.3%
if 2.79999999999999983e-242 < a < 6.19999999999999993e-55Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-/l*51.4%
associate-/r/45.4%
Simplified45.4%
Taylor expanded in x around 0 51.3%
*-lft-identity51.3%
times-frac51.3%
/-rgt-identity51.3%
Simplified51.3%
if 6.19999999999999993e-55 < a < 1.5000000000000001e38Initial program 75.7%
Taylor expanded in x around 0 47.2%
associate-/l*64.8%
associate-/r/58.7%
Simplified58.7%
Taylor expanded in y around 0 40.6%
associate-*r/40.6%
mul-1-neg40.6%
distribute-rgt-neg-out40.6%
associate-*l/52.1%
Simplified52.1%
associate-*l/40.6%
frac-2neg40.6%
add-sqr-sqrt26.6%
sqrt-unprod15.4%
sqr-neg15.4%
sqrt-unprod0.9%
add-sqr-sqrt2.3%
distribute-rgt-neg-out2.3%
add-sqr-sqrt1.5%
sqrt-unprod8.9%
sqr-neg8.9%
sqrt-unprod13.7%
add-sqr-sqrt40.6%
sub-neg40.6%
distribute-neg-in40.6%
add-sqr-sqrt26.6%
sqrt-unprod15.3%
sqr-neg15.3%
sqrt-unprod0.8%
add-sqr-sqrt2.3%
add-sqr-sqrt1.5%
sqrt-unprod9.5%
sqr-neg9.5%
Applied egg-rr40.6%
associate-/l*58.2%
+-commutative58.2%
unsub-neg58.2%
Simplified58.2%
if 1.5000000000000001e38 < a < 1.8e91Initial program 82.0%
Taylor expanded in x around 0 45.4%
associate-/l*45.9%
associate-/r/45.7%
Simplified45.7%
Taylor expanded in a around inf 41.7%
associate-/l*42.0%
Simplified42.0%
if 1.8e91 < a < 1.44999999999999989e96Initial program 100.0%
Taylor expanded in z around inf 100.0%
if 6.1999999999999996e160 < a < 1.35000000000000003e164Initial program 2.2%
Taylor expanded in z around inf 4.7%
associate--l+4.7%
distribute-lft-out--4.7%
div-sub4.7%
mul-1-neg4.7%
unsub-neg4.7%
distribute-rgt-out--4.7%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in t around 0 4.7%
associate-/l*100.0%
associate-/r/100.0%
Simplified100.0%
Taylor expanded in y around 0 4.7%
mul-1-neg4.7%
distribute-neg-frac4.7%
distribute-lft-neg-out4.7%
associate-*r/100.0%
*-commutative100.0%
Simplified100.0%
Final simplification57.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ y (/ a (- t x)))))
(if (<= a -4.6e+108)
x
(if (<= a -0.41)
t_1
(if (<= a 2.7e-242)
(- t (/ t (/ z y)))
(if (<= a 1.55e-49)
(* x (/ (- y a) z))
(if (<= a 1.55e+32)
(/ t (/ (- z a) z))
(if (<= a 3.3e+91)
t_1
(if (<= a 1.7e+96)
t
(if (<= a 2.8e+132)
x
(if (<= a 1.25e+164)
(* (- y z) (/ t a))
(if (<= a 1.35e+164) (* a (/ (- x) z)) x))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -4.6e+108) {
tmp = x;
} else if (a <= -0.41) {
tmp = t_1;
} else if (a <= 2.7e-242) {
tmp = t - (t / (z / y));
} else if (a <= 1.55e-49) {
tmp = x * ((y - a) / z);
} else if (a <= 1.55e+32) {
tmp = t / ((z - a) / z);
} else if (a <= 3.3e+91) {
tmp = t_1;
} else if (a <= 1.7e+96) {
tmp = t;
} else if (a <= 2.8e+132) {
tmp = x;
} else if (a <= 1.25e+164) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = y / (a / (t - x))
if (a <= (-4.6d+108)) then
tmp = x
else if (a <= (-0.41d0)) then
tmp = t_1
else if (a <= 2.7d-242) then
tmp = t - (t / (z / y))
else if (a <= 1.55d-49) then
tmp = x * ((y - a) / z)
else if (a <= 1.55d+32) then
tmp = t / ((z - a) / z)
else if (a <= 3.3d+91) then
tmp = t_1
else if (a <= 1.7d+96) then
tmp = t
else if (a <= 2.8d+132) then
tmp = x
else if (a <= 1.25d+164) then
tmp = (y - z) * (t / a)
else if (a <= 1.35d+164) then
tmp = a * (-x / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -4.6e+108) {
tmp = x;
} else if (a <= -0.41) {
tmp = t_1;
} else if (a <= 2.7e-242) {
tmp = t - (t / (z / y));
} else if (a <= 1.55e-49) {
tmp = x * ((y - a) / z);
} else if (a <= 1.55e+32) {
tmp = t / ((z - a) / z);
} else if (a <= 3.3e+91) {
tmp = t_1;
} else if (a <= 1.7e+96) {
tmp = t;
} else if (a <= 2.8e+132) {
tmp = x;
} else if (a <= 1.25e+164) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y / (a / (t - x)) tmp = 0 if a <= -4.6e+108: tmp = x elif a <= -0.41: tmp = t_1 elif a <= 2.7e-242: tmp = t - (t / (z / y)) elif a <= 1.55e-49: tmp = x * ((y - a) / z) elif a <= 1.55e+32: tmp = t / ((z - a) / z) elif a <= 3.3e+91: tmp = t_1 elif a <= 1.7e+96: tmp = t elif a <= 2.8e+132: tmp = x elif a <= 1.25e+164: tmp = (y - z) * (t / a) elif a <= 1.35e+164: tmp = a * (-x / z) else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(y / Float64(a / Float64(t - x))) tmp = 0.0 if (a <= -4.6e+108) tmp = x; elseif (a <= -0.41) tmp = t_1; elseif (a <= 2.7e-242) tmp = Float64(t - Float64(t / Float64(z / y))); elseif (a <= 1.55e-49) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 1.55e+32) tmp = Float64(t / Float64(Float64(z - a) / z)); elseif (a <= 3.3e+91) tmp = t_1; elseif (a <= 1.7e+96) tmp = t; elseif (a <= 2.8e+132) tmp = x; elseif (a <= 1.25e+164) tmp = Float64(Float64(y - z) * Float64(t / a)); elseif (a <= 1.35e+164) tmp = Float64(a * Float64(Float64(-x) / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y / (a / (t - x)); tmp = 0.0; if (a <= -4.6e+108) tmp = x; elseif (a <= -0.41) tmp = t_1; elseif (a <= 2.7e-242) tmp = t - (t / (z / y)); elseif (a <= 1.55e-49) tmp = x * ((y - a) / z); elseif (a <= 1.55e+32) tmp = t / ((z - a) / z); elseif (a <= 3.3e+91) tmp = t_1; elseif (a <= 1.7e+96) tmp = t; elseif (a <= 2.8e+132) tmp = x; elseif (a <= 1.25e+164) tmp = (y - z) * (t / a); elseif (a <= 1.35e+164) tmp = a * (-x / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.6e+108], x, If[LessEqual[a, -0.41], t$95$1, If[LessEqual[a, 2.7e-242], N[(t - N[(t / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.55e-49], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.55e+32], N[(t / N[(N[(z - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.3e+91], t$95$1, If[LessEqual[a, 1.7e+96], t, If[LessEqual[a, 2.8e+132], x, If[LessEqual[a, 1.25e+164], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+164], N[(a * N[((-x) / z), $MachinePrecision]), $MachinePrecision], x]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{\frac{a}{t - x}}\\
\mathbf{if}\;a \leq -4.6 \cdot 10^{+108}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -0.41:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-242}:\\
\;\;\;\;t - \frac{t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 1.55 \cdot 10^{-49}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 1.55 \cdot 10^{+32}:\\
\;\;\;\;\frac{t}{\frac{z - a}{z}}\\
\mathbf{elif}\;a \leq 3.3 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.7 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{+132}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{+164}:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+164}:\\
\;\;\;\;a \cdot \frac{-x}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -4.5999999999999998e108 or 1.7e96 < a < 2.7999999999999999e132 or 1.35000000000000003e164 < a Initial program 86.8%
Taylor expanded in a around inf 59.3%
if -4.5999999999999998e108 < a < -0.409999999999999976 or 1.54999999999999997e32 < a < 3.30000000000000017e91Initial program 87.5%
Taylor expanded in y around inf 57.0%
div-sub57.0%
associate-*r/53.3%
associate-/l*57.0%
Simplified57.0%
Taylor expanded in a around inf 49.3%
if -0.409999999999999976 < a < 2.7e-242Initial program 70.8%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub79.0%
mul-1-neg79.0%
unsub-neg79.0%
distribute-rgt-out--79.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 75.0%
Taylor expanded in t around inf 61.4%
associate-/l*65.3%
Simplified65.3%
if 2.7e-242 < a < 1.55e-49Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-/l*51.4%
associate-/r/45.4%
Simplified45.4%
Taylor expanded in x around 0 51.3%
*-lft-identity51.3%
times-frac51.3%
/-rgt-identity51.3%
Simplified51.3%
if 1.55e-49 < a < 1.54999999999999997e32Initial program 72.2%
Taylor expanded in x around 0 39.7%
associate-/l*59.8%
associate-/r/52.8%
Simplified52.8%
Taylor expanded in y around 0 39.0%
associate-*r/39.0%
mul-1-neg39.0%
distribute-rgt-neg-out39.0%
associate-*l/52.2%
Simplified52.2%
associate-*l/39.0%
frac-2neg39.0%
add-sqr-sqrt30.1%
sqrt-unprod17.4%
sqr-neg17.4%
sqrt-unprod0.9%
add-sqr-sqrt2.5%
distribute-rgt-neg-out2.5%
add-sqr-sqrt1.6%
sqrt-unprod2.9%
sqr-neg2.9%
sqrt-unprod8.5%
add-sqr-sqrt39.0%
sub-neg39.0%
distribute-neg-in39.0%
add-sqr-sqrt30.1%
sqrt-unprod17.1%
sqr-neg17.1%
sqrt-unprod0.9%
add-sqr-sqrt2.3%
add-sqr-sqrt1.5%
sqrt-unprod3.4%
sqr-neg3.4%
Applied egg-rr39.0%
associate-/l*59.1%
+-commutative59.1%
unsub-neg59.1%
Simplified59.1%
if 3.30000000000000017e91 < a < 1.7e96Initial program 100.0%
Taylor expanded in z around inf 100.0%
if 2.7999999999999999e132 < a < 1.24999999999999987e164Initial program 96.7%
Taylor expanded in x around 0 53.2%
associate-/l*83.6%
associate-/r/84.1%
Simplified84.1%
Taylor expanded in a around inf 68.5%
if 1.24999999999999987e164 < a < 1.35000000000000003e164Initial program 2.2%
Taylor expanded in z around inf 4.7%
associate--l+4.7%
distribute-lft-out--4.7%
div-sub4.7%
mul-1-neg4.7%
unsub-neg4.7%
distribute-rgt-out--4.7%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in t around 0 4.7%
associate-/l*100.0%
associate-/r/100.0%
Simplified100.0%
Taylor expanded in y around 0 4.7%
mul-1-neg4.7%
distribute-neg-frac4.7%
distribute-lft-neg-out4.7%
associate-*r/100.0%
*-commutative100.0%
Simplified100.0%
Final simplification58.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ y (/ a (- t x)))))
(if (<= a -9.5e+109)
x
(if (<= a -0.72)
t_1
(if (<= a 2.7e-242)
(- t (/ t (/ z y)))
(if (<= a 1.2e-54)
(/ (* x (- y a)) z)
(if (<= a 1.8e+29)
(/ t (/ (- z a) z))
(if (<= a 3.2e+91)
t_1
(if (<= a 1.7e+96)
t
(if (<= a 6.2e+132)
x
(if (<= a 7.2e+163)
(* (- y z) (/ t a))
(if (<= a 1.35e+164) (* a (/ (- x) z)) x))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -9.5e+109) {
tmp = x;
} else if (a <= -0.72) {
tmp = t_1;
} else if (a <= 2.7e-242) {
tmp = t - (t / (z / y));
} else if (a <= 1.2e-54) {
tmp = (x * (y - a)) / z;
} else if (a <= 1.8e+29) {
tmp = t / ((z - a) / z);
} else if (a <= 3.2e+91) {
tmp = t_1;
} else if (a <= 1.7e+96) {
tmp = t;
} else if (a <= 6.2e+132) {
tmp = x;
} else if (a <= 7.2e+163) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = y / (a / (t - x))
if (a <= (-9.5d+109)) then
tmp = x
else if (a <= (-0.72d0)) then
tmp = t_1
else if (a <= 2.7d-242) then
tmp = t - (t / (z / y))
else if (a <= 1.2d-54) then
tmp = (x * (y - a)) / z
else if (a <= 1.8d+29) then
tmp = t / ((z - a) / z)
else if (a <= 3.2d+91) then
tmp = t_1
else if (a <= 1.7d+96) then
tmp = t
else if (a <= 6.2d+132) then
tmp = x
else if (a <= 7.2d+163) then
tmp = (y - z) * (t / a)
else if (a <= 1.35d+164) then
tmp = a * (-x / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -9.5e+109) {
tmp = x;
} else if (a <= -0.72) {
tmp = t_1;
} else if (a <= 2.7e-242) {
tmp = t - (t / (z / y));
} else if (a <= 1.2e-54) {
tmp = (x * (y - a)) / z;
} else if (a <= 1.8e+29) {
tmp = t / ((z - a) / z);
} else if (a <= 3.2e+91) {
tmp = t_1;
} else if (a <= 1.7e+96) {
tmp = t;
} else if (a <= 6.2e+132) {
tmp = x;
} else if (a <= 7.2e+163) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y / (a / (t - x)) tmp = 0 if a <= -9.5e+109: tmp = x elif a <= -0.72: tmp = t_1 elif a <= 2.7e-242: tmp = t - (t / (z / y)) elif a <= 1.2e-54: tmp = (x * (y - a)) / z elif a <= 1.8e+29: tmp = t / ((z - a) / z) elif a <= 3.2e+91: tmp = t_1 elif a <= 1.7e+96: tmp = t elif a <= 6.2e+132: tmp = x elif a <= 7.2e+163: tmp = (y - z) * (t / a) elif a <= 1.35e+164: tmp = a * (-x / z) else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(y / Float64(a / Float64(t - x))) tmp = 0.0 if (a <= -9.5e+109) tmp = x; elseif (a <= -0.72) tmp = t_1; elseif (a <= 2.7e-242) tmp = Float64(t - Float64(t / Float64(z / y))); elseif (a <= 1.2e-54) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (a <= 1.8e+29) tmp = Float64(t / Float64(Float64(z - a) / z)); elseif (a <= 3.2e+91) tmp = t_1; elseif (a <= 1.7e+96) tmp = t; elseif (a <= 6.2e+132) tmp = x; elseif (a <= 7.2e+163) tmp = Float64(Float64(y - z) * Float64(t / a)); elseif (a <= 1.35e+164) tmp = Float64(a * Float64(Float64(-x) / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y / (a / (t - x)); tmp = 0.0; if (a <= -9.5e+109) tmp = x; elseif (a <= -0.72) tmp = t_1; elseif (a <= 2.7e-242) tmp = t - (t / (z / y)); elseif (a <= 1.2e-54) tmp = (x * (y - a)) / z; elseif (a <= 1.8e+29) tmp = t / ((z - a) / z); elseif (a <= 3.2e+91) tmp = t_1; elseif (a <= 1.7e+96) tmp = t; elseif (a <= 6.2e+132) tmp = x; elseif (a <= 7.2e+163) tmp = (y - z) * (t / a); elseif (a <= 1.35e+164) tmp = a * (-x / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -9.5e+109], x, If[LessEqual[a, -0.72], t$95$1, If[LessEqual[a, 2.7e-242], N[(t - N[(t / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.2e-54], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[a, 1.8e+29], N[(t / N[(N[(z - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.2e+91], t$95$1, If[LessEqual[a, 1.7e+96], t, If[LessEqual[a, 6.2e+132], x, If[LessEqual[a, 7.2e+163], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+164], N[(a * N[((-x) / z), $MachinePrecision]), $MachinePrecision], x]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{\frac{a}{t - x}}\\
\mathbf{if}\;a \leq -9.5 \cdot 10^{+109}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -0.72:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-242}:\\
\;\;\;\;t - \frac{t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-54}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;a \leq 1.8 \cdot 10^{+29}:\\
\;\;\;\;\frac{t}{\frac{z - a}{z}}\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.7 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 6.2 \cdot 10^{+132}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 7.2 \cdot 10^{+163}:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+164}:\\
\;\;\;\;a \cdot \frac{-x}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -9.49999999999999972e109 or 1.7e96 < a < 6.1999999999999995e132 or 1.35000000000000003e164 < a Initial program 86.8%
Taylor expanded in a around inf 59.3%
if -9.49999999999999972e109 < a < -0.71999999999999997 or 1.79999999999999988e29 < a < 3.19999999999999989e91Initial program 87.5%
Taylor expanded in y around inf 57.0%
div-sub57.0%
associate-*r/53.3%
associate-/l*57.0%
Simplified57.0%
Taylor expanded in a around inf 49.3%
if -0.71999999999999997 < a < 2.7e-242Initial program 70.8%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub79.0%
mul-1-neg79.0%
unsub-neg79.0%
distribute-rgt-out--79.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 75.0%
Taylor expanded in t around inf 61.4%
associate-/l*65.3%
Simplified65.3%
if 2.7e-242 < a < 1.20000000000000007e-54Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
if 1.20000000000000007e-54 < a < 1.79999999999999988e29Initial program 72.2%
Taylor expanded in x around 0 39.7%
associate-/l*59.8%
associate-/r/52.8%
Simplified52.8%
Taylor expanded in y around 0 39.0%
associate-*r/39.0%
mul-1-neg39.0%
distribute-rgt-neg-out39.0%
associate-*l/52.2%
Simplified52.2%
associate-*l/39.0%
frac-2neg39.0%
add-sqr-sqrt30.1%
sqrt-unprod17.4%
sqr-neg17.4%
sqrt-unprod0.9%
add-sqr-sqrt2.5%
distribute-rgt-neg-out2.5%
add-sqr-sqrt1.6%
sqrt-unprod2.9%
sqr-neg2.9%
sqrt-unprod8.5%
add-sqr-sqrt39.0%
sub-neg39.0%
distribute-neg-in39.0%
add-sqr-sqrt30.1%
sqrt-unprod17.1%
sqr-neg17.1%
sqrt-unprod0.9%
add-sqr-sqrt2.3%
add-sqr-sqrt1.5%
sqrt-unprod3.4%
sqr-neg3.4%
Applied egg-rr39.0%
associate-/l*59.1%
+-commutative59.1%
unsub-neg59.1%
Simplified59.1%
if 3.19999999999999989e91 < a < 1.7e96Initial program 100.0%
Taylor expanded in z around inf 100.0%
if 6.1999999999999995e132 < a < 7.19999999999999955e163Initial program 96.7%
Taylor expanded in x around 0 53.2%
associate-/l*83.6%
associate-/r/84.1%
Simplified84.1%
Taylor expanded in a around inf 68.5%
if 7.19999999999999955e163 < a < 1.35000000000000003e164Initial program 2.2%
Taylor expanded in z around inf 4.7%
associate--l+4.7%
distribute-lft-out--4.7%
div-sub4.7%
mul-1-neg4.7%
unsub-neg4.7%
distribute-rgt-out--4.7%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in t around 0 4.7%
associate-/l*100.0%
associate-/r/100.0%
Simplified100.0%
Taylor expanded in y around 0 4.7%
mul-1-neg4.7%
distribute-neg-frac4.7%
distribute-lft-neg-out4.7%
associate-*r/100.0%
*-commutative100.0%
Simplified100.0%
Final simplification58.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ y (/ a (- t x)))))
(if (<= a -1.05e+106)
x
(if (<= a -1.65)
t_1
(if (<= a 1.2e-242)
(- t (/ t (/ z y)))
(if (<= a 3.8e-48)
(/ (- x) (/ z (- a y)))
(if (<= a 1.2e+29)
(/ t (/ (- z a) z))
(if (<= a 1.4e+91)
t_1
(if (<= a 1.12e+96)
t
(if (<= a 4e+131)
x
(if (<= a 1.3e+164)
(* (- y z) (/ t a))
(if (<= a 1.35e+164) (* a (/ (- x) z)) x))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -1.05e+106) {
tmp = x;
} else if (a <= -1.65) {
tmp = t_1;
} else if (a <= 1.2e-242) {
tmp = t - (t / (z / y));
} else if (a <= 3.8e-48) {
tmp = -x / (z / (a - y));
} else if (a <= 1.2e+29) {
tmp = t / ((z - a) / z);
} else if (a <= 1.4e+91) {
tmp = t_1;
} else if (a <= 1.12e+96) {
tmp = t;
} else if (a <= 4e+131) {
tmp = x;
} else if (a <= 1.3e+164) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = y / (a / (t - x))
if (a <= (-1.05d+106)) then
tmp = x
else if (a <= (-1.65d0)) then
tmp = t_1
else if (a <= 1.2d-242) then
tmp = t - (t / (z / y))
else if (a <= 3.8d-48) then
tmp = -x / (z / (a - y))
else if (a <= 1.2d+29) then
tmp = t / ((z - a) / z)
else if (a <= 1.4d+91) then
tmp = t_1
else if (a <= 1.12d+96) then
tmp = t
else if (a <= 4d+131) then
tmp = x
else if (a <= 1.3d+164) then
tmp = (y - z) * (t / a)
else if (a <= 1.35d+164) then
tmp = a * (-x / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -1.05e+106) {
tmp = x;
} else if (a <= -1.65) {
tmp = t_1;
} else if (a <= 1.2e-242) {
tmp = t - (t / (z / y));
} else if (a <= 3.8e-48) {
tmp = -x / (z / (a - y));
} else if (a <= 1.2e+29) {
tmp = t / ((z - a) / z);
} else if (a <= 1.4e+91) {
tmp = t_1;
} else if (a <= 1.12e+96) {
tmp = t;
} else if (a <= 4e+131) {
tmp = x;
} else if (a <= 1.3e+164) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = a * (-x / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y / (a / (t - x)) tmp = 0 if a <= -1.05e+106: tmp = x elif a <= -1.65: tmp = t_1 elif a <= 1.2e-242: tmp = t - (t / (z / y)) elif a <= 3.8e-48: tmp = -x / (z / (a - y)) elif a <= 1.2e+29: tmp = t / ((z - a) / z) elif a <= 1.4e+91: tmp = t_1 elif a <= 1.12e+96: tmp = t elif a <= 4e+131: tmp = x elif a <= 1.3e+164: tmp = (y - z) * (t / a) elif a <= 1.35e+164: tmp = a * (-x / z) else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(y / Float64(a / Float64(t - x))) tmp = 0.0 if (a <= -1.05e+106) tmp = x; elseif (a <= -1.65) tmp = t_1; elseif (a <= 1.2e-242) tmp = Float64(t - Float64(t / Float64(z / y))); elseif (a <= 3.8e-48) tmp = Float64(Float64(-x) / Float64(z / Float64(a - y))); elseif (a <= 1.2e+29) tmp = Float64(t / Float64(Float64(z - a) / z)); elseif (a <= 1.4e+91) tmp = t_1; elseif (a <= 1.12e+96) tmp = t; elseif (a <= 4e+131) tmp = x; elseif (a <= 1.3e+164) tmp = Float64(Float64(y - z) * Float64(t / a)); elseif (a <= 1.35e+164) tmp = Float64(a * Float64(Float64(-x) / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y / (a / (t - x)); tmp = 0.0; if (a <= -1.05e+106) tmp = x; elseif (a <= -1.65) tmp = t_1; elseif (a <= 1.2e-242) tmp = t - (t / (z / y)); elseif (a <= 3.8e-48) tmp = -x / (z / (a - y)); elseif (a <= 1.2e+29) tmp = t / ((z - a) / z); elseif (a <= 1.4e+91) tmp = t_1; elseif (a <= 1.12e+96) tmp = t; elseif (a <= 4e+131) tmp = x; elseif (a <= 1.3e+164) tmp = (y - z) * (t / a); elseif (a <= 1.35e+164) tmp = a * (-x / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.05e+106], x, If[LessEqual[a, -1.65], t$95$1, If[LessEqual[a, 1.2e-242], N[(t - N[(t / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.8e-48], N[((-x) / N[(z / N[(a - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.2e+29], N[(t / N[(N[(z - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.4e+91], t$95$1, If[LessEqual[a, 1.12e+96], t, If[LessEqual[a, 4e+131], x, If[LessEqual[a, 1.3e+164], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+164], N[(a * N[((-x) / z), $MachinePrecision]), $MachinePrecision], x]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{\frac{a}{t - x}}\\
\mathbf{if}\;a \leq -1.05 \cdot 10^{+106}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.65:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-242}:\\
\;\;\;\;t - \frac{t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 3.8 \cdot 10^{-48}:\\
\;\;\;\;\frac{-x}{\frac{z}{a - y}}\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{+29}:\\
\;\;\;\;\frac{t}{\frac{z - a}{z}}\\
\mathbf{elif}\;a \leq 1.4 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 4 \cdot 10^{+131}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.3 \cdot 10^{+164}:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+164}:\\
\;\;\;\;a \cdot \frac{-x}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.05000000000000002e106 or 1.1199999999999999e96 < a < 3.9999999999999996e131 or 1.35000000000000003e164 < a Initial program 86.8%
Taylor expanded in a around inf 59.3%
if -1.05000000000000002e106 < a < -1.6499999999999999 or 1.2e29 < a < 1.3999999999999999e91Initial program 87.5%
Taylor expanded in y around inf 57.0%
div-sub57.0%
associate-*r/53.3%
associate-/l*57.0%
Simplified57.0%
Taylor expanded in a around inf 49.3%
if -1.6499999999999999 < a < 1.2e-242Initial program 70.8%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub79.0%
mul-1-neg79.0%
unsub-neg79.0%
distribute-rgt-out--79.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 75.0%
Taylor expanded in t around inf 61.4%
associate-/l*65.3%
Simplified65.3%
if 1.2e-242 < a < 3.80000000000000002e-48Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in z around 0 54.8%
mul-1-neg54.8%
*-commutative54.8%
associate-*l/57.6%
distribute-lft-neg-in57.6%
distribute-neg-frac57.6%
Simplified57.6%
Taylor expanded in t around 0 51.3%
mul-1-neg51.3%
associate-/l*51.4%
Simplified51.4%
if 3.80000000000000002e-48 < a < 1.2e29Initial program 72.2%
Taylor expanded in x around 0 39.7%
associate-/l*59.8%
associate-/r/52.8%
Simplified52.8%
Taylor expanded in y around 0 39.0%
associate-*r/39.0%
mul-1-neg39.0%
distribute-rgt-neg-out39.0%
associate-*l/52.2%
Simplified52.2%
associate-*l/39.0%
frac-2neg39.0%
add-sqr-sqrt30.1%
sqrt-unprod17.4%
sqr-neg17.4%
sqrt-unprod0.9%
add-sqr-sqrt2.5%
distribute-rgt-neg-out2.5%
add-sqr-sqrt1.6%
sqrt-unprod2.9%
sqr-neg2.9%
sqrt-unprod8.5%
add-sqr-sqrt39.0%
sub-neg39.0%
distribute-neg-in39.0%
add-sqr-sqrt30.1%
sqrt-unprod17.1%
sqr-neg17.1%
sqrt-unprod0.9%
add-sqr-sqrt2.3%
add-sqr-sqrt1.5%
sqrt-unprod3.4%
sqr-neg3.4%
Applied egg-rr39.0%
associate-/l*59.1%
+-commutative59.1%
unsub-neg59.1%
Simplified59.1%
if 1.3999999999999999e91 < a < 1.1199999999999999e96Initial program 100.0%
Taylor expanded in z around inf 100.0%
if 3.9999999999999996e131 < a < 1.3e164Initial program 96.7%
Taylor expanded in x around 0 53.2%
associate-/l*83.6%
associate-/r/84.1%
Simplified84.1%
Taylor expanded in a around inf 68.5%
if 1.3e164 < a < 1.35000000000000003e164Initial program 2.2%
Taylor expanded in z around inf 4.7%
associate--l+4.7%
distribute-lft-out--4.7%
div-sub4.7%
mul-1-neg4.7%
unsub-neg4.7%
distribute-rgt-out--4.7%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in t around 0 4.7%
associate-/l*100.0%
associate-/r/100.0%
Simplified100.0%
Taylor expanded in y around 0 4.7%
mul-1-neg4.7%
distribute-neg-frac4.7%
distribute-lft-neg-out4.7%
associate-*r/100.0%
*-commutative100.0%
Simplified100.0%
Final simplification58.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (or (<= t_1 -1e-235) (not (<= t_1 5e-210)))
t_1
(+ t (/ (- x t) (/ z (- y a)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if ((t_1 <= -1e-235) || !(t_1 <= 5e-210)) {
tmp = t_1;
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = x + ((y - z) * ((t - x) / (a - z)))
if ((t_1 <= (-1d-235)) .or. (.not. (t_1 <= 5d-210))) then
tmp = t_1
else
tmp = t + ((x - t) / (z / (y - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if ((t_1 <= -1e-235) || !(t_1 <= 5e-210)) {
tmp = t_1;
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y - z) * ((t - x) / (a - z))) tmp = 0 if (t_1 <= -1e-235) or not (t_1 <= 5e-210): tmp = t_1 else: tmp = t + ((x - t) / (z / (y - a))) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) tmp = 0.0 if ((t_1 <= -1e-235) || !(t_1 <= 5e-210)) tmp = t_1; else tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y - z) * ((t - x) / (a - z))); tmp = 0.0; if ((t_1 <= -1e-235) || ~((t_1 <= 5e-210))) tmp = t_1; else tmp = t + ((x - t) / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -1e-235], N[Not[LessEqual[t$95$1, 5e-210]], $MachinePrecision]], t$95$1, N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{-235} \lor \neg \left(t\_1 \leq 5 \cdot 10^{-210}\right):\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -9.9999999999999996e-236 or 5.0000000000000002e-210 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 90.8%
if -9.9999999999999996e-236 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 5.0000000000000002e-210Initial program 6.4%
Taylor expanded in z around inf 73.6%
associate--l+73.6%
distribute-lft-out--73.6%
div-sub73.6%
mul-1-neg73.6%
unsub-neg73.6%
distribute-rgt-out--73.6%
associate-/l*91.9%
Simplified91.9%
Final simplification91.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- t x) (/ y a)))) (t_2 (* t (/ (- y z) (- a z)))))
(if (<= x -16000000000.0)
t_1
(if (<= x -2.4e-36)
(+ t (/ (* x y) z))
(if (<= x -2.9e-133)
t_1
(if (<= x 6e-23)
t_2
(if (<= x 1.06e+114)
t_1
(if (<= x 3.15e+156) t_2 (* (- t x) (/ (- a y) z))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) * (y / a));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (x <= -16000000000.0) {
tmp = t_1;
} else if (x <= -2.4e-36) {
tmp = t + ((x * y) / z);
} else if (x <= -2.9e-133) {
tmp = t_1;
} else if (x <= 6e-23) {
tmp = t_2;
} else if (x <= 1.06e+114) {
tmp = t_1;
} else if (x <= 3.15e+156) {
tmp = t_2;
} else {
tmp = (t - x) * ((a - y) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + ((t - x) * (y / a))
t_2 = t * ((y - z) / (a - z))
if (x <= (-16000000000.0d0)) then
tmp = t_1
else if (x <= (-2.4d-36)) then
tmp = t + ((x * y) / z)
else if (x <= (-2.9d-133)) then
tmp = t_1
else if (x <= 6d-23) then
tmp = t_2
else if (x <= 1.06d+114) then
tmp = t_1
else if (x <= 3.15d+156) then
tmp = t_2
else
tmp = (t - x) * ((a - y) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) * (y / a));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (x <= -16000000000.0) {
tmp = t_1;
} else if (x <= -2.4e-36) {
tmp = t + ((x * y) / z);
} else if (x <= -2.9e-133) {
tmp = t_1;
} else if (x <= 6e-23) {
tmp = t_2;
} else if (x <= 1.06e+114) {
tmp = t_1;
} else if (x <= 3.15e+156) {
tmp = t_2;
} else {
tmp = (t - x) * ((a - y) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((t - x) * (y / a)) t_2 = t * ((y - z) / (a - z)) tmp = 0 if x <= -16000000000.0: tmp = t_1 elif x <= -2.4e-36: tmp = t + ((x * y) / z) elif x <= -2.9e-133: tmp = t_1 elif x <= 6e-23: tmp = t_2 elif x <= 1.06e+114: tmp = t_1 elif x <= 3.15e+156: tmp = t_2 else: tmp = (t - x) * ((a - y) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(t - x) * Float64(y / a))) t_2 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (x <= -16000000000.0) tmp = t_1; elseif (x <= -2.4e-36) tmp = Float64(t + Float64(Float64(x * y) / z)); elseif (x <= -2.9e-133) tmp = t_1; elseif (x <= 6e-23) tmp = t_2; elseif (x <= 1.06e+114) tmp = t_1; elseif (x <= 3.15e+156) tmp = t_2; else tmp = Float64(Float64(t - x) * Float64(Float64(a - y) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((t - x) * (y / a)); t_2 = t * ((y - z) / (a - z)); tmp = 0.0; if (x <= -16000000000.0) tmp = t_1; elseif (x <= -2.4e-36) tmp = t + ((x * y) / z); elseif (x <= -2.9e-133) tmp = t_1; elseif (x <= 6e-23) tmp = t_2; elseif (x <= 1.06e+114) tmp = t_1; elseif (x <= 3.15e+156) tmp = t_2; else tmp = (t - x) * ((a - y) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -16000000000.0], t$95$1, If[LessEqual[x, -2.4e-36], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.9e-133], t$95$1, If[LessEqual[x, 6e-23], t$95$2, If[LessEqual[x, 1.06e+114], t$95$1, If[LessEqual[x, 3.15e+156], t$95$2, N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(t - x\right) \cdot \frac{y}{a}\\
t_2 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;x \leq -16000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -2.4 \cdot 10^{-36}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{elif}\;x \leq -2.9 \cdot 10^{-133}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 6 \cdot 10^{-23}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 1.06 \cdot 10^{+114}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 3.15 \cdot 10^{+156}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{a - y}{z}\\
\end{array}
\end{array}
if x < -1.6e10 or -2.4e-36 < x < -2.8999999999999998e-133 or 6.00000000000000006e-23 < x < 1.05999999999999993e114Initial program 79.7%
Taylor expanded in z around 0 60.8%
associate-/l*63.8%
associate-/r/67.0%
Simplified67.0%
if -1.6e10 < x < -2.4e-36Initial program 80.8%
Taylor expanded in z around inf 71.1%
associate--l+71.1%
distribute-lft-out--71.1%
div-sub71.1%
mul-1-neg71.1%
unsub-neg71.1%
distribute-rgt-out--71.1%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 72.0%
Taylor expanded in t around 0 81.4%
mul-1-neg81.4%
distribute-lft-neg-out81.4%
*-commutative81.4%
Simplified81.4%
if -2.8999999999999998e-133 < x < 6.00000000000000006e-23 or 1.05999999999999993e114 < x < 3.14999999999999991e156Initial program 83.9%
associate-*r/75.2%
clear-num75.2%
Applied egg-rr75.2%
Taylor expanded in x around 0 62.8%
*-commutative62.8%
associate-/l*69.2%
associate-/r/77.8%
*-commutative77.8%
Simplified77.8%
if 3.14999999999999991e156 < x Initial program 63.7%
Taylor expanded in z around inf 38.6%
associate--l+38.6%
distribute-lft-out--38.6%
div-sub41.3%
mul-1-neg41.3%
unsub-neg41.3%
distribute-rgt-out--41.3%
associate-/l*65.6%
Simplified65.6%
Taylor expanded in z around 0 31.6%
mul-1-neg31.6%
*-commutative31.6%
associate-*l/52.4%
distribute-lft-neg-in52.4%
distribute-neg-frac52.4%
Simplified52.4%
Taylor expanded in y around 0 52.4%
+-commutative52.4%
mul-1-neg52.4%
sub-neg52.4%
div-sub52.4%
Simplified52.4%
Final simplification69.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (+ x (* (- t x) (/ y a)))))
(if (<= x -19000000.0)
t_2
(if (<= x -1.6e-34)
(+ t (/ (* x y) z))
(if (<= x -9.2e-143)
(+ x (/ y (/ a (- t x))))
(if (<= x 1.7e-12)
t_1
(if (<= x 1.3e+114)
t_2
(if (<= x 3.15e+156) t_1 (* (- t x) (/ (- a y) z))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + ((t - x) * (y / a));
double tmp;
if (x <= -19000000.0) {
tmp = t_2;
} else if (x <= -1.6e-34) {
tmp = t + ((x * y) / z);
} else if (x <= -9.2e-143) {
tmp = x + (y / (a / (t - x)));
} else if (x <= 1.7e-12) {
tmp = t_1;
} else if (x <= 1.3e+114) {
tmp = t_2;
} else if (x <= 3.15e+156) {
tmp = t_1;
} else {
tmp = (t - x) * ((a - y) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = x + ((t - x) * (y / a))
if (x <= (-19000000.0d0)) then
tmp = t_2
else if (x <= (-1.6d-34)) then
tmp = t + ((x * y) / z)
else if (x <= (-9.2d-143)) then
tmp = x + (y / (a / (t - x)))
else if (x <= 1.7d-12) then
tmp = t_1
else if (x <= 1.3d+114) then
tmp = t_2
else if (x <= 3.15d+156) then
tmp = t_1
else
tmp = (t - x) * ((a - y) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + ((t - x) * (y / a));
double tmp;
if (x <= -19000000.0) {
tmp = t_2;
} else if (x <= -1.6e-34) {
tmp = t + ((x * y) / z);
} else if (x <= -9.2e-143) {
tmp = x + (y / (a / (t - x)));
} else if (x <= 1.7e-12) {
tmp = t_1;
} else if (x <= 1.3e+114) {
tmp = t_2;
} else if (x <= 3.15e+156) {
tmp = t_1;
} else {
tmp = (t - x) * ((a - y) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + ((t - x) * (y / a)) tmp = 0 if x <= -19000000.0: tmp = t_2 elif x <= -1.6e-34: tmp = t + ((x * y) / z) elif x <= -9.2e-143: tmp = x + (y / (a / (t - x))) elif x <= 1.7e-12: tmp = t_1 elif x <= 1.3e+114: tmp = t_2 elif x <= 3.15e+156: tmp = t_1 else: tmp = (t - x) * ((a - y) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(x + Float64(Float64(t - x) * Float64(y / a))) tmp = 0.0 if (x <= -19000000.0) tmp = t_2; elseif (x <= -1.6e-34) tmp = Float64(t + Float64(Float64(x * y) / z)); elseif (x <= -9.2e-143) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); elseif (x <= 1.7e-12) tmp = t_1; elseif (x <= 1.3e+114) tmp = t_2; elseif (x <= 3.15e+156) tmp = t_1; else tmp = Float64(Float64(t - x) * Float64(Float64(a - y) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = x + ((t - x) * (y / a)); tmp = 0.0; if (x <= -19000000.0) tmp = t_2; elseif (x <= -1.6e-34) tmp = t + ((x * y) / z); elseif (x <= -9.2e-143) tmp = x + (y / (a / (t - x))); elseif (x <= 1.7e-12) tmp = t_1; elseif (x <= 1.3e+114) tmp = t_2; elseif (x <= 3.15e+156) tmp = t_1; else tmp = (t - x) * ((a - y) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -19000000.0], t$95$2, If[LessEqual[x, -1.6e-34], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -9.2e-143], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.7e-12], t$95$1, If[LessEqual[x, 1.3e+114], t$95$2, If[LessEqual[x, 3.15e+156], t$95$1, N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{if}\;x \leq -19000000:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.6 \cdot 10^{-34}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{elif}\;x \leq -9.2 \cdot 10^{-143}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{-12}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{+114}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 3.15 \cdot 10^{+156}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{a - y}{z}\\
\end{array}
\end{array}
if x < -1.9e7 or 1.7e-12 < x < 1.3e114Initial program 77.0%
Taylor expanded in z around 0 57.1%
associate-/l*60.6%
associate-/r/64.5%
Simplified64.5%
if -1.9e7 < x < -1.60000000000000001e-34Initial program 80.8%
Taylor expanded in z around inf 71.1%
associate--l+71.1%
distribute-lft-out--71.1%
div-sub71.1%
mul-1-neg71.1%
unsub-neg71.1%
distribute-rgt-out--71.1%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 72.0%
Taylor expanded in t around 0 81.4%
mul-1-neg81.4%
distribute-lft-neg-out81.4%
*-commutative81.4%
Simplified81.4%
if -1.60000000000000001e-34 < x < -9.20000000000000045e-143Initial program 94.3%
Taylor expanded in z around 0 76.1%
associate-/l*81.5%
Simplified81.5%
if -9.20000000000000045e-143 < x < 1.7e-12 or 1.3e114 < x < 3.14999999999999991e156Initial program 83.8%
associate-*r/75.9%
clear-num75.9%
Applied egg-rr75.9%
Taylor expanded in x around 0 63.4%
*-commutative63.4%
associate-/l*68.9%
associate-/r/77.6%
*-commutative77.6%
Simplified77.6%
if 3.14999999999999991e156 < x Initial program 63.7%
Taylor expanded in z around inf 38.6%
associate--l+38.6%
distribute-lft-out--38.6%
div-sub41.3%
mul-1-neg41.3%
unsub-neg41.3%
distribute-rgt-out--41.3%
associate-/l*65.6%
Simplified65.6%
Taylor expanded in z around 0 31.6%
mul-1-neg31.6%
*-commutative31.6%
associate-*l/52.4%
distribute-lft-neg-in52.4%
distribute-neg-frac52.4%
Simplified52.4%
Taylor expanded in y around 0 52.4%
+-commutative52.4%
mul-1-neg52.4%
sub-neg52.4%
div-sub52.4%
Simplified52.4%
Final simplification69.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- y z) (/ t a))))
(if (<= a -2.8e+155)
x
(if (<= a -40.0)
t_1
(if (<= a 2.8e-242)
(* t (- 1.0 (/ y z)))
(if (<= a 6e-53)
(* x (/ (- y a) z))
(if (<= a 1.2e+38)
t
(if (<= a 6e+90) t_1 (if (<= a 1.25e+96) t x)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / a);
double tmp;
if (a <= -2.8e+155) {
tmp = x;
} else if (a <= -40.0) {
tmp = t_1;
} else if (a <= 2.8e-242) {
tmp = t * (1.0 - (y / z));
} else if (a <= 6e-53) {
tmp = x * ((y - a) / z);
} else if (a <= 1.2e+38) {
tmp = t;
} else if (a <= 6e+90) {
tmp = t_1;
} else if (a <= 1.25e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = (y - z) * (t / a)
if (a <= (-2.8d+155)) then
tmp = x
else if (a <= (-40.0d0)) then
tmp = t_1
else if (a <= 2.8d-242) then
tmp = t * (1.0d0 - (y / z))
else if (a <= 6d-53) then
tmp = x * ((y - a) / z)
else if (a <= 1.2d+38) then
tmp = t
else if (a <= 6d+90) then
tmp = t_1
else if (a <= 1.25d+96) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / a);
double tmp;
if (a <= -2.8e+155) {
tmp = x;
} else if (a <= -40.0) {
tmp = t_1;
} else if (a <= 2.8e-242) {
tmp = t * (1.0 - (y / z));
} else if (a <= 6e-53) {
tmp = x * ((y - a) / z);
} else if (a <= 1.2e+38) {
tmp = t;
} else if (a <= 6e+90) {
tmp = t_1;
} else if (a <= 1.25e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (y - z) * (t / a) tmp = 0 if a <= -2.8e+155: tmp = x elif a <= -40.0: tmp = t_1 elif a <= 2.8e-242: tmp = t * (1.0 - (y / z)) elif a <= 6e-53: tmp = x * ((y - a) / z) elif a <= 1.2e+38: tmp = t elif a <= 6e+90: tmp = t_1 elif a <= 1.25e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(y - z) * Float64(t / a)) tmp = 0.0 if (a <= -2.8e+155) tmp = x; elseif (a <= -40.0) tmp = t_1; elseif (a <= 2.8e-242) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (a <= 6e-53) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 1.2e+38) tmp = t; elseif (a <= 6e+90) tmp = t_1; elseif (a <= 1.25e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (y - z) * (t / a); tmp = 0.0; if (a <= -2.8e+155) tmp = x; elseif (a <= -40.0) tmp = t_1; elseif (a <= 2.8e-242) tmp = t * (1.0 - (y / z)); elseif (a <= 6e-53) tmp = x * ((y - a) / z); elseif (a <= 1.2e+38) tmp = t; elseif (a <= 6e+90) tmp = t_1; elseif (a <= 1.25e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.8e+155], x, If[LessEqual[a, -40.0], t$95$1, If[LessEqual[a, 2.8e-242], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 6e-53], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.2e+38], t, If[LessEqual[a, 6e+90], t$95$1, If[LessEqual[a, 1.25e+96], t, x]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{if}\;a \leq -2.8 \cdot 10^{+155}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -40:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-242}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 6 \cdot 10^{-53}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 6 \cdot 10^{+90}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -2.80000000000000016e155 or 1.2500000000000001e96 < a Initial program 87.7%
Taylor expanded in a around inf 58.9%
if -2.80000000000000016e155 < a < -40 or 1.20000000000000009e38 < a < 5.99999999999999957e90Initial program 85.1%
Taylor expanded in x around 0 38.5%
associate-/l*48.1%
associate-/r/48.2%
Simplified48.2%
Taylor expanded in a around inf 39.3%
if -40 < a < 2.79999999999999983e-242Initial program 70.8%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub79.0%
mul-1-neg79.0%
unsub-neg79.0%
distribute-rgt-out--79.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 75.0%
Taylor expanded in t around inf 65.3%
if 2.79999999999999983e-242 < a < 6.0000000000000004e-53Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-/l*51.4%
associate-/r/45.4%
Simplified45.4%
Taylor expanded in x around 0 51.3%
*-lft-identity51.3%
times-frac51.3%
/-rgt-identity51.3%
Simplified51.3%
if 6.0000000000000004e-53 < a < 1.20000000000000009e38 or 5.99999999999999957e90 < a < 1.2500000000000001e96Initial program 79.5%
Taylor expanded in z around inf 59.4%
Final simplification55.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- y z) (/ t a))))
(if (<= a -1.36e+157)
x
(if (<= a -88.0)
t_1
(if (<= a 2.7e-242)
(- t (/ t (/ z y)))
(if (<= a 5.4e-49)
(* x (/ (- y a) z))
(if (<= a 1.2e+38)
t
(if (<= a 6e+90) t_1 (if (<= a 1.2e+96) t x)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / a);
double tmp;
if (a <= -1.36e+157) {
tmp = x;
} else if (a <= -88.0) {
tmp = t_1;
} else if (a <= 2.7e-242) {
tmp = t - (t / (z / y));
} else if (a <= 5.4e-49) {
tmp = x * ((y - a) / z);
} else if (a <= 1.2e+38) {
tmp = t;
} else if (a <= 6e+90) {
tmp = t_1;
} else if (a <= 1.2e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = (y - z) * (t / a)
if (a <= (-1.36d+157)) then
tmp = x
else if (a <= (-88.0d0)) then
tmp = t_1
else if (a <= 2.7d-242) then
tmp = t - (t / (z / y))
else if (a <= 5.4d-49) then
tmp = x * ((y - a) / z)
else if (a <= 1.2d+38) then
tmp = t
else if (a <= 6d+90) then
tmp = t_1
else if (a <= 1.2d+96) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (y - z) * (t / a);
double tmp;
if (a <= -1.36e+157) {
tmp = x;
} else if (a <= -88.0) {
tmp = t_1;
} else if (a <= 2.7e-242) {
tmp = t - (t / (z / y));
} else if (a <= 5.4e-49) {
tmp = x * ((y - a) / z);
} else if (a <= 1.2e+38) {
tmp = t;
} else if (a <= 6e+90) {
tmp = t_1;
} else if (a <= 1.2e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (y - z) * (t / a) tmp = 0 if a <= -1.36e+157: tmp = x elif a <= -88.0: tmp = t_1 elif a <= 2.7e-242: tmp = t - (t / (z / y)) elif a <= 5.4e-49: tmp = x * ((y - a) / z) elif a <= 1.2e+38: tmp = t elif a <= 6e+90: tmp = t_1 elif a <= 1.2e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(y - z) * Float64(t / a)) tmp = 0.0 if (a <= -1.36e+157) tmp = x; elseif (a <= -88.0) tmp = t_1; elseif (a <= 2.7e-242) tmp = Float64(t - Float64(t / Float64(z / y))); elseif (a <= 5.4e-49) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 1.2e+38) tmp = t; elseif (a <= 6e+90) tmp = t_1; elseif (a <= 1.2e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (y - z) * (t / a); tmp = 0.0; if (a <= -1.36e+157) tmp = x; elseif (a <= -88.0) tmp = t_1; elseif (a <= 2.7e-242) tmp = t - (t / (z / y)); elseif (a <= 5.4e-49) tmp = x * ((y - a) / z); elseif (a <= 1.2e+38) tmp = t; elseif (a <= 6e+90) tmp = t_1; elseif (a <= 1.2e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.36e+157], x, If[LessEqual[a, -88.0], t$95$1, If[LessEqual[a, 2.7e-242], N[(t - N[(t / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.4e-49], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.2e+38], t, If[LessEqual[a, 6e+90], t$95$1, If[LessEqual[a, 1.2e+96], t, x]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{if}\;a \leq -1.36 \cdot 10^{+157}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -88:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-242}:\\
\;\;\;\;t - \frac{t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 5.4 \cdot 10^{-49}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 6 \cdot 10^{+90}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.36e157 or 1.19999999999999996e96 < a Initial program 87.7%
Taylor expanded in a around inf 58.9%
if -1.36e157 < a < -88 or 1.20000000000000009e38 < a < 5.99999999999999957e90Initial program 85.1%
Taylor expanded in x around 0 38.5%
associate-/l*48.1%
associate-/r/48.2%
Simplified48.2%
Taylor expanded in a around inf 39.3%
if -88 < a < 2.7e-242Initial program 70.8%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub79.0%
mul-1-neg79.0%
unsub-neg79.0%
distribute-rgt-out--79.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 75.0%
Taylor expanded in t around inf 61.4%
associate-/l*65.3%
Simplified65.3%
if 2.7e-242 < a < 5.3999999999999999e-49Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-/l*51.4%
associate-/r/45.4%
Simplified45.4%
Taylor expanded in x around 0 51.3%
*-lft-identity51.3%
times-frac51.3%
/-rgt-identity51.3%
Simplified51.3%
if 5.3999999999999999e-49 < a < 1.20000000000000009e38 or 5.99999999999999957e90 < a < 1.19999999999999996e96Initial program 79.5%
Taylor expanded in z around inf 59.4%
Final simplification55.2%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.5e+155)
x
(if (<= a -43.0)
(* (- y z) (/ t a))
(if (<= a 1.65e-242)
(- t (/ t (/ z y)))
(if (<= a 5.8e-49)
(* x (/ (- y a) z))
(if (<= a 1.25e+38)
t
(if (<= a 2.9e+91)
(/ t (/ a (- y z)))
(if (<= a 1.12e+96) t x))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.5e+155) {
tmp = x;
} else if (a <= -43.0) {
tmp = (y - z) * (t / a);
} else if (a <= 1.65e-242) {
tmp = t - (t / (z / y));
} else if (a <= 5.8e-49) {
tmp = x * ((y - a) / z);
} else if (a <= 1.25e+38) {
tmp = t;
} else if (a <= 2.9e+91) {
tmp = t / (a / (y - z));
} else if (a <= 1.12e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-2.5d+155)) then
tmp = x
else if (a <= (-43.0d0)) then
tmp = (y - z) * (t / a)
else if (a <= 1.65d-242) then
tmp = t - (t / (z / y))
else if (a <= 5.8d-49) then
tmp = x * ((y - a) / z)
else if (a <= 1.25d+38) then
tmp = t
else if (a <= 2.9d+91) then
tmp = t / (a / (y - z))
else if (a <= 1.12d+96) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.5e+155) {
tmp = x;
} else if (a <= -43.0) {
tmp = (y - z) * (t / a);
} else if (a <= 1.65e-242) {
tmp = t - (t / (z / y));
} else if (a <= 5.8e-49) {
tmp = x * ((y - a) / z);
} else if (a <= 1.25e+38) {
tmp = t;
} else if (a <= 2.9e+91) {
tmp = t / (a / (y - z));
} else if (a <= 1.12e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.5e+155: tmp = x elif a <= -43.0: tmp = (y - z) * (t / a) elif a <= 1.65e-242: tmp = t - (t / (z / y)) elif a <= 5.8e-49: tmp = x * ((y - a) / z) elif a <= 1.25e+38: tmp = t elif a <= 2.9e+91: tmp = t / (a / (y - z)) elif a <= 1.12e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.5e+155) tmp = x; elseif (a <= -43.0) tmp = Float64(Float64(y - z) * Float64(t / a)); elseif (a <= 1.65e-242) tmp = Float64(t - Float64(t / Float64(z / y))); elseif (a <= 5.8e-49) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 1.25e+38) tmp = t; elseif (a <= 2.9e+91) tmp = Float64(t / Float64(a / Float64(y - z))); elseif (a <= 1.12e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.5e+155) tmp = x; elseif (a <= -43.0) tmp = (y - z) * (t / a); elseif (a <= 1.65e-242) tmp = t - (t / (z / y)); elseif (a <= 5.8e-49) tmp = x * ((y - a) / z); elseif (a <= 1.25e+38) tmp = t; elseif (a <= 2.9e+91) tmp = t / (a / (y - z)); elseif (a <= 1.12e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.5e+155], x, If[LessEqual[a, -43.0], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.65e-242], N[(t - N[(t / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.8e-49], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.25e+38], t, If[LessEqual[a, 2.9e+91], N[(t / N[(a / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.12e+96], t, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.5 \cdot 10^{+155}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -43:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{-242}:\\
\;\;\;\;t - \frac{t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 5.8 \cdot 10^{-49}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{+91}:\\
\;\;\;\;\frac{t}{\frac{a}{y - z}}\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -2.5e155 or 1.1199999999999999e96 < a Initial program 87.7%
Taylor expanded in a around inf 58.9%
if -2.5e155 < a < -43Initial program 86.6%
Taylor expanded in x around 0 35.4%
associate-/l*47.9%
associate-/r/48.1%
Simplified48.1%
Taylor expanded in a around inf 37.6%
if -43 < a < 1.64999999999999991e-242Initial program 70.8%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub79.0%
mul-1-neg79.0%
unsub-neg79.0%
distribute-rgt-out--79.0%
associate-/l*80.7%
Simplified80.7%
Taylor expanded in y around inf 75.0%
Taylor expanded in t around inf 61.4%
associate-/l*65.3%
Simplified65.3%
if 1.64999999999999991e-242 < a < 5.8e-49Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-/l*51.4%
associate-/r/45.4%
Simplified45.4%
Taylor expanded in x around 0 51.3%
*-lft-identity51.3%
times-frac51.3%
/-rgt-identity51.3%
Simplified51.3%
if 5.8e-49 < a < 1.24999999999999992e38 or 2.90000000000000014e91 < a < 1.1199999999999999e96Initial program 78.4%
Taylor expanded in z around inf 62.5%
if 1.24999999999999992e38 < a < 2.90000000000000014e91Initial program 82.0%
Taylor expanded in x around 0 45.4%
associate-/l*45.9%
associate-/r/45.7%
Simplified45.7%
Taylor expanded in a around inf 41.7%
associate-/l*42.0%
Simplified42.0%
Final simplification55.2%
(FPCore (x y z t a)
:precision binary64
(if (<= a -4e+99)
x
(if (<= a 2.75e-242)
(* t (- 1.0 (/ y z)))
(if (<= a 4.6e-48)
(* x (/ (- y a) z))
(if (<= a 1.9e+38)
t
(if (<= a 1.15e+91) (* t (/ y (- a z))) (if (<= a 1.55e+96) t x)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4e+99) {
tmp = x;
} else if (a <= 2.75e-242) {
tmp = t * (1.0 - (y / z));
} else if (a <= 4.6e-48) {
tmp = x * ((y - a) / z);
} else if (a <= 1.9e+38) {
tmp = t;
} else if (a <= 1.15e+91) {
tmp = t * (y / (a - z));
} else if (a <= 1.55e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-4d+99)) then
tmp = x
else if (a <= 2.75d-242) then
tmp = t * (1.0d0 - (y / z))
else if (a <= 4.6d-48) then
tmp = x * ((y - a) / z)
else if (a <= 1.9d+38) then
tmp = t
else if (a <= 1.15d+91) then
tmp = t * (y / (a - z))
else if (a <= 1.55d+96) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4e+99) {
tmp = x;
} else if (a <= 2.75e-242) {
tmp = t * (1.0 - (y / z));
} else if (a <= 4.6e-48) {
tmp = x * ((y - a) / z);
} else if (a <= 1.9e+38) {
tmp = t;
} else if (a <= 1.15e+91) {
tmp = t * (y / (a - z));
} else if (a <= 1.55e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -4e+99: tmp = x elif a <= 2.75e-242: tmp = t * (1.0 - (y / z)) elif a <= 4.6e-48: tmp = x * ((y - a) / z) elif a <= 1.9e+38: tmp = t elif a <= 1.15e+91: tmp = t * (y / (a - z)) elif a <= 1.55e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -4e+99) tmp = x; elseif (a <= 2.75e-242) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (a <= 4.6e-48) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 1.9e+38) tmp = t; elseif (a <= 1.15e+91) tmp = Float64(t * Float64(y / Float64(a - z))); elseif (a <= 1.55e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -4e+99) tmp = x; elseif (a <= 2.75e-242) tmp = t * (1.0 - (y / z)); elseif (a <= 4.6e-48) tmp = x * ((y - a) / z); elseif (a <= 1.9e+38) tmp = t; elseif (a <= 1.15e+91) tmp = t * (y / (a - z)); elseif (a <= 1.55e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -4e+99], x, If[LessEqual[a, 2.75e-242], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.6e-48], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.9e+38], t, If[LessEqual[a, 1.15e+91], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.55e+96], t, x]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4 \cdot 10^{+99}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 2.75 \cdot 10^{-242}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{-48}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 1.9 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 1.15 \cdot 10^{+91}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;a \leq 1.55 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -3.9999999999999999e99 or 1.5499999999999999e96 < a Initial program 87.1%
Taylor expanded in a around inf 53.7%
if -3.9999999999999999e99 < a < 2.7499999999999999e-242Initial program 75.4%
Taylor expanded in z around inf 64.7%
associate--l+64.7%
distribute-lft-out--64.7%
div-sub65.8%
mul-1-neg65.8%
unsub-neg65.8%
distribute-rgt-out--65.8%
associate-/l*69.0%
Simplified69.0%
Taylor expanded in y around inf 62.7%
Taylor expanded in t around inf 53.7%
if 2.7499999999999999e-242 < a < 4.6000000000000001e-48Initial program 65.5%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
distribute-lft-out--72.6%
div-sub72.6%
mul-1-neg72.6%
unsub-neg72.6%
distribute-rgt-out--72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-/l*51.4%
associate-/r/45.4%
Simplified45.4%
Taylor expanded in x around 0 51.3%
*-lft-identity51.3%
times-frac51.3%
/-rgt-identity51.3%
Simplified51.3%
if 4.6000000000000001e-48 < a < 1.8999999999999999e38 or 1.14999999999999996e91 < a < 1.5499999999999999e96Initial program 78.4%
Taylor expanded in z around inf 62.5%
if 1.8999999999999999e38 < a < 1.14999999999999996e91Initial program 82.0%
Taylor expanded in y around inf 51.9%
div-sub51.9%
associate-*r/51.8%
associate-/l*51.7%
associate-/r/51.7%
Simplified51.7%
Taylor expanded in t around inf 39.3%
associate-*r/39.2%
Simplified39.2%
Final simplification53.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ y (/ a (- t x)))))
(if (<= a -2.2e+106)
x
(if (<= a -1.85)
t_1
(if (<= a 2.5e-245)
(- t (/ t (/ z y)))
(if (<= a 1.65e+38)
(+ t (/ (* x y) z))
(if (<= a 2.95e+91) t_1 (if (<= a 1.12e+96) t x))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -2.2e+106) {
tmp = x;
} else if (a <= -1.85) {
tmp = t_1;
} else if (a <= 2.5e-245) {
tmp = t - (t / (z / y));
} else if (a <= 1.65e+38) {
tmp = t + ((x * y) / z);
} else if (a <= 2.95e+91) {
tmp = t_1;
} else if (a <= 1.12e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = y / (a / (t - x))
if (a <= (-2.2d+106)) then
tmp = x
else if (a <= (-1.85d0)) then
tmp = t_1
else if (a <= 2.5d-245) then
tmp = t - (t / (z / y))
else if (a <= 1.65d+38) then
tmp = t + ((x * y) / z)
else if (a <= 2.95d+91) then
tmp = t_1
else if (a <= 1.12d+96) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -2.2e+106) {
tmp = x;
} else if (a <= -1.85) {
tmp = t_1;
} else if (a <= 2.5e-245) {
tmp = t - (t / (z / y));
} else if (a <= 1.65e+38) {
tmp = t + ((x * y) / z);
} else if (a <= 2.95e+91) {
tmp = t_1;
} else if (a <= 1.12e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y / (a / (t - x)) tmp = 0 if a <= -2.2e+106: tmp = x elif a <= -1.85: tmp = t_1 elif a <= 2.5e-245: tmp = t - (t / (z / y)) elif a <= 1.65e+38: tmp = t + ((x * y) / z) elif a <= 2.95e+91: tmp = t_1 elif a <= 1.12e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(y / Float64(a / Float64(t - x))) tmp = 0.0 if (a <= -2.2e+106) tmp = x; elseif (a <= -1.85) tmp = t_1; elseif (a <= 2.5e-245) tmp = Float64(t - Float64(t / Float64(z / y))); elseif (a <= 1.65e+38) tmp = Float64(t + Float64(Float64(x * y) / z)); elseif (a <= 2.95e+91) tmp = t_1; elseif (a <= 1.12e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y / (a / (t - x)); tmp = 0.0; if (a <= -2.2e+106) tmp = x; elseif (a <= -1.85) tmp = t_1; elseif (a <= 2.5e-245) tmp = t - (t / (z / y)); elseif (a <= 1.65e+38) tmp = t + ((x * y) / z); elseif (a <= 2.95e+91) tmp = t_1; elseif (a <= 1.12e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.2e+106], x, If[LessEqual[a, -1.85], t$95$1, If[LessEqual[a, 2.5e-245], N[(t - N[(t / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.65e+38], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.95e+91], t$95$1, If[LessEqual[a, 1.12e+96], t, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{\frac{a}{t - x}}\\
\mathbf{if}\;a \leq -2.2 \cdot 10^{+106}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.85:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.5 \cdot 10^{-245}:\\
\;\;\;\;t - \frac{t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{+38}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{elif}\;a \leq 2.95 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -2.19999999999999992e106 or 1.1199999999999999e96 < a Initial program 86.5%
Taylor expanded in a around inf 54.8%
if -2.19999999999999992e106 < a < -1.8500000000000001 or 1.65e38 < a < 2.9500000000000001e91Initial program 86.9%
Taylor expanded in y around inf 57.3%
div-sub57.3%
associate-*r/53.4%
associate-/l*57.2%
Simplified57.2%
Taylor expanded in a around inf 49.1%
if -1.8500000000000001 < a < 2.4999999999999998e-245Initial program 70.4%
Taylor expanded in z around inf 77.2%
associate--l+77.2%
distribute-lft-out--77.2%
div-sub78.7%
mul-1-neg78.7%
unsub-neg78.7%
distribute-rgt-out--78.7%
associate-/l*80.4%
Simplified80.4%
Taylor expanded in y around inf 74.7%
Taylor expanded in t around inf 60.8%
associate-/l*64.8%
Simplified64.8%
if 2.4999999999999998e-245 < a < 1.65e38Initial program 69.5%
Taylor expanded in z around inf 68.3%
associate--l+68.3%
distribute-lft-out--68.3%
div-sub68.3%
mul-1-neg68.3%
unsub-neg68.3%
distribute-rgt-out--68.3%
associate-/l*76.1%
Simplified76.1%
Taylor expanded in y around inf 63.0%
Taylor expanded in t around 0 63.1%
mul-1-neg63.1%
distribute-lft-neg-out63.1%
*-commutative63.1%
Simplified63.1%
if 2.9500000000000001e91 < a < 1.1199999999999999e96Initial program 100.0%
Taylor expanded in z around inf 100.0%
Final simplification58.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ y (/ a (- t x)))))
(if (<= a -1.4e+110)
x
(if (<= a -42.0)
t_1
(if (<= a 2.5e-245)
(* t (+ (/ (- a y) z) 1.0))
(if (<= a 2.3e+38)
(+ t (/ (* x y) z))
(if (<= a 3.5e+91) t_1 (if (<= a 1.46e+96) t x))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -1.4e+110) {
tmp = x;
} else if (a <= -42.0) {
tmp = t_1;
} else if (a <= 2.5e-245) {
tmp = t * (((a - y) / z) + 1.0);
} else if (a <= 2.3e+38) {
tmp = t + ((x * y) / z);
} else if (a <= 3.5e+91) {
tmp = t_1;
} else if (a <= 1.46e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = y / (a / (t - x))
if (a <= (-1.4d+110)) then
tmp = x
else if (a <= (-42.0d0)) then
tmp = t_1
else if (a <= 2.5d-245) then
tmp = t * (((a - y) / z) + 1.0d0)
else if (a <= 2.3d+38) then
tmp = t + ((x * y) / z)
else if (a <= 3.5d+91) then
tmp = t_1
else if (a <= 1.46d+96) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y / (a / (t - x));
double tmp;
if (a <= -1.4e+110) {
tmp = x;
} else if (a <= -42.0) {
tmp = t_1;
} else if (a <= 2.5e-245) {
tmp = t * (((a - y) / z) + 1.0);
} else if (a <= 2.3e+38) {
tmp = t + ((x * y) / z);
} else if (a <= 3.5e+91) {
tmp = t_1;
} else if (a <= 1.46e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y / (a / (t - x)) tmp = 0 if a <= -1.4e+110: tmp = x elif a <= -42.0: tmp = t_1 elif a <= 2.5e-245: tmp = t * (((a - y) / z) + 1.0) elif a <= 2.3e+38: tmp = t + ((x * y) / z) elif a <= 3.5e+91: tmp = t_1 elif a <= 1.46e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(y / Float64(a / Float64(t - x))) tmp = 0.0 if (a <= -1.4e+110) tmp = x; elseif (a <= -42.0) tmp = t_1; elseif (a <= 2.5e-245) tmp = Float64(t * Float64(Float64(Float64(a - y) / z) + 1.0)); elseif (a <= 2.3e+38) tmp = Float64(t + Float64(Float64(x * y) / z)); elseif (a <= 3.5e+91) tmp = t_1; elseif (a <= 1.46e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y / (a / (t - x)); tmp = 0.0; if (a <= -1.4e+110) tmp = x; elseif (a <= -42.0) tmp = t_1; elseif (a <= 2.5e-245) tmp = t * (((a - y) / z) + 1.0); elseif (a <= 2.3e+38) tmp = t + ((x * y) / z); elseif (a <= 3.5e+91) tmp = t_1; elseif (a <= 1.46e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.4e+110], x, If[LessEqual[a, -42.0], t$95$1, If[LessEqual[a, 2.5e-245], N[(t * N[(N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.3e+38], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.5e+91], t$95$1, If[LessEqual[a, 1.46e+96], t, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{\frac{a}{t - x}}\\
\mathbf{if}\;a \leq -1.4 \cdot 10^{+110}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -42:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.5 \cdot 10^{-245}:\\
\;\;\;\;t \cdot \left(\frac{a - y}{z} + 1\right)\\
\mathbf{elif}\;a \leq 2.3 \cdot 10^{+38}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{elif}\;a \leq 3.5 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.46 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.39999999999999993e110 or 1.4600000000000001e96 < a Initial program 86.5%
Taylor expanded in a around inf 54.8%
if -1.39999999999999993e110 < a < -42 or 2.3000000000000001e38 < a < 3.50000000000000001e91Initial program 86.9%
Taylor expanded in y around inf 57.3%
div-sub57.3%
associate-*r/53.4%
associate-/l*57.2%
Simplified57.2%
Taylor expanded in a around inf 49.1%
if -42 < a < 2.4999999999999998e-245Initial program 70.4%
Taylor expanded in z around inf 77.2%
associate--l+77.2%
distribute-lft-out--77.2%
div-sub78.7%
mul-1-neg78.7%
unsub-neg78.7%
distribute-rgt-out--78.7%
associate-/l*80.4%
Simplified80.4%
Taylor expanded in t around -inf 64.8%
neg-mul-164.8%
unsub-neg64.8%
Simplified64.8%
if 2.4999999999999998e-245 < a < 2.3000000000000001e38Initial program 69.5%
Taylor expanded in z around inf 68.3%
associate--l+68.3%
distribute-lft-out--68.3%
div-sub68.3%
mul-1-neg68.3%
unsub-neg68.3%
distribute-rgt-out--68.3%
associate-/l*76.1%
Simplified76.1%
Taylor expanded in y around inf 63.0%
Taylor expanded in t around 0 63.1%
mul-1-neg63.1%
distribute-lft-neg-out63.1%
*-commutative63.1%
Simplified63.1%
if 3.50000000000000001e91 < a < 1.4600000000000001e96Initial program 100.0%
Taylor expanded in z around inf 100.0%
Final simplification58.5%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.15e+106)
x
(if (<= a -2.6e+58)
(/ t (/ a y))
(if (<= a -1100000000.0)
x
(if (<= a 3.6e-222)
t
(if (<= a 2.5e-42) (* y (/ x z)) (if (<= a 1.35e+38) t x)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.15e+106) {
tmp = x;
} else if (a <= -2.6e+58) {
tmp = t / (a / y);
} else if (a <= -1100000000.0) {
tmp = x;
} else if (a <= 3.6e-222) {
tmp = t;
} else if (a <= 2.5e-42) {
tmp = y * (x / z);
} else if (a <= 1.35e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-1.15d+106)) then
tmp = x
else if (a <= (-2.6d+58)) then
tmp = t / (a / y)
else if (a <= (-1100000000.0d0)) then
tmp = x
else if (a <= 3.6d-222) then
tmp = t
else if (a <= 2.5d-42) then
tmp = y * (x / z)
else if (a <= 1.35d+38) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.15e+106) {
tmp = x;
} else if (a <= -2.6e+58) {
tmp = t / (a / y);
} else if (a <= -1100000000.0) {
tmp = x;
} else if (a <= 3.6e-222) {
tmp = t;
} else if (a <= 2.5e-42) {
tmp = y * (x / z);
} else if (a <= 1.35e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.15e+106: tmp = x elif a <= -2.6e+58: tmp = t / (a / y) elif a <= -1100000000.0: tmp = x elif a <= 3.6e-222: tmp = t elif a <= 2.5e-42: tmp = y * (x / z) elif a <= 1.35e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.15e+106) tmp = x; elseif (a <= -2.6e+58) tmp = Float64(t / Float64(a / y)); elseif (a <= -1100000000.0) tmp = x; elseif (a <= 3.6e-222) tmp = t; elseif (a <= 2.5e-42) tmp = Float64(y * Float64(x / z)); elseif (a <= 1.35e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.15e+106) tmp = x; elseif (a <= -2.6e+58) tmp = t / (a / y); elseif (a <= -1100000000.0) tmp = x; elseif (a <= 3.6e-222) tmp = t; elseif (a <= 2.5e-42) tmp = y * (x / z); elseif (a <= 1.35e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.15e+106], x, If[LessEqual[a, -2.6e+58], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1100000000.0], x, If[LessEqual[a, 3.6e-222], t, If[LessEqual[a, 2.5e-42], N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+38], t, x]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.15 \cdot 10^{+106}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -2.6 \cdot 10^{+58}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq -1100000000:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 3.6 \cdot 10^{-222}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 2.5 \cdot 10^{-42}:\\
\;\;\;\;y \cdot \frac{x}{z}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.1500000000000001e106 or -2.59999999999999988e58 < a < -1.1e9 or 1.34999999999999998e38 < a Initial program 85.6%
Taylor expanded in a around inf 47.6%
if -1.1500000000000001e106 < a < -2.59999999999999988e58Initial program 93.8%
Taylor expanded in x around 0 53.6%
associate-/l*64.9%
associate-/r/64.8%
Simplified64.8%
Taylor expanded in z around 0 37.7%
associate-/l*38.1%
Simplified38.1%
if -1.1e9 < a < 3.59999999999999974e-222 or 2.50000000000000001e-42 < a < 1.34999999999999998e38Initial program 70.3%
Taylor expanded in z around inf 43.6%
if 3.59999999999999974e-222 < a < 2.50000000000000001e-42Initial program 71.1%
Taylor expanded in z around inf 65.3%
associate--l+65.3%
distribute-lft-out--65.3%
div-sub65.3%
mul-1-neg65.3%
unsub-neg65.3%
distribute-rgt-out--65.3%
associate-/l*72.3%
Simplified72.3%
Taylor expanded in t around 0 47.9%
associate-/l*48.0%
associate-/r/47.8%
Simplified47.8%
Taylor expanded in y around inf 41.5%
associate-*l/41.6%
*-commutative41.6%
Simplified41.6%
Final simplification44.8%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.8e+110)
x
(if (<= a -7.2e+56)
(/ t (/ a y))
(if (<= a -13000000000000.0)
x
(if (<= a 2.4e-244)
t
(if (<= a 1.65e-46) (/ (* x y) z) (if (<= a 2.4e+38) t x)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.8e+110) {
tmp = x;
} else if (a <= -7.2e+56) {
tmp = t / (a / y);
} else if (a <= -13000000000000.0) {
tmp = x;
} else if (a <= 2.4e-244) {
tmp = t;
} else if (a <= 1.65e-46) {
tmp = (x * y) / z;
} else if (a <= 2.4e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-1.8d+110)) then
tmp = x
else if (a <= (-7.2d+56)) then
tmp = t / (a / y)
else if (a <= (-13000000000000.0d0)) then
tmp = x
else if (a <= 2.4d-244) then
tmp = t
else if (a <= 1.65d-46) then
tmp = (x * y) / z
else if (a <= 2.4d+38) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.8e+110) {
tmp = x;
} else if (a <= -7.2e+56) {
tmp = t / (a / y);
} else if (a <= -13000000000000.0) {
tmp = x;
} else if (a <= 2.4e-244) {
tmp = t;
} else if (a <= 1.65e-46) {
tmp = (x * y) / z;
} else if (a <= 2.4e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.8e+110: tmp = x elif a <= -7.2e+56: tmp = t / (a / y) elif a <= -13000000000000.0: tmp = x elif a <= 2.4e-244: tmp = t elif a <= 1.65e-46: tmp = (x * y) / z elif a <= 2.4e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.8e+110) tmp = x; elseif (a <= -7.2e+56) tmp = Float64(t / Float64(a / y)); elseif (a <= -13000000000000.0) tmp = x; elseif (a <= 2.4e-244) tmp = t; elseif (a <= 1.65e-46) tmp = Float64(Float64(x * y) / z); elseif (a <= 2.4e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.8e+110) tmp = x; elseif (a <= -7.2e+56) tmp = t / (a / y); elseif (a <= -13000000000000.0) tmp = x; elseif (a <= 2.4e-244) tmp = t; elseif (a <= 1.65e-46) tmp = (x * y) / z; elseif (a <= 2.4e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.8e+110], x, If[LessEqual[a, -7.2e+56], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -13000000000000.0], x, If[LessEqual[a, 2.4e-244], t, If[LessEqual[a, 1.65e-46], N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[a, 2.4e+38], t, x]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.8 \cdot 10^{+110}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -7.2 \cdot 10^{+56}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq -13000000000000:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{-244}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{-46}:\\
\;\;\;\;\frac{x \cdot y}{z}\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.7999999999999998e110 or -7.19999999999999996e56 < a < -1.3e13 or 2.40000000000000017e38 < a Initial program 85.6%
Taylor expanded in a around inf 47.6%
if -1.7999999999999998e110 < a < -7.19999999999999996e56Initial program 93.8%
Taylor expanded in x around 0 53.6%
associate-/l*64.9%
associate-/r/64.8%
Simplified64.8%
Taylor expanded in z around 0 37.7%
associate-/l*38.1%
Simplified38.1%
if -1.3e13 < a < 2.40000000000000016e-244 or 1.65000000000000007e-46 < a < 2.40000000000000017e38Initial program 72.0%
Taylor expanded in z around inf 43.7%
if 2.40000000000000016e-244 < a < 1.65000000000000007e-46Initial program 66.6%
Taylor expanded in z around inf 70.6%
associate--l+70.6%
distribute-lft-out--70.6%
div-sub70.6%
mul-1-neg70.6%
unsub-neg70.6%
distribute-rgt-out--70.6%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in t around 0 50.0%
associate-/l*50.0%
associate-/r/44.2%
Simplified44.2%
Taylor expanded in y around inf 41.7%
Final simplification44.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- y z) (/ (- t x) a)))))
(if (<= a -0.97)
t_1
(if (<= a 5.6e-124)
(+ t (/ (* y (- x t)) z))
(if (<= a 1.9e-80)
(+ x (* (- t x) (/ y a)))
(if (<= a 1.18e+38) (+ t (/ (* x y) z)) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / a));
double tmp;
if (a <= -0.97) {
tmp = t_1;
} else if (a <= 5.6e-124) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 1.9e-80) {
tmp = x + ((t - x) * (y / a));
} else if (a <= 1.18e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = x + ((y - z) * ((t - x) / a))
if (a <= (-0.97d0)) then
tmp = t_1
else if (a <= 5.6d-124) then
tmp = t + ((y * (x - t)) / z)
else if (a <= 1.9d-80) then
tmp = x + ((t - x) * (y / a))
else if (a <= 1.18d+38) then
tmp = t + ((x * y) / z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y - z) * ((t - x) / a));
double tmp;
if (a <= -0.97) {
tmp = t_1;
} else if (a <= 5.6e-124) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 1.9e-80) {
tmp = x + ((t - x) * (y / a));
} else if (a <= 1.18e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y - z) * ((t - x) / a)) tmp = 0 if a <= -0.97: tmp = t_1 elif a <= 5.6e-124: tmp = t + ((y * (x - t)) / z) elif a <= 1.9e-80: tmp = x + ((t - x) * (y / a)) elif a <= 1.18e+38: tmp = t + ((x * y) / z) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / a))) tmp = 0.0 if (a <= -0.97) tmp = t_1; elseif (a <= 5.6e-124) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (a <= 1.9e-80) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); elseif (a <= 1.18e+38) tmp = Float64(t + Float64(Float64(x * y) / z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y - z) * ((t - x) / a)); tmp = 0.0; if (a <= -0.97) tmp = t_1; elseif (a <= 5.6e-124) tmp = t + ((y * (x - t)) / z); elseif (a <= 1.9e-80) tmp = x + ((t - x) * (y / a)); elseif (a <= 1.18e+38) tmp = t + ((x * y) / z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -0.97], t$95$1, If[LessEqual[a, 5.6e-124], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.9e-80], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.18e+38], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - z\right) \cdot \frac{t - x}{a}\\
\mathbf{if}\;a \leq -0.97:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-124}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;a \leq 1.9 \cdot 10^{-80}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{elif}\;a \leq 1.18 \cdot 10^{+38}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -0.96999999999999997 or 1.18e38 < a Initial program 86.8%
Taylor expanded in a around inf 76.1%
if -0.96999999999999997 < a < 5.59999999999999996e-124Initial program 68.6%
Taylor expanded in z around inf 79.4%
associate--l+79.4%
distribute-lft-out--79.4%
div-sub80.6%
mul-1-neg80.6%
unsub-neg80.6%
distribute-rgt-out--80.6%
associate-/l*84.0%
Simplified84.0%
Taylor expanded in y around inf 75.5%
if 5.59999999999999996e-124 < a < 1.89999999999999983e-80Initial program 87.2%
Taylor expanded in z around 0 97.8%
associate-/l*85.7%
associate-/r/98.2%
Simplified98.2%
if 1.89999999999999983e-80 < a < 1.18e38Initial program 70.8%
Taylor expanded in z around inf 66.1%
associate--l+66.1%
distribute-lft-out--66.1%
div-sub66.1%
mul-1-neg66.1%
unsub-neg66.1%
distribute-rgt-out--66.1%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in y around inf 61.7%
Taylor expanded in t around 0 66.6%
mul-1-neg66.6%
distribute-lft-neg-out66.6%
*-commutative66.6%
Simplified66.6%
Final simplification75.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- x t) (/ (- z y) a)))))
(if (<= a -5.3)
t_1
(if (<= a 5.6e-124)
(+ t (/ (* y (- x t)) z))
(if (<= a 7.4e-82)
t_1
(if (<= a 1.18e+38)
(+ t (/ (* x y) z))
(+ x (* (- y z) (/ (- t x) a)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((x - t) * ((z - y) / a));
double tmp;
if (a <= -5.3) {
tmp = t_1;
} else if (a <= 5.6e-124) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 7.4e-82) {
tmp = t_1;
} else if (a <= 1.18e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = x + ((y - z) * ((t - x) / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = x + ((x - t) * ((z - y) / a))
if (a <= (-5.3d0)) then
tmp = t_1
else if (a <= 5.6d-124) then
tmp = t + ((y * (x - t)) / z)
else if (a <= 7.4d-82) then
tmp = t_1
else if (a <= 1.18d+38) then
tmp = t + ((x * y) / z)
else
tmp = x + ((y - z) * ((t - x) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((x - t) * ((z - y) / a));
double tmp;
if (a <= -5.3) {
tmp = t_1;
} else if (a <= 5.6e-124) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 7.4e-82) {
tmp = t_1;
} else if (a <= 1.18e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = x + ((y - z) * ((t - x) / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((x - t) * ((z - y) / a)) tmp = 0 if a <= -5.3: tmp = t_1 elif a <= 5.6e-124: tmp = t + ((y * (x - t)) / z) elif a <= 7.4e-82: tmp = t_1 elif a <= 1.18e+38: tmp = t + ((x * y) / z) else: tmp = x + ((y - z) * ((t - x) / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / a))) tmp = 0.0 if (a <= -5.3) tmp = t_1; elseif (a <= 5.6e-124) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (a <= 7.4e-82) tmp = t_1; elseif (a <= 1.18e+38) tmp = Float64(t + Float64(Float64(x * y) / z)); else tmp = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((x - t) * ((z - y) / a)); tmp = 0.0; if (a <= -5.3) tmp = t_1; elseif (a <= 5.6e-124) tmp = t + ((y * (x - t)) / z); elseif (a <= 7.4e-82) tmp = t_1; elseif (a <= 1.18e+38) tmp = t + ((x * y) / z); else tmp = x + ((y - z) * ((t - x) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -5.3], t$95$1, If[LessEqual[a, 5.6e-124], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.4e-82], t$95$1, If[LessEqual[a, 1.18e+38], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(x - t\right) \cdot \frac{z - y}{a}\\
\mathbf{if}\;a \leq -5.3:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-124}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;a \leq 7.4 \cdot 10^{-82}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.18 \cdot 10^{+38}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t - x}{a}\\
\end{array}
\end{array}
if a < -5.29999999999999982 or 5.59999999999999996e-124 < a < 7.4000000000000002e-82Initial program 88.4%
Taylor expanded in y around 0 75.5%
+-commutative75.5%
div-sub75.5%
associate-*r/67.8%
mul-1-neg67.8%
sub-neg67.8%
associate-/l*75.5%
associate-/l*88.1%
div-sub88.3%
associate-/r/91.8%
Simplified91.8%
Taylor expanded in a around inf 80.0%
if -5.29999999999999982 < a < 5.59999999999999996e-124Initial program 68.6%
Taylor expanded in z around inf 79.4%
associate--l+79.4%
distribute-lft-out--79.4%
div-sub80.6%
mul-1-neg80.6%
unsub-neg80.6%
distribute-rgt-out--80.6%
associate-/l*84.0%
Simplified84.0%
Taylor expanded in y around inf 75.5%
if 7.4000000000000002e-82 < a < 1.18e38Initial program 70.8%
Taylor expanded in z around inf 66.1%
associate--l+66.1%
distribute-lft-out--66.1%
div-sub66.1%
mul-1-neg66.1%
unsub-neg66.1%
distribute-rgt-out--66.1%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in y around inf 61.7%
Taylor expanded in t around 0 66.6%
mul-1-neg66.6%
distribute-lft-neg-out66.6%
*-commutative66.6%
Simplified66.6%
if 1.18e38 < a Initial program 84.6%
Taylor expanded in a around inf 75.0%
Final simplification76.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- x t) (/ (- z y) a)))))
(if (<= a -70.0)
t_1
(if (<= a 5.3e-124)
(+ t (/ (* (- t x) (- a y)) z))
(if (<= a 2.1e-82)
t_1
(if (<= a 1.55e+38)
(+ t (/ (* x y) z))
(+ x (* (- y z) (/ (- t x) a)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((x - t) * ((z - y) / a));
double tmp;
if (a <= -70.0) {
tmp = t_1;
} else if (a <= 5.3e-124) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (a <= 2.1e-82) {
tmp = t_1;
} else if (a <= 1.55e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = x + ((y - z) * ((t - x) / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = x + ((x - t) * ((z - y) / a))
if (a <= (-70.0d0)) then
tmp = t_1
else if (a <= 5.3d-124) then
tmp = t + (((t - x) * (a - y)) / z)
else if (a <= 2.1d-82) then
tmp = t_1
else if (a <= 1.55d+38) then
tmp = t + ((x * y) / z)
else
tmp = x + ((y - z) * ((t - x) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((x - t) * ((z - y) / a));
double tmp;
if (a <= -70.0) {
tmp = t_1;
} else if (a <= 5.3e-124) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (a <= 2.1e-82) {
tmp = t_1;
} else if (a <= 1.55e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = x + ((y - z) * ((t - x) / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((x - t) * ((z - y) / a)) tmp = 0 if a <= -70.0: tmp = t_1 elif a <= 5.3e-124: tmp = t + (((t - x) * (a - y)) / z) elif a <= 2.1e-82: tmp = t_1 elif a <= 1.55e+38: tmp = t + ((x * y) / z) else: tmp = x + ((y - z) * ((t - x) / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / a))) tmp = 0.0 if (a <= -70.0) tmp = t_1; elseif (a <= 5.3e-124) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); elseif (a <= 2.1e-82) tmp = t_1; elseif (a <= 1.55e+38) tmp = Float64(t + Float64(Float64(x * y) / z)); else tmp = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((x - t) * ((z - y) / a)); tmp = 0.0; if (a <= -70.0) tmp = t_1; elseif (a <= 5.3e-124) tmp = t + (((t - x) * (a - y)) / z); elseif (a <= 2.1e-82) tmp = t_1; elseif (a <= 1.55e+38) tmp = t + ((x * y) / z); else tmp = x + ((y - z) * ((t - x) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -70.0], t$95$1, If[LessEqual[a, 5.3e-124], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.1e-82], t$95$1, If[LessEqual[a, 1.55e+38], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(x - t\right) \cdot \frac{z - y}{a}\\
\mathbf{if}\;a \leq -70:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.3 \cdot 10^{-124}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{-82}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.55 \cdot 10^{+38}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t - x}{a}\\
\end{array}
\end{array}
if a < -70 or 5.2999999999999997e-124 < a < 2.1e-82Initial program 88.4%
Taylor expanded in y around 0 75.5%
+-commutative75.5%
div-sub75.5%
associate-*r/67.8%
mul-1-neg67.8%
sub-neg67.8%
associate-/l*75.5%
associate-/l*88.1%
div-sub88.3%
associate-/r/91.8%
Simplified91.8%
Taylor expanded in a around inf 80.0%
if -70 < a < 5.2999999999999997e-124Initial program 68.6%
Taylor expanded in z around inf 79.4%
associate--l+79.4%
distribute-lft-out--79.4%
div-sub80.6%
mul-1-neg80.6%
unsub-neg80.6%
distribute-rgt-out--80.6%
associate-/l*84.0%
Simplified84.0%
Taylor expanded in z around 0 80.6%
if 2.1e-82 < a < 1.55000000000000009e38Initial program 70.8%
Taylor expanded in z around inf 66.1%
associate--l+66.1%
distribute-lft-out--66.1%
div-sub66.1%
mul-1-neg66.1%
unsub-neg66.1%
distribute-rgt-out--66.1%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in y around inf 61.7%
Taylor expanded in t around 0 66.6%
mul-1-neg66.6%
distribute-lft-neg-out66.6%
*-commutative66.6%
Simplified66.6%
if 1.55000000000000009e38 < a Initial program 84.6%
Taylor expanded in a around inf 75.0%
Final simplification78.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (/ (- x t) (/ z (- y a)))))
(t_2 (+ x (* (- x t) (/ (- z y) a)))))
(if (<= a -30.5)
t_2
(if (<= a 1.1e-124)
t_1
(if (<= a 1.65e-85)
t_2
(if (<= a 6.2e+28) t_1 (+ x (* (- y z) (/ (- t x) a)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((x - t) / (z / (y - a)));
double t_2 = x + ((x - t) * ((z - y) / a));
double tmp;
if (a <= -30.5) {
tmp = t_2;
} else if (a <= 1.1e-124) {
tmp = t_1;
} else if (a <= 1.65e-85) {
tmp = t_2;
} else if (a <= 6.2e+28) {
tmp = t_1;
} else {
tmp = x + ((y - z) * ((t - x) / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t + ((x - t) / (z / (y - a)))
t_2 = x + ((x - t) * ((z - y) / a))
if (a <= (-30.5d0)) then
tmp = t_2
else if (a <= 1.1d-124) then
tmp = t_1
else if (a <= 1.65d-85) then
tmp = t_2
else if (a <= 6.2d+28) then
tmp = t_1
else
tmp = x + ((y - z) * ((t - x) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((x - t) / (z / (y - a)));
double t_2 = x + ((x - t) * ((z - y) / a));
double tmp;
if (a <= -30.5) {
tmp = t_2;
} else if (a <= 1.1e-124) {
tmp = t_1;
} else if (a <= 1.65e-85) {
tmp = t_2;
} else if (a <= 6.2e+28) {
tmp = t_1;
} else {
tmp = x + ((y - z) * ((t - x) / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + ((x - t) / (z / (y - a))) t_2 = x + ((x - t) * ((z - y) / a)) tmp = 0 if a <= -30.5: tmp = t_2 elif a <= 1.1e-124: tmp = t_1 elif a <= 1.65e-85: tmp = t_2 elif a <= 6.2e+28: tmp = t_1 else: tmp = x + ((y - z) * ((t - x) / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))) t_2 = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / a))) tmp = 0.0 if (a <= -30.5) tmp = t_2; elseif (a <= 1.1e-124) tmp = t_1; elseif (a <= 1.65e-85) tmp = t_2; elseif (a <= 6.2e+28) tmp = t_1; else tmp = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + ((x - t) / (z / (y - a))); t_2 = x + ((x - t) * ((z - y) / a)); tmp = 0.0; if (a <= -30.5) tmp = t_2; elseif (a <= 1.1e-124) tmp = t_1; elseif (a <= 1.65e-85) tmp = t_2; elseif (a <= 6.2e+28) tmp = t_1; else tmp = x + ((y - z) * ((t - x) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -30.5], t$95$2, If[LessEqual[a, 1.1e-124], t$95$1, If[LessEqual[a, 1.65e-85], t$95$2, If[LessEqual[a, 6.2e+28], t$95$1, N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{x - t}{\frac{z}{y - a}}\\
t_2 := x + \left(x - t\right) \cdot \frac{z - y}{a}\\
\mathbf{if}\;a \leq -30.5:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 1.1 \cdot 10^{-124}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{-85}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 6.2 \cdot 10^{+28}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{t - x}{a}\\
\end{array}
\end{array}
if a < -30.5 or 1.0999999999999999e-124 < a < 1.64999999999999986e-85Initial program 88.4%
Taylor expanded in y around 0 75.5%
+-commutative75.5%
div-sub75.5%
associate-*r/67.8%
mul-1-neg67.8%
sub-neg67.8%
associate-/l*75.5%
associate-/l*88.1%
div-sub88.3%
associate-/r/91.8%
Simplified91.8%
Taylor expanded in a around inf 80.0%
if -30.5 < a < 1.0999999999999999e-124 or 1.64999999999999986e-85 < a < 6.2000000000000001e28Initial program 68.4%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
distribute-lft-out--77.5%
div-sub78.5%
mul-1-neg78.5%
unsub-neg78.5%
distribute-rgt-out--78.5%
associate-/l*83.1%
Simplified83.1%
if 6.2000000000000001e28 < a Initial program 85.1%
Taylor expanded in a around inf 74.1%
Final simplification80.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- t x) (/ y (- a z)))) (t_2 (* t (/ (- y z) (- a z)))))
(if (<= t -8.4e-97)
t_2
(if (<= t 4.9e-237)
t_1
(if (<= t 3.8e-100) x (if (<= t 6.5e-28) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - x) * (y / (a - z));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (t <= -8.4e-97) {
tmp = t_2;
} else if (t <= 4.9e-237) {
tmp = t_1;
} else if (t <= 3.8e-100) {
tmp = x;
} else if (t <= 6.5e-28) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (t - x) * (y / (a - z))
t_2 = t * ((y - z) / (a - z))
if (t <= (-8.4d-97)) then
tmp = t_2
else if (t <= 4.9d-237) then
tmp = t_1
else if (t <= 3.8d-100) then
tmp = x
else if (t <= 6.5d-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 t_1 = (t - x) * (y / (a - z));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (t <= -8.4e-97) {
tmp = t_2;
} else if (t <= 4.9e-237) {
tmp = t_1;
} else if (t <= 3.8e-100) {
tmp = x;
} else if (t <= 6.5e-28) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (t - x) * (y / (a - z)) t_2 = t * ((y - z) / (a - z)) tmp = 0 if t <= -8.4e-97: tmp = t_2 elif t <= 4.9e-237: tmp = t_1 elif t <= 3.8e-100: tmp = x elif t <= 6.5e-28: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(t - x) * Float64(y / Float64(a - z))) t_2 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (t <= -8.4e-97) tmp = t_2; elseif (t <= 4.9e-237) tmp = t_1; elseif (t <= 3.8e-100) tmp = x; elseif (t <= 6.5e-28) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (t - x) * (y / (a - z)); t_2 = t * ((y - z) / (a - z)); tmp = 0.0; if (t <= -8.4e-97) tmp = t_2; elseif (t <= 4.9e-237) tmp = t_1; elseif (t <= 3.8e-100) tmp = x; elseif (t <= 6.5e-28) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8.4e-97], t$95$2, If[LessEqual[t, 4.9e-237], t$95$1, If[LessEqual[t, 3.8e-100], x, If[LessEqual[t, 6.5e-28], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(t - x\right) \cdot \frac{y}{a - z}\\
t_2 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;t \leq -8.4 \cdot 10^{-97}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq 4.9 \cdot 10^{-237}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{-100}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 6.5 \cdot 10^{-28}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -8.4000000000000005e-97 or 6.50000000000000043e-28 < t Initial program 84.3%
associate-*r/63.1%
clear-num63.1%
Applied egg-rr63.1%
Taylor expanded in x around 0 50.4%
*-commutative50.4%
associate-/l*63.4%
associate-/r/67.6%
*-commutative67.6%
Simplified67.6%
if -8.4000000000000005e-97 < t < 4.9000000000000001e-237 or 3.79999999999999997e-100 < t < 6.50000000000000043e-28Initial program 72.7%
Taylor expanded in y around inf 49.8%
div-sub49.8%
associate-*r/51.1%
associate-/l*49.9%
associate-/r/53.4%
Simplified53.4%
if 4.9000000000000001e-237 < t < 3.79999999999999997e-100Initial program 64.0%
Taylor expanded in a around inf 44.8%
Final simplification61.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))))
(if (<= t -1e-95)
t_1
(if (<= t 5.2e-240)
(* (- t x) (/ y (- a z)))
(if (<= t 1.5e-99)
x
(if (<= t 2e-20) (* (- t x) (/ (- a y) z)) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (t <= -1e-95) {
tmp = t_1;
} else if (t <= 5.2e-240) {
tmp = (t - x) * (y / (a - z));
} else if (t <= 1.5e-99) {
tmp = x;
} else if (t <= 2e-20) {
tmp = (t - x) * ((a - y) / z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
if (t <= (-1d-95)) then
tmp = t_1
else if (t <= 5.2d-240) then
tmp = (t - x) * (y / (a - z))
else if (t <= 1.5d-99) then
tmp = x
else if (t <= 2d-20) then
tmp = (t - x) * ((a - y) / z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (t <= -1e-95) {
tmp = t_1;
} else if (t <= 5.2e-240) {
tmp = (t - x) * (y / (a - z));
} else if (t <= 1.5e-99) {
tmp = x;
} else if (t <= 2e-20) {
tmp = (t - x) * ((a - y) / z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) tmp = 0 if t <= -1e-95: tmp = t_1 elif t <= 5.2e-240: tmp = (t - x) * (y / (a - z)) elif t <= 1.5e-99: tmp = x elif t <= 2e-20: tmp = (t - x) * ((a - y) / z) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (t <= -1e-95) tmp = t_1; elseif (t <= 5.2e-240) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); elseif (t <= 1.5e-99) tmp = x; elseif (t <= 2e-20) tmp = Float64(Float64(t - x) * Float64(Float64(a - y) / z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); tmp = 0.0; if (t <= -1e-95) tmp = t_1; elseif (t <= 5.2e-240) tmp = (t - x) * (y / (a - z)); elseif (t <= 1.5e-99) tmp = x; elseif (t <= 2e-20) tmp = (t - x) * ((a - y) / z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1e-95], t$95$1, If[LessEqual[t, 5.2e-240], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.5e-99], x, If[LessEqual[t, 2e-20], N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;t \leq -1 \cdot 10^{-95}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 5.2 \cdot 10^{-240}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{elif}\;t \leq 1.5 \cdot 10^{-99}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-20}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{a - y}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -9.99999999999999989e-96 or 1.99999999999999989e-20 < t Initial program 84.2%
associate-*r/62.8%
clear-num62.8%
Applied egg-rr62.8%
Taylor expanded in x around 0 50.1%
*-commutative50.1%
associate-/l*63.1%
associate-/r/67.4%
*-commutative67.4%
Simplified67.4%
if -9.99999999999999989e-96 < t < 5.19999999999999984e-240Initial program 74.0%
Taylor expanded in y around inf 48.7%
div-sub48.7%
associate-*r/50.3%
associate-/l*48.8%
associate-/r/53.0%
Simplified53.0%
if 5.19999999999999984e-240 < t < 1.50000000000000003e-99Initial program 64.0%
Taylor expanded in a around inf 44.8%
if 1.50000000000000003e-99 < t < 1.99999999999999989e-20Initial program 68.0%
Taylor expanded in z around inf 59.2%
associate--l+59.2%
distribute-lft-out--59.2%
div-sub59.2%
mul-1-neg59.2%
unsub-neg59.2%
distribute-rgt-out--59.2%
associate-/l*67.1%
Simplified67.1%
Taylor expanded in z around 0 51.1%
mul-1-neg51.1%
*-commutative51.1%
associate-*l/58.8%
distribute-lft-neg-in58.8%
distribute-neg-frac58.8%
Simplified58.8%
Taylor expanded in y around 0 58.8%
+-commutative58.8%
mul-1-neg58.8%
sub-neg58.8%
div-sub58.8%
Simplified58.8%
Final simplification61.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- t x) (/ y a)))))
(if (<= a -7.9)
t_1
(if (<= a 5.6e-124)
(+ t (/ (* y (- x t)) z))
(if (<= a 1.04e-85)
t_1
(if (<= a 1.25e+38)
(+ t (/ (* x y) z))
(+ x (/ y (/ a (- t x))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) * (y / a));
double tmp;
if (a <= -7.9) {
tmp = t_1;
} else if (a <= 5.6e-124) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 1.04e-85) {
tmp = t_1;
} else if (a <= 1.25e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = x + ((t - x) * (y / a))
if (a <= (-7.9d0)) then
tmp = t_1
else if (a <= 5.6d-124) then
tmp = t + ((y * (x - t)) / z)
else if (a <= 1.04d-85) then
tmp = t_1
else if (a <= 1.25d+38) then
tmp = t + ((x * y) / z)
else
tmp = x + (y / (a / (t - x)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) * (y / a));
double tmp;
if (a <= -7.9) {
tmp = t_1;
} else if (a <= 5.6e-124) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 1.04e-85) {
tmp = t_1;
} else if (a <= 1.25e+38) {
tmp = t + ((x * y) / z);
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((t - x) * (y / a)) tmp = 0 if a <= -7.9: tmp = t_1 elif a <= 5.6e-124: tmp = t + ((y * (x - t)) / z) elif a <= 1.04e-85: tmp = t_1 elif a <= 1.25e+38: tmp = t + ((x * y) / z) else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(t - x) * Float64(y / a))) tmp = 0.0 if (a <= -7.9) tmp = t_1; elseif (a <= 5.6e-124) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (a <= 1.04e-85) tmp = t_1; elseif (a <= 1.25e+38) tmp = Float64(t + Float64(Float64(x * y) / z)); else tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((t - x) * (y / a)); tmp = 0.0; if (a <= -7.9) tmp = t_1; elseif (a <= 5.6e-124) tmp = t + ((y * (x - t)) / z); elseif (a <= 1.04e-85) tmp = t_1; elseif (a <= 1.25e+38) tmp = t + ((x * y) / z); else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -7.9], t$95$1, If[LessEqual[a, 5.6e-124], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.04e-85], t$95$1, If[LessEqual[a, 1.25e+38], N[(t + N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -7.9:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-124}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;a \leq 1.04 \cdot 10^{-85}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{+38}:\\
\;\;\;\;t + \frac{x \cdot y}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if a < -7.9000000000000004 or 5.59999999999999996e-124 < a < 1.04e-85Initial program 88.4%
Taylor expanded in z around 0 59.4%
associate-/l*67.7%
associate-/r/69.9%
Simplified69.9%
if -7.9000000000000004 < a < 5.59999999999999996e-124Initial program 68.6%
Taylor expanded in z around inf 79.4%
associate--l+79.4%
distribute-lft-out--79.4%
div-sub80.6%
mul-1-neg80.6%
unsub-neg80.6%
distribute-rgt-out--80.6%
associate-/l*84.0%
Simplified84.0%
Taylor expanded in y around inf 75.5%
if 1.04e-85 < a < 1.24999999999999992e38Initial program 70.8%
Taylor expanded in z around inf 66.1%
associate--l+66.1%
distribute-lft-out--66.1%
div-sub66.1%
mul-1-neg66.1%
unsub-neg66.1%
distribute-rgt-out--66.1%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in y around inf 61.7%
Taylor expanded in t around 0 66.6%
mul-1-neg66.6%
distribute-lft-neg-out66.6%
*-commutative66.6%
Simplified66.6%
if 1.24999999999999992e38 < a Initial program 84.6%
Taylor expanded in z around 0 59.5%
associate-/l*67.7%
Simplified67.7%
Final simplification71.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))))
(if (<= t -2.25e-123)
t_1
(if (<= t 2.5e-240) (* (- x) (/ y (- a z))) (if (<= t 4.5e-169) x t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (t <= -2.25e-123) {
tmp = t_1;
} else if (t <= 2.5e-240) {
tmp = -x * (y / (a - z));
} else if (t <= 4.5e-169) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
if (t <= (-2.25d-123)) then
tmp = t_1
else if (t <= 2.5d-240) then
tmp = -x * (y / (a - z))
else if (t <= 4.5d-169) then
tmp = x
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (t <= -2.25e-123) {
tmp = t_1;
} else if (t <= 2.5e-240) {
tmp = -x * (y / (a - z));
} else if (t <= 4.5e-169) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) tmp = 0 if t <= -2.25e-123: tmp = t_1 elif t <= 2.5e-240: tmp = -x * (y / (a - z)) elif t <= 4.5e-169: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (t <= -2.25e-123) tmp = t_1; elseif (t <= 2.5e-240) tmp = Float64(Float64(-x) * Float64(y / Float64(a - z))); elseif (t <= 4.5e-169) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); tmp = 0.0; if (t <= -2.25e-123) tmp = t_1; elseif (t <= 2.5e-240) tmp = -x * (y / (a - z)); elseif (t <= 4.5e-169) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.25e-123], t$95$1, If[LessEqual[t, 2.5e-240], N[((-x) * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.5e-169], x, t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;t \leq -2.25 \cdot 10^{-123}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2.5 \cdot 10^{-240}:\\
\;\;\;\;\left(-x\right) \cdot \frac{y}{a - z}\\
\mathbf{elif}\;t \leq 4.5 \cdot 10^{-169}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.24999999999999997e-123 or 4.4999999999999999e-169 < t Initial program 80.6%
associate-*r/63.3%
clear-num63.3%
Applied egg-rr63.3%
Taylor expanded in x around 0 48.1%
*-commutative48.1%
associate-/l*57.8%
associate-/r/63.0%
*-commutative63.0%
Simplified63.0%
if -2.24999999999999997e-123 < t < 2.5000000000000002e-240Initial program 76.3%
Taylor expanded in y around inf 50.1%
div-sub50.1%
associate-*r/51.8%
associate-/l*50.2%
associate-/r/53.2%
Simplified53.2%
Taylor expanded in t around 0 47.1%
associate-*r/47.1%
mul-1-neg47.1%
distribute-lft-neg-out47.1%
associate-*r/48.5%
distribute-lft-neg-out48.5%
distribute-rgt-neg-in48.5%
Simplified48.5%
if 2.5000000000000002e-240 < t < 4.4999999999999999e-169Initial program 69.9%
Taylor expanded in a around inf 47.6%
Final simplification58.8%
(FPCore (x y z t a)
:precision binary64
(if (<= a -4.8e+99)
x
(if (<= a 2.55e+38)
(* t (- 1.0 (/ y z)))
(if (<= a 2.8e+91) (* t (/ y (- a z))) (if (<= a 1.12e+96) t x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4.8e+99) {
tmp = x;
} else if (a <= 2.55e+38) {
tmp = t * (1.0 - (y / z));
} else if (a <= 2.8e+91) {
tmp = t * (y / (a - z));
} else if (a <= 1.12e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-4.8d+99)) then
tmp = x
else if (a <= 2.55d+38) then
tmp = t * (1.0d0 - (y / z))
else if (a <= 2.8d+91) then
tmp = t * (y / (a - z))
else if (a <= 1.12d+96) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4.8e+99) {
tmp = x;
} else if (a <= 2.55e+38) {
tmp = t * (1.0 - (y / z));
} else if (a <= 2.8e+91) {
tmp = t * (y / (a - z));
} else if (a <= 1.12e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -4.8e+99: tmp = x elif a <= 2.55e+38: tmp = t * (1.0 - (y / z)) elif a <= 2.8e+91: tmp = t * (y / (a - z)) elif a <= 1.12e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -4.8e+99) tmp = x; elseif (a <= 2.55e+38) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (a <= 2.8e+91) tmp = Float64(t * Float64(y / Float64(a - z))); elseif (a <= 1.12e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -4.8e+99) tmp = x; elseif (a <= 2.55e+38) tmp = t * (1.0 - (y / z)); elseif (a <= 2.8e+91) tmp = t * (y / (a - z)); elseif (a <= 1.12e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -4.8e+99], x, If[LessEqual[a, 2.55e+38], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e+91], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.12e+96], t, x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4.8 \cdot 10^{+99}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 2.55 \cdot 10^{+38}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{+91}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -4.8000000000000002e99 or 1.1199999999999999e96 < a Initial program 87.1%
Taylor expanded in a around inf 53.7%
if -4.8000000000000002e99 < a < 2.5500000000000001e38Initial program 73.2%
Taylor expanded in z around inf 65.7%
associate--l+65.7%
distribute-lft-out--65.7%
div-sub66.4%
mul-1-neg66.4%
unsub-neg66.4%
distribute-rgt-out--66.4%
associate-/l*71.2%
Simplified71.2%
Taylor expanded in y around inf 62.6%
Taylor expanded in t around inf 49.8%
if 2.5500000000000001e38 < a < 2.7999999999999999e91Initial program 82.0%
Taylor expanded in y around inf 51.9%
div-sub51.9%
associate-*r/51.8%
associate-/l*51.7%
associate-/r/51.7%
Simplified51.7%
Taylor expanded in t around inf 39.3%
associate-*r/39.2%
Simplified39.2%
if 2.7999999999999999e91 < a < 1.1199999999999999e96Initial program 100.0%
Taylor expanded in z around inf 100.0%
Final simplification50.9%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3250000.0)
x
(if (<= a 3.3e-225)
t
(if (<= a 4.5e-47) (* y (/ x z)) (if (<= a 2.4e+38) t x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3250000.0) {
tmp = x;
} else if (a <= 3.3e-225) {
tmp = t;
} else if (a <= 4.5e-47) {
tmp = y * (x / z);
} else if (a <= 2.4e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-3250000.0d0)) then
tmp = x
else if (a <= 3.3d-225) then
tmp = t
else if (a <= 4.5d-47) then
tmp = y * (x / z)
else if (a <= 2.4d+38) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3250000.0) {
tmp = x;
} else if (a <= 3.3e-225) {
tmp = t;
} else if (a <= 4.5e-47) {
tmp = y * (x / z);
} else if (a <= 2.4e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3250000.0: tmp = x elif a <= 3.3e-225: tmp = t elif a <= 4.5e-47: tmp = y * (x / z) elif a <= 2.4e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3250000.0) tmp = x; elseif (a <= 3.3e-225) tmp = t; elseif (a <= 4.5e-47) tmp = Float64(y * Float64(x / z)); elseif (a <= 2.4e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3250000.0) tmp = x; elseif (a <= 3.3e-225) tmp = t; elseif (a <= 4.5e-47) tmp = y * (x / z); elseif (a <= 2.4e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3250000.0], x, If[LessEqual[a, 3.3e-225], t, If[LessEqual[a, 4.5e-47], N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.4e+38], t, x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3250000:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 3.3 \cdot 10^{-225}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 4.5 \cdot 10^{-47}:\\
\;\;\;\;y \cdot \frac{x}{z}\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -3.25e6 or 2.40000000000000017e38 < a Initial program 86.7%
Taylor expanded in a around inf 42.7%
if -3.25e6 < a < 3.3000000000000001e-225 or 4.5e-47 < a < 2.40000000000000017e38Initial program 70.3%
Taylor expanded in z around inf 43.6%
if 3.3000000000000001e-225 < a < 4.5e-47Initial program 71.1%
Taylor expanded in z around inf 65.3%
associate--l+65.3%
distribute-lft-out--65.3%
div-sub65.3%
mul-1-neg65.3%
unsub-neg65.3%
distribute-rgt-out--65.3%
associate-/l*72.3%
Simplified72.3%
Taylor expanded in t around 0 47.9%
associate-/l*48.0%
associate-/r/47.8%
Simplified47.8%
Taylor expanded in y around inf 41.5%
associate-*l/41.6%
*-commutative41.6%
Simplified41.6%
Final simplification42.9%
(FPCore (x y z t a) :precision binary64 (if (<= a -8.8e+98) x (if (<= a 1.65e+38) (* t (- 1.0 (/ y z))) x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -8.8e+98) {
tmp = x;
} else if (a <= 1.65e+38) {
tmp = t * (1.0 - (y / z));
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-8.8d+98)) then
tmp = x
else if (a <= 1.65d+38) then
tmp = t * (1.0d0 - (y / z))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -8.8e+98) {
tmp = x;
} else if (a <= 1.65e+38) {
tmp = t * (1.0 - (y / z));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -8.8e+98: tmp = x elif a <= 1.65e+38: tmp = t * (1.0 - (y / z)) else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -8.8e+98) tmp = x; elseif (a <= 1.65e+38) tmp = Float64(t * Float64(1.0 - Float64(y / z))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -8.8e+98) tmp = x; elseif (a <= 1.65e+38) tmp = t * (1.0 - (y / z)); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -8.8e+98], x, If[LessEqual[a, 1.65e+38], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -8.8 \cdot 10^{+98}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{+38}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -8.80000000000000034e98 or 1.65e38 < a Initial program 86.6%
Taylor expanded in a around inf 48.6%
if -8.80000000000000034e98 < a < 1.65e38Initial program 73.2%
Taylor expanded in z around inf 65.7%
associate--l+65.7%
distribute-lft-out--65.7%
div-sub66.4%
mul-1-neg66.4%
unsub-neg66.4%
distribute-rgt-out--66.4%
associate-/l*71.2%
Simplified71.2%
Taylor expanded in y around inf 62.6%
Taylor expanded in t around inf 49.8%
Final simplification49.3%
(FPCore (x y z t a) :precision binary64 (if (<= a -275000.0) x (if (<= a 2.05e+38) t x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -275000.0) {
tmp = x;
} else if (a <= 2.05e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a <= (-275000.0d0)) then
tmp = x
else if (a <= 2.05d+38) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -275000.0) {
tmp = x;
} else if (a <= 2.05e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -275000.0: tmp = x elif a <= 2.05e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -275000.0) tmp = x; elseif (a <= 2.05e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -275000.0) tmp = x; elseif (a <= 2.05e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -275000.0], x, If[LessEqual[a, 2.05e+38], t, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -275000:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 2.05 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -275000 or 2.0500000000000002e38 < a Initial program 86.7%
Taylor expanded in a around inf 42.7%
if -275000 < a < 2.0500000000000002e38Initial program 70.5%
Taylor expanded in z around inf 38.4%
Final simplification40.7%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
real(8) function code(x, y, z, t, a)
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
code = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 79.0%
Taylor expanded in z around inf 24.6%
Final simplification24.6%
herbie shell --seed 2024027
(FPCore (x y z t a)
:name "Numeric.Signal:interpolate from hsignal-0.2.7.1"
:precision binary64
(+ x (* (- y z) (/ (- t x) (- a z)))))