
(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(Float64(y - z) * 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[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 28 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(Float64(y - z) * 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[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
(FPCore (x y z t a) :precision binary64 (if (or (<= z -6e+71) (not (<= z 4.5e+165))) (+ t (/ (- x t) (/ z (- y a)))) (+ x (/ 1.0 (/ (/ (- a z) (- y z)) (- t x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6e+71) || !(z <= 4.5e+165)) {
tmp = t + ((x - t) / (z / (y - a)));
} else {
tmp = x + (1.0 / (((a - z) / (y - z)) / (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) :: tmp
if ((z <= (-6d+71)) .or. (.not. (z <= 4.5d+165))) then
tmp = t + ((x - t) / (z / (y - a)))
else
tmp = x + (1.0d0 / (((a - z) / (y - z)) / (t - x)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6e+71) || !(z <= 4.5e+165)) {
tmp = t + ((x - t) / (z / (y - a)));
} else {
tmp = x + (1.0 / (((a - z) / (y - z)) / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -6e+71) or not (z <= 4.5e+165): tmp = t + ((x - t) / (z / (y - a))) else: tmp = x + (1.0 / (((a - z) / (y - z)) / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -6e+71) || !(z <= 4.5e+165)) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); else tmp = Float64(x + Float64(1.0 / Float64(Float64(Float64(a - z) / Float64(y - z)) / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -6e+71) || ~((z <= 4.5e+165))) tmp = t + ((x - t) / (z / (y - a))); else tmp = x + (1.0 / (((a - z) / (y - z)) / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -6e+71], N[Not[LessEqual[z, 4.5e+165]], $MachinePrecision]], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(1.0 / N[(N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6 \cdot 10^{+71} \lor \neg \left(z \leq 4.5 \cdot 10^{+165}\right):\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{1}{\frac{\frac{a - z}{y - z}}{t - x}}\\
\end{array}
\end{array}
if z < -6.00000000000000025e71 or 4.4999999999999996e165 < z Initial program 25.7%
associate-*l/57.2%
Simplified57.2%
Taylor expanded in z around inf 62.8%
associate--l+62.8%
associate-*r/62.8%
associate-*r/62.8%
div-sub62.8%
distribute-lft-out--62.8%
associate-*r/62.8%
mul-1-neg62.8%
distribute-rgt-out--62.9%
unsub-neg62.9%
associate-/l*85.1%
Simplified85.1%
if -6.00000000000000025e71 < z < 4.4999999999999996e165Initial program 83.7%
associate-*l/93.8%
Simplified93.8%
associate-*l/83.7%
clear-num83.7%
associate-/r*93.9%
Applied egg-rr93.9%
Final simplification91.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- t x) (/ y a))))
(if (<= a -1.8e+109)
x
(if (<= a -17.0)
t_1
(if (<= a 4.8e-243)
(- t (* t (/ y z)))
(if (<= a 2.3e-50)
(/ (* x (- y a)) z)
(if (<= a 1.3e+24)
(/ (- t) (/ (- a z) z))
(if (<= a 2.1e+91)
t_1
(if (<= a 1.12e+96)
t
(if (<= a 4.6e+132)
x
(if (<= a 1.28e+163)
(* (- y z) (/ t a))
(if (<= a 1.35e+164) (* x (/ (- y a) z)) x))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - x) * (y / a);
double tmp;
if (a <= -1.8e+109) {
tmp = x;
} else if (a <= -17.0) {
tmp = t_1;
} else if (a <= 4.8e-243) {
tmp = t - (t * (y / z));
} else if (a <= 2.3e-50) {
tmp = (x * (y - a)) / z;
} else if (a <= 1.3e+24) {
tmp = -t / ((a - z) / z);
} else if (a <= 2.1e+91) {
tmp = t_1;
} else if (a <= 1.12e+96) {
tmp = t;
} else if (a <= 4.6e+132) {
tmp = x;
} else if (a <= 1.28e+163) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = x * ((y - a) / 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 = (t - x) * (y / a)
if (a <= (-1.8d+109)) then
tmp = x
else if (a <= (-17.0d0)) then
tmp = t_1
else if (a <= 4.8d-243) then
tmp = t - (t * (y / z))
else if (a <= 2.3d-50) then
tmp = (x * (y - a)) / z
else if (a <= 1.3d+24) then
tmp = -t / ((a - z) / z)
else if (a <= 2.1d+91) then
tmp = t_1
else if (a <= 1.12d+96) then
tmp = t
else if (a <= 4.6d+132) then
tmp = x
else if (a <= 1.28d+163) then
tmp = (y - z) * (t / a)
else if (a <= 1.35d+164) then
tmp = x * ((y - a) / 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 = (t - x) * (y / a);
double tmp;
if (a <= -1.8e+109) {
tmp = x;
} else if (a <= -17.0) {
tmp = t_1;
} else if (a <= 4.8e-243) {
tmp = t - (t * (y / z));
} else if (a <= 2.3e-50) {
tmp = (x * (y - a)) / z;
} else if (a <= 1.3e+24) {
tmp = -t / ((a - z) / z);
} else if (a <= 2.1e+91) {
tmp = t_1;
} else if (a <= 1.12e+96) {
tmp = t;
} else if (a <= 4.6e+132) {
tmp = x;
} else if (a <= 1.28e+163) {
tmp = (y - z) * (t / a);
} else if (a <= 1.35e+164) {
tmp = x * ((y - a) / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (t - x) * (y / a) tmp = 0 if a <= -1.8e+109: tmp = x elif a <= -17.0: tmp = t_1 elif a <= 4.8e-243: tmp = t - (t * (y / z)) elif a <= 2.3e-50: tmp = (x * (y - a)) / z elif a <= 1.3e+24: tmp = -t / ((a - z) / z) elif a <= 2.1e+91: tmp = t_1 elif a <= 1.12e+96: tmp = t elif a <= 4.6e+132: tmp = x elif a <= 1.28e+163: tmp = (y - z) * (t / a) elif a <= 1.35e+164: tmp = x * ((y - a) / z) else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(t - x) * Float64(y / a)) tmp = 0.0 if (a <= -1.8e+109) tmp = x; elseif (a <= -17.0) tmp = t_1; elseif (a <= 4.8e-243) tmp = Float64(t - Float64(t * Float64(y / z))); elseif (a <= 2.3e-50) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (a <= 1.3e+24) tmp = Float64(Float64(-t) / Float64(Float64(a - z) / z)); elseif (a <= 2.1e+91) tmp = t_1; elseif (a <= 1.12e+96) tmp = t; elseif (a <= 4.6e+132) tmp = x; elseif (a <= 1.28e+163) tmp = Float64(Float64(y - z) * Float64(t / a)); elseif (a <= 1.35e+164) tmp = Float64(x * Float64(Float64(y - a) / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (t - x) * (y / a); tmp = 0.0; if (a <= -1.8e+109) tmp = x; elseif (a <= -17.0) tmp = t_1; elseif (a <= 4.8e-243) tmp = t - (t * (y / z)); elseif (a <= 2.3e-50) tmp = (x * (y - a)) / z; elseif (a <= 1.3e+24) tmp = -t / ((a - z) / z); elseif (a <= 2.1e+91) tmp = t_1; elseif (a <= 1.12e+96) tmp = t; elseif (a <= 4.6e+132) tmp = x; elseif (a <= 1.28e+163) tmp = (y - z) * (t / a); elseif (a <= 1.35e+164) tmp = x * ((y - a) / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.8e+109], x, If[LessEqual[a, -17.0], t$95$1, If[LessEqual[a, 4.8e-243], N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.3e-50], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[a, 1.3e+24], N[((-t) / N[(N[(a - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.1e+91], t$95$1, If[LessEqual[a, 1.12e+96], t, If[LessEqual[a, 4.6e+132], x, If[LessEqual[a, 1.28e+163], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+164], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], x]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -1.8 \cdot 10^{+109}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -17:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 4.8 \cdot 10^{-243}:\\
\;\;\;\;t - t \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 2.3 \cdot 10^{-50}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;a \leq 1.3 \cdot 10^{+24}:\\
\;\;\;\;\frac{-t}{\frac{a - z}{z}}\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{+132}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.28 \cdot 10^{+163}:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+164}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.8e109 or 1.1199999999999999e96 < a < 4.6000000000000003e132 or 1.35000000000000003e164 < a Initial program 62.5%
associate-*l/90.3%
Simplified90.3%
Taylor expanded in a around inf 59.3%
if -1.8e109 < a < -17 or 1.2999999999999999e24 < a < 2.10000000000000008e91Initial program 78.7%
associate-*l/87.5%
Simplified87.5%
Taylor expanded in y around -inf 53.3%
associate-*l/57.0%
Simplified57.0%
Taylor expanded in a around inf 49.4%
if -17 < a < 4.8000000000000002e-243Initial program 64.9%
associate-*l/76.7%
Simplified76.7%
Taylor expanded in x around 0 57.1%
Taylor expanded in a around 0 52.3%
associate-*r/52.3%
*-commutative52.3%
neg-mul-152.3%
distribute-rgt-neg-in52.3%
Simplified52.3%
Taylor expanded in y around 0 61.4%
mul-1-neg61.4%
unsub-neg61.4%
*-commutative61.4%
associate-*l/65.3%
*-commutative65.3%
Simplified65.3%
if 4.8000000000000002e-243 < a < 2.3000000000000002e-50Initial program 71.1%
associate-*l/73.9%
Simplified73.9%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
associate-*r/72.6%
associate-*r/72.6%
div-sub72.6%
distribute-lft-out--72.6%
associate-*r/72.6%
mul-1-neg72.6%
distribute-rgt-out--72.6%
unsub-neg72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
if 2.3000000000000002e-50 < a < 1.2999999999999999e24Initial program 47.3%
associate-*l/72.3%
Simplified72.3%
Taylor expanded in x around 0 39.7%
Taylor expanded in y around 0 39.0%
mul-1-neg39.0%
associate-/l*59.1%
Simplified59.1%
if 2.10000000000000008e91 < a < 1.1199999999999999e96Initial program 56.8%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in z around inf 100.0%
if 4.6000000000000003e132 < a < 1.28e163Initial program 65.8%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in x around 0 53.2%
associate-/l*83.6%
Simplified83.6%
Taylor expanded in a around inf 53.2%
associate-/l*68.0%
associate-/r/68.5%
Simplified68.5%
if 1.28e163 < a < 1.35000000000000003e164Initial program 4.7%
associate-*l/2.2%
Simplified2.2%
Taylor expanded in z around inf 4.7%
associate--l+4.7%
associate-*r/4.7%
associate-*r/4.7%
div-sub4.7%
distribute-lft-out--4.7%
associate-*r/4.7%
mul-1-neg4.7%
distribute-rgt-out--4.7%
unsub-neg4.7%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in t around 0 4.7%
associate-*r/100.0%
Simplified100.0%
Final simplification58.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (- t x) (/ y (- a z)))) (t_2 (* t (/ (- y z) (- a z)))))
(if (<= z -2.8e-26)
t_2
(if (<= z -6.8e-89)
t_1
(if (<= z -3e-125)
(/ (- t) (/ (- a z) z))
(if (<= z -1.35e-201)
(* y (/ (- t x) (- a z)))
(if (<= z -1.22e-263)
t_1
(if (<= z 5.6e-26)
(* x (+ (/ (- z y) a) 1.0))
(if (<= z 7.5e+148) t_2 (- t (/ a (/ z x))))))))))))
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 (z <= -2.8e-26) {
tmp = t_2;
} else if (z <= -6.8e-89) {
tmp = t_1;
} else if (z <= -3e-125) {
tmp = -t / ((a - z) / z);
} else if (z <= -1.35e-201) {
tmp = y * ((t - x) / (a - z));
} else if (z <= -1.22e-263) {
tmp = t_1;
} else if (z <= 5.6e-26) {
tmp = x * (((z - y) / a) + 1.0);
} else if (z <= 7.5e+148) {
tmp = t_2;
} else {
tmp = t - (a / (z / 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) :: t_2
real(8) :: tmp
t_1 = (t - x) * (y / (a - z))
t_2 = t * ((y - z) / (a - z))
if (z <= (-2.8d-26)) then
tmp = t_2
else if (z <= (-6.8d-89)) then
tmp = t_1
else if (z <= (-3d-125)) then
tmp = -t / ((a - z) / z)
else if (z <= (-1.35d-201)) then
tmp = y * ((t - x) / (a - z))
else if (z <= (-1.22d-263)) then
tmp = t_1
else if (z <= 5.6d-26) then
tmp = x * (((z - y) / a) + 1.0d0)
else if (z <= 7.5d+148) then
tmp = t_2
else
tmp = t - (a / (z / x))
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 (z <= -2.8e-26) {
tmp = t_2;
} else if (z <= -6.8e-89) {
tmp = t_1;
} else if (z <= -3e-125) {
tmp = -t / ((a - z) / z);
} else if (z <= -1.35e-201) {
tmp = y * ((t - x) / (a - z));
} else if (z <= -1.22e-263) {
tmp = t_1;
} else if (z <= 5.6e-26) {
tmp = x * (((z - y) / a) + 1.0);
} else if (z <= 7.5e+148) {
tmp = t_2;
} else {
tmp = t - (a / (z / x));
}
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 z <= -2.8e-26: tmp = t_2 elif z <= -6.8e-89: tmp = t_1 elif z <= -3e-125: tmp = -t / ((a - z) / z) elif z <= -1.35e-201: tmp = y * ((t - x) / (a - z)) elif z <= -1.22e-263: tmp = t_1 elif z <= 5.6e-26: tmp = x * (((z - y) / a) + 1.0) elif z <= 7.5e+148: tmp = t_2 else: tmp = t - (a / (z / x)) 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 (z <= -2.8e-26) tmp = t_2; elseif (z <= -6.8e-89) tmp = t_1; elseif (z <= -3e-125) tmp = Float64(Float64(-t) / Float64(Float64(a - z) / z)); elseif (z <= -1.35e-201) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (z <= -1.22e-263) tmp = t_1; elseif (z <= 5.6e-26) tmp = Float64(x * Float64(Float64(Float64(z - y) / a) + 1.0)); elseif (z <= 7.5e+148) tmp = t_2; else tmp = Float64(t - Float64(a / Float64(z / x))); 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 (z <= -2.8e-26) tmp = t_2; elseif (z <= -6.8e-89) tmp = t_1; elseif (z <= -3e-125) tmp = -t / ((a - z) / z); elseif (z <= -1.35e-201) tmp = y * ((t - x) / (a - z)); elseif (z <= -1.22e-263) tmp = t_1; elseif (z <= 5.6e-26) tmp = x * (((z - y) / a) + 1.0); elseif (z <= 7.5e+148) tmp = t_2; else tmp = t - (a / (z / x)); 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[z, -2.8e-26], t$95$2, If[LessEqual[z, -6.8e-89], t$95$1, If[LessEqual[z, -3e-125], N[((-t) / N[(N[(a - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.35e-201], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.22e-263], t$95$1, If[LessEqual[z, 5.6e-26], N[(x * N[(N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.5e+148], t$95$2, N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\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}\;z \leq -2.8 \cdot 10^{-26}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -6.8 \cdot 10^{-89}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-125}:\\
\;\;\;\;\frac{-t}{\frac{a - z}{z}}\\
\mathbf{elif}\;z \leq -1.35 \cdot 10^{-201}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;z \leq -1.22 \cdot 10^{-263}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 5.6 \cdot 10^{-26}:\\
\;\;\;\;x \cdot \left(\frac{z - y}{a} + 1\right)\\
\mathbf{elif}\;z \leq 7.5 \cdot 10^{+148}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\end{array}
\end{array}
if z < -2.8000000000000001e-26 or 5.6000000000000002e-26 < z < 7.50000000000000008e148Initial program 56.8%
associate-*l/77.5%
Simplified77.5%
Taylor expanded in x around 0 42.5%
associate-/l*57.8%
div-inv57.8%
clear-num57.8%
Applied egg-rr57.8%
if -2.8000000000000001e-26 < z < -6.8000000000000001e-89 or -1.35000000000000003e-201 < z < -1.22000000000000005e-263Initial program 84.0%
associate-*l/90.3%
Simplified90.3%
Taylor expanded in y around -inf 62.5%
associate-*l/65.6%
Simplified65.6%
if -6.8000000000000001e-89 < z < -2.9999999999999999e-125Initial program 83.2%
associate-*l/83.7%
Simplified83.7%
Taylor expanded in x around 0 83.9%
Taylor expanded in y around 0 83.9%
mul-1-neg83.9%
associate-/l*84.4%
Simplified84.4%
if -2.9999999999999999e-125 < z < -1.35000000000000003e-201Initial program 75.9%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in y around inf 70.0%
div-sub77.1%
Simplified77.1%
if -1.22000000000000005e-263 < z < 5.6000000000000002e-26Initial program 90.0%
associate-*l/98.4%
Simplified98.4%
Taylor expanded in a around inf 90.2%
Taylor expanded in x around inf 77.3%
mul-1-neg77.3%
unsub-neg77.3%
Simplified77.3%
if 7.50000000000000008e148 < z Initial program 23.0%
associate-*l/57.3%
Simplified57.3%
Taylor expanded in z around inf 56.1%
associate--l+56.1%
associate-*r/56.1%
associate-*r/56.1%
div-sub56.1%
distribute-lft-out--56.1%
associate-*r/56.1%
mul-1-neg56.1%
distribute-rgt-out--56.2%
unsub-neg56.2%
associate-/l*82.0%
Simplified82.0%
Taylor expanded in y around 0 52.3%
sub-neg52.3%
associate-*r/52.3%
associate-*r*52.3%
neg-mul-152.3%
associate-*r/68.2%
distribute-lft-neg-out68.2%
remove-double-neg68.2%
Simplified68.2%
Taylor expanded in t around 0 56.1%
mul-1-neg56.1%
associate-/l*68.6%
distribute-neg-frac68.6%
Simplified68.6%
Final simplification66.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (+ (/ (- z y) a) 1.0))) (t_2 (* t (/ (- y z) (- a z)))))
(if (<= z -2.25e-30)
t_2
(if (<= z -4.3e-88)
t_1
(if (<= z -2.3e-241)
t_2
(if (<= z 2.22e-23)
t_1
(if (<= z 6.5e+78)
t_2
(if (<= z 2.75e+104) t_1 (- t (/ a (/ z x)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (((z - y) / a) + 1.0);
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (z <= -2.25e-30) {
tmp = t_2;
} else if (z <= -4.3e-88) {
tmp = t_1;
} else if (z <= -2.3e-241) {
tmp = t_2;
} else if (z <= 2.22e-23) {
tmp = t_1;
} else if (z <= 6.5e+78) {
tmp = t_2;
} else if (z <= 2.75e+104) {
tmp = t_1;
} else {
tmp = t - (a / (z / 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) :: t_2
real(8) :: tmp
t_1 = x * (((z - y) / a) + 1.0d0)
t_2 = t * ((y - z) / (a - z))
if (z <= (-2.25d-30)) then
tmp = t_2
else if (z <= (-4.3d-88)) then
tmp = t_1
else if (z <= (-2.3d-241)) then
tmp = t_2
else if (z <= 2.22d-23) then
tmp = t_1
else if (z <= 6.5d+78) then
tmp = t_2
else if (z <= 2.75d+104) then
tmp = t_1
else
tmp = t - (a / (z / 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 * (((z - y) / a) + 1.0);
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (z <= -2.25e-30) {
tmp = t_2;
} else if (z <= -4.3e-88) {
tmp = t_1;
} else if (z <= -2.3e-241) {
tmp = t_2;
} else if (z <= 2.22e-23) {
tmp = t_1;
} else if (z <= 6.5e+78) {
tmp = t_2;
} else if (z <= 2.75e+104) {
tmp = t_1;
} else {
tmp = t - (a / (z / x));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (((z - y) / a) + 1.0) t_2 = t * ((y - z) / (a - z)) tmp = 0 if z <= -2.25e-30: tmp = t_2 elif z <= -4.3e-88: tmp = t_1 elif z <= -2.3e-241: tmp = t_2 elif z <= 2.22e-23: tmp = t_1 elif z <= 6.5e+78: tmp = t_2 elif z <= 2.75e+104: tmp = t_1 else: tmp = t - (a / (z / x)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(Float64(Float64(z - y) / a) + 1.0)) t_2 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (z <= -2.25e-30) tmp = t_2; elseif (z <= -4.3e-88) tmp = t_1; elseif (z <= -2.3e-241) tmp = t_2; elseif (z <= 2.22e-23) tmp = t_1; elseif (z <= 6.5e+78) tmp = t_2; elseif (z <= 2.75e+104) tmp = t_1; else tmp = Float64(t - Float64(a / Float64(z / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (((z - y) / a) + 1.0); t_2 = t * ((y - z) / (a - z)); tmp = 0.0; if (z <= -2.25e-30) tmp = t_2; elseif (z <= -4.3e-88) tmp = t_1; elseif (z <= -2.3e-241) tmp = t_2; elseif (z <= 2.22e-23) tmp = t_1; elseif (z <= 6.5e+78) tmp = t_2; elseif (z <= 2.75e+104) tmp = t_1; else tmp = t - (a / (z / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.25e-30], t$95$2, If[LessEqual[z, -4.3e-88], t$95$1, If[LessEqual[z, -2.3e-241], t$95$2, If[LessEqual[z, 2.22e-23], t$95$1, If[LessEqual[z, 6.5e+78], t$95$2, If[LessEqual[z, 2.75e+104], t$95$1, N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(\frac{z - y}{a} + 1\right)\\
t_2 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;z \leq -2.25 \cdot 10^{-30}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -4.3 \cdot 10^{-88}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -2.3 \cdot 10^{-241}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 2.22 \cdot 10^{-23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+78}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 2.75 \cdot 10^{+104}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\end{array}
\end{array}
if z < -2.24999999999999984e-30 or -4.2999999999999997e-88 < z < -2.2999999999999999e-241 or 2.22e-23 < z < 6.50000000000000036e78Initial program 61.2%
associate-*l/78.9%
Simplified78.9%
Taylor expanded in x around 0 46.5%
associate-/l*60.1%
div-inv60.1%
clear-num60.1%
Applied egg-rr60.1%
if -2.24999999999999984e-30 < z < -4.2999999999999997e-88 or -2.2999999999999999e-241 < z < 2.22e-23 or 6.50000000000000036e78 < z < 2.75000000000000008e104Initial program 88.4%
associate-*l/96.7%
Simplified96.7%
Taylor expanded in a around inf 84.9%
Taylor expanded in x around inf 73.1%
mul-1-neg73.1%
unsub-neg73.1%
Simplified73.1%
if 2.75000000000000008e104 < z Initial program 29.8%
associate-*l/62.6%
Simplified62.6%
Taylor expanded in z around inf 56.5%
associate--l+56.5%
associate-*r/56.5%
associate-*r/56.5%
div-sub56.5%
distribute-lft-out--56.5%
associate-*r/56.5%
mul-1-neg56.5%
distribute-rgt-out--56.6%
unsub-neg56.6%
associate-/l*80.0%
Simplified80.0%
Taylor expanded in y around 0 50.9%
sub-neg50.9%
associate-*r/50.9%
associate-*r*50.9%
neg-mul-150.9%
associate-*r/63.6%
distribute-lft-neg-out63.6%
remove-double-neg63.6%
Simplified63.6%
Taylor expanded in t around 0 51.7%
mul-1-neg51.7%
associate-/l*64.4%
distribute-neg-frac64.4%
Simplified64.4%
Final simplification65.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ (- y z) a)))) (t_2 (* t (/ (- y z) (- a z)))))
(if (<= a -8.8e+98)
t_1
(if (<= a -1.15e+43)
(* (- t x) (/ y (- a z)))
(if (<= a -1.05e+21)
t_1
(if (<= a 3.4e-223)
t_2
(if (<= a 9.5e-50)
(* y (/ (- t x) (- a z)))
(if (<= a 2.55e+38) t_2 t_1))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * ((y - z) / a));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (a <= -8.8e+98) {
tmp = t_1;
} else if (a <= -1.15e+43) {
tmp = (t - x) * (y / (a - z));
} else if (a <= -1.05e+21) {
tmp = t_1;
} else if (a <= 3.4e-223) {
tmp = t_2;
} else if (a <= 9.5e-50) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 2.55e+38) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = x + (t * ((y - z) / a))
t_2 = t * ((y - z) / (a - z))
if (a <= (-8.8d+98)) then
tmp = t_1
else if (a <= (-1.15d+43)) then
tmp = (t - x) * (y / (a - z))
else if (a <= (-1.05d+21)) then
tmp = t_1
else if (a <= 3.4d-223) then
tmp = t_2
else if (a <= 9.5d-50) then
tmp = y * ((t - x) / (a - z))
else if (a <= 2.55d+38) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * ((y - z) / a));
double t_2 = t * ((y - z) / (a - z));
double tmp;
if (a <= -8.8e+98) {
tmp = t_1;
} else if (a <= -1.15e+43) {
tmp = (t - x) * (y / (a - z));
} else if (a <= -1.05e+21) {
tmp = t_1;
} else if (a <= 3.4e-223) {
tmp = t_2;
} else if (a <= 9.5e-50) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 2.55e+38) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * ((y - z) / a)) t_2 = t * ((y - z) / (a - z)) tmp = 0 if a <= -8.8e+98: tmp = t_1 elif a <= -1.15e+43: tmp = (t - x) * (y / (a - z)) elif a <= -1.05e+21: tmp = t_1 elif a <= 3.4e-223: tmp = t_2 elif a <= 9.5e-50: tmp = y * ((t - x) / (a - z)) elif a <= 2.55e+38: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(Float64(y - z) / a))) t_2 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (a <= -8.8e+98) tmp = t_1; elseif (a <= -1.15e+43) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); elseif (a <= -1.05e+21) tmp = t_1; elseif (a <= 3.4e-223) tmp = t_2; elseif (a <= 9.5e-50) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= 2.55e+38) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * ((y - z) / a)); t_2 = t * ((y - z) / (a - z)); tmp = 0.0; if (a <= -8.8e+98) tmp = t_1; elseif (a <= -1.15e+43) tmp = (t - x) * (y / (a - z)); elseif (a <= -1.05e+21) tmp = t_1; elseif (a <= 3.4e-223) tmp = t_2; elseif (a <= 9.5e-50) tmp = y * ((t - x) / (a - z)); elseif (a <= 2.55e+38) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -8.8e+98], t$95$1, If[LessEqual[a, -1.15e+43], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.05e+21], t$95$1, If[LessEqual[a, 3.4e-223], t$95$2, If[LessEqual[a, 9.5e-50], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.55e+38], t$95$2, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y - z}{a}\\
t_2 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;a \leq -8.8 \cdot 10^{+98}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -1.15 \cdot 10^{+43}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{elif}\;a \leq -1.05 \cdot 10^{+21}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 3.4 \cdot 10^{-223}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 9.5 \cdot 10^{-50}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 2.55 \cdot 10^{+38}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -8.80000000000000034e98 or -1.1500000000000001e43 < a < -1.05e21 or 2.5500000000000001e38 < a Initial program 66.8%
associate-*l/88.7%
Simplified88.7%
Taylor expanded in a around inf 77.7%
Taylor expanded in t around inf 61.3%
associate-*r/72.3%
Simplified72.3%
if -8.80000000000000034e98 < a < -1.1500000000000001e43Initial program 64.7%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in y around -inf 56.0%
associate-*l/67.2%
Simplified67.2%
if -1.05e21 < a < 3.3999999999999998e-223 or 9.4999999999999993e-50 < a < 2.5500000000000001e38Initial program 64.0%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in x around 0 53.9%
associate-/l*65.4%
div-inv65.4%
clear-num65.4%
Applied egg-rr65.4%
if 3.3999999999999998e-223 < a < 9.4999999999999993e-50Initial program 73.1%
associate-*l/76.4%
Simplified76.4%
Taylor expanded in y around inf 64.2%
div-sub64.2%
Simplified64.2%
Final simplification68.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (/ (* y (- x t)) z))) (t_2 (+ x (* (- t x) (/ y a)))))
(if (<= a -1.2e+127)
(+ x (* t (/ (- y z) a)))
(if (<= a -2.25)
t_2
(if (<= a -2.45e-37)
(- t (/ a (/ z x)))
(if (<= a 5.6e-124)
t_1
(if (<= a 4.2e-85)
t_2
(if (<= a 2.5e+24) t_1 (+ x (/ y (/ a (- t x))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((y * (x - t)) / z);
double t_2 = x + ((t - x) * (y / a));
double tmp;
if (a <= -1.2e+127) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -2.25) {
tmp = t_2;
} else if (a <= -2.45e-37) {
tmp = t - (a / (z / x));
} else if (a <= 5.6e-124) {
tmp = t_1;
} else if (a <= 4.2e-85) {
tmp = t_2;
} else if (a <= 2.5e+24) {
tmp = t_1;
} 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) :: t_2
real(8) :: tmp
t_1 = t + ((y * (x - t)) / z)
t_2 = x + ((t - x) * (y / a))
if (a <= (-1.2d+127)) then
tmp = x + (t * ((y - z) / a))
else if (a <= (-2.25d0)) then
tmp = t_2
else if (a <= (-2.45d-37)) then
tmp = t - (a / (z / x))
else if (a <= 5.6d-124) then
tmp = t_1
else if (a <= 4.2d-85) then
tmp = t_2
else if (a <= 2.5d+24) then
tmp = t_1
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 = t + ((y * (x - t)) / z);
double t_2 = x + ((t - x) * (y / a));
double tmp;
if (a <= -1.2e+127) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -2.25) {
tmp = t_2;
} else if (a <= -2.45e-37) {
tmp = t - (a / (z / x));
} else if (a <= 5.6e-124) {
tmp = t_1;
} else if (a <= 4.2e-85) {
tmp = t_2;
} else if (a <= 2.5e+24) {
tmp = t_1;
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + ((y * (x - t)) / z) t_2 = x + ((t - x) * (y / a)) tmp = 0 if a <= -1.2e+127: tmp = x + (t * ((y - z) / a)) elif a <= -2.25: tmp = t_2 elif a <= -2.45e-37: tmp = t - (a / (z / x)) elif a <= 5.6e-124: tmp = t_1 elif a <= 4.2e-85: tmp = t_2 elif a <= 2.5e+24: tmp = t_1 else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(y * Float64(x - t)) / z)) t_2 = Float64(x + Float64(Float64(t - x) * Float64(y / a))) tmp = 0.0 if (a <= -1.2e+127) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / a))); elseif (a <= -2.25) tmp = t_2; elseif (a <= -2.45e-37) tmp = Float64(t - Float64(a / Float64(z / x))); elseif (a <= 5.6e-124) tmp = t_1; elseif (a <= 4.2e-85) tmp = t_2; elseif (a <= 2.5e+24) tmp = t_1; 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 = t + ((y * (x - t)) / z); t_2 = x + ((t - x) * (y / a)); tmp = 0.0; if (a <= -1.2e+127) tmp = x + (t * ((y - z) / a)); elseif (a <= -2.25) tmp = t_2; elseif (a <= -2.45e-37) tmp = t - (a / (z / x)); elseif (a <= 5.6e-124) tmp = t_1; elseif (a <= 4.2e-85) tmp = t_2; elseif (a <= 2.5e+24) tmp = t_1; else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.2e+127], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.25], t$95$2, If[LessEqual[a, -2.45e-37], N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.6e-124], t$95$1, If[LessEqual[a, 4.2e-85], t$95$2, If[LessEqual[a, 2.5e+24], t$95$1, N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{y \cdot \left(x - t\right)}{z}\\
t_2 := x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -1.2 \cdot 10^{+127}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a}\\
\mathbf{elif}\;a \leq -2.25:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -2.45 \cdot 10^{-37}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-124}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 4.2 \cdot 10^{-85}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 2.5 \cdot 10^{+24}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if a < -1.2000000000000001e127Initial program 59.6%
associate-*l/92.5%
Simplified92.5%
Taylor expanded in a around inf 79.7%
Taylor expanded in t around inf 57.4%
associate-*r/80.0%
Simplified80.0%
if -1.2000000000000001e127 < a < -2.25 or 5.59999999999999996e-124 < a < 4.2e-85Initial program 77.4%
associate-*l/91.1%
Simplified91.1%
Taylor expanded in z around 0 71.8%
if -2.25 < a < -2.45000000000000009e-37Initial program 56.4%
associate-*l/85.0%
Simplified85.0%
Taylor expanded in z around inf 62.2%
associate--l+62.2%
associate-*r/62.2%
associate-*r/62.2%
div-sub62.8%
distribute-lft-out--62.8%
associate-*r/62.8%
mul-1-neg62.8%
distribute-rgt-out--62.8%
unsub-neg62.8%
associate-/l*70.1%
Simplified70.1%
Taylor expanded in y around 0 71.3%
sub-neg71.3%
associate-*r/71.3%
associate-*r*71.3%
neg-mul-171.3%
associate-*r/71.3%
distribute-lft-neg-out71.3%
remove-double-neg71.3%
Simplified71.3%
Taylor expanded in t around 0 71.3%
mul-1-neg71.3%
associate-/l*71.3%
distribute-neg-frac71.3%
Simplified71.3%
if -2.45000000000000009e-37 < a < 5.59999999999999996e-124 or 4.2e-85 < a < 2.50000000000000023e24Initial program 63.0%
associate-*l/72.4%
Simplified72.4%
Taylor expanded in z around inf 79.6%
associate--l+79.6%
associate-*r/79.6%
associate-*r/79.6%
div-sub80.6%
distribute-lft-out--80.6%
associate-*r/80.6%
mul-1-neg80.6%
distribute-rgt-out--80.6%
unsub-neg80.6%
associate-/l*84.8%
Simplified84.8%
Taylor expanded in y around inf 74.8%
if 2.50000000000000023e24 < a Initial program 69.6%
associate-*l/86.6%
Simplified86.6%
Taylor expanded in z around 0 59.3%
associate-/l*67.2%
Simplified67.2%
Final simplification73.1%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.6e+156)
x
(if (<= a -410.0)
(* (- y z) (/ t a))
(if (<= a -5e-41)
t
(if (<= a -6.6e-101)
(* t (/ y (- a z)))
(if (<= a 1.85e-243)
t
(if (<= a 7.5e-55)
(* x (/ (- y a) z))
(if (<= a 2.35e+38) t x))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.6e+156) {
tmp = x;
} else if (a <= -410.0) {
tmp = (y - z) * (t / a);
} else if (a <= -5e-41) {
tmp = t;
} else if (a <= -6.6e-101) {
tmp = t * (y / (a - z));
} else if (a <= 1.85e-243) {
tmp = t;
} else if (a <= 7.5e-55) {
tmp = x * ((y - a) / z);
} else if (a <= 2.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.6d+156)) then
tmp = x
else if (a <= (-410.0d0)) then
tmp = (y - z) * (t / a)
else if (a <= (-5d-41)) then
tmp = t
else if (a <= (-6.6d-101)) then
tmp = t * (y / (a - z))
else if (a <= 1.85d-243) then
tmp = t
else if (a <= 7.5d-55) then
tmp = x * ((y - a) / z)
else if (a <= 2.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.6e+156) {
tmp = x;
} else if (a <= -410.0) {
tmp = (y - z) * (t / a);
} else if (a <= -5e-41) {
tmp = t;
} else if (a <= -6.6e-101) {
tmp = t * (y / (a - z));
} else if (a <= 1.85e-243) {
tmp = t;
} else if (a <= 7.5e-55) {
tmp = x * ((y - a) / z);
} else if (a <= 2.35e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.6e+156: tmp = x elif a <= -410.0: tmp = (y - z) * (t / a) elif a <= -5e-41: tmp = t elif a <= -6.6e-101: tmp = t * (y / (a - z)) elif a <= 1.85e-243: tmp = t elif a <= 7.5e-55: tmp = x * ((y - a) / z) elif a <= 2.35e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.6e+156) tmp = x; elseif (a <= -410.0) tmp = Float64(Float64(y - z) * Float64(t / a)); elseif (a <= -5e-41) tmp = t; elseif (a <= -6.6e-101) tmp = Float64(t * Float64(y / Float64(a - z))); elseif (a <= 1.85e-243) tmp = t; elseif (a <= 7.5e-55) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 2.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.6e+156) tmp = x; elseif (a <= -410.0) tmp = (y - z) * (t / a); elseif (a <= -5e-41) tmp = t; elseif (a <= -6.6e-101) tmp = t * (y / (a - z)); elseif (a <= 1.85e-243) tmp = t; elseif (a <= 7.5e-55) tmp = x * ((y - a) / z); elseif (a <= 2.35e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.6e+156], x, If[LessEqual[a, -410.0], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -5e-41], t, If[LessEqual[a, -6.6e-101], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.85e-243], t, If[LessEqual[a, 7.5e-55], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.35e+38], t, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.6 \cdot 10^{+156}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -410:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq -5 \cdot 10^{-41}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq -6.6 \cdot 10^{-101}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;a \leq 1.85 \cdot 10^{-243}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 7.5 \cdot 10^{-55}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.60000000000000001e156 or 2.35e38 < a Initial program 65.3%
associate-*l/89.0%
Simplified89.0%
Taylor expanded in a around inf 51.7%
if -1.60000000000000001e156 < a < -410Initial program 70.5%
associate-*l/88.6%
Simplified88.6%
Taylor expanded in x around 0 36.2%
associate-/l*49.0%
Simplified49.0%
Taylor expanded in a around inf 31.9%
associate-/l*38.4%
associate-/r/38.5%
Simplified38.5%
if -410 < a < -4.9999999999999996e-41 or -6.59999999999999968e-101 < a < 1.85e-243 or 7.50000000000000023e-55 < a < 2.35e38Initial program 60.4%
associate-*l/75.4%
Simplified75.4%
Taylor expanded in z around inf 48.3%
if -4.9999999999999996e-41 < a < -6.59999999999999968e-101Initial program 89.0%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in y around -inf 89.2%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in t around inf 67.3%
associate-*r/67.0%
Simplified67.0%
if 1.85e-243 < a < 7.50000000000000023e-55Initial program 71.1%
associate-*l/73.9%
Simplified73.9%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
associate-*r/72.6%
associate-*r/72.6%
div-sub72.6%
distribute-lft-out--72.6%
associate-*r/72.6%
mul-1-neg72.6%
distribute-rgt-out--72.6%
unsub-neg72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-*r/51.3%
Simplified51.3%
Final simplification48.9%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.1e+108)
x
(if (<= a -15.5)
(* (- t x) (/ y a))
(if (<= a -3.8e-43)
t
(if (<= a -5.4e-101)
(* t (/ y (- a z)))
(if (<= a 7.5e-244)
t
(if (<= a 1e-54) (* x (/ (- y a) z)) (if (<= a 2.1e+38) t x))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.1e+108) {
tmp = x;
} else if (a <= -15.5) {
tmp = (t - x) * (y / a);
} else if (a <= -3.8e-43) {
tmp = t;
} else if (a <= -5.4e-101) {
tmp = t * (y / (a - z));
} else if (a <= 7.5e-244) {
tmp = t;
} else if (a <= 1e-54) {
tmp = x * ((y - a) / z);
} else if (a <= 2.1e+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.1d+108)) then
tmp = x
else if (a <= (-15.5d0)) then
tmp = (t - x) * (y / a)
else if (a <= (-3.8d-43)) then
tmp = t
else if (a <= (-5.4d-101)) then
tmp = t * (y / (a - z))
else if (a <= 7.5d-244) then
tmp = t
else if (a <= 1d-54) then
tmp = x * ((y - a) / z)
else if (a <= 2.1d+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.1e+108) {
tmp = x;
} else if (a <= -15.5) {
tmp = (t - x) * (y / a);
} else if (a <= -3.8e-43) {
tmp = t;
} else if (a <= -5.4e-101) {
tmp = t * (y / (a - z));
} else if (a <= 7.5e-244) {
tmp = t;
} else if (a <= 1e-54) {
tmp = x * ((y - a) / z);
} else if (a <= 2.1e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.1e+108: tmp = x elif a <= -15.5: tmp = (t - x) * (y / a) elif a <= -3.8e-43: tmp = t elif a <= -5.4e-101: tmp = t * (y / (a - z)) elif a <= 7.5e-244: tmp = t elif a <= 1e-54: tmp = x * ((y - a) / z) elif a <= 2.1e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.1e+108) tmp = x; elseif (a <= -15.5) tmp = Float64(Float64(t - x) * Float64(y / a)); elseif (a <= -3.8e-43) tmp = t; elseif (a <= -5.4e-101) tmp = Float64(t * Float64(y / Float64(a - z))); elseif (a <= 7.5e-244) tmp = t; elseif (a <= 1e-54) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 2.1e+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.1e+108) tmp = x; elseif (a <= -15.5) tmp = (t - x) * (y / a); elseif (a <= -3.8e-43) tmp = t; elseif (a <= -5.4e-101) tmp = t * (y / (a - z)); elseif (a <= 7.5e-244) tmp = t; elseif (a <= 1e-54) tmp = x * ((y - a) / z); elseif (a <= 2.1e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.1e+108], x, If[LessEqual[a, -15.5], N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -3.8e-43], t, If[LessEqual[a, -5.4e-101], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.5e-244], t, If[LessEqual[a, 1e-54], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.1e+38], t, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.1 \cdot 10^{+108}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -15.5:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{elif}\;a \leq -3.8 \cdot 10^{-43}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq -5.4 \cdot 10^{-101}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;a \leq 7.5 \cdot 10^{-244}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 10^{-54}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.1000000000000001e108 or 2.1e38 < a Initial program 64.9%
associate-*l/88.7%
Simplified88.7%
Taylor expanded in a around inf 49.3%
if -1.1000000000000001e108 < a < -15.5Initial program 75.7%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in y around -inf 54.2%
associate-*l/60.3%
Simplified60.3%
Taylor expanded in a around inf 51.3%
if -15.5 < a < -3.7999999999999997e-43 or -5.4000000000000003e-101 < a < 7.5000000000000003e-244 or 1e-54 < a < 2.1e38Initial program 59.9%
associate-*l/75.1%
Simplified75.1%
Taylor expanded in z around inf 49.0%
if -3.7999999999999997e-43 < a < -5.4000000000000003e-101Initial program 89.0%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in y around -inf 89.2%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in t around inf 67.3%
associate-*r/67.0%
Simplified67.0%
if 7.5000000000000003e-244 < a < 1e-54Initial program 71.1%
associate-*l/73.9%
Simplified73.9%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
associate-*r/72.6%
associate-*r/72.6%
div-sub72.6%
distribute-lft-out--72.6%
associate-*r/72.6%
mul-1-neg72.6%
distribute-rgt-out--72.6%
unsub-neg72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-*r/51.3%
Simplified51.3%
Final simplification50.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* t (/ y z)))) (t_2 (* (- t x) (/ y a))))
(if (<= a -8e+107)
x
(if (<= a -10.8)
t_2
(if (<= a 2.7e-242)
t_1
(if (<= a 5.8e-55)
(* x (/ (- y a) z))
(if (<= a 4.4e+29)
t_1
(if (<= a 2.3e+91) t_2 (if (<= a 1.2e+96) t x)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (t * (y / z));
double t_2 = (t - x) * (y / a);
double tmp;
if (a <= -8e+107) {
tmp = x;
} else if (a <= -10.8) {
tmp = t_2;
} else if (a <= 2.7e-242) {
tmp = t_1;
} else if (a <= 5.8e-55) {
tmp = x * ((y - a) / z);
} else if (a <= 4.4e+29) {
tmp = t_1;
} else if (a <= 2.3e+91) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = t - (t * (y / z))
t_2 = (t - x) * (y / a)
if (a <= (-8d+107)) then
tmp = x
else if (a <= (-10.8d0)) then
tmp = t_2
else if (a <= 2.7d-242) then
tmp = t_1
else if (a <= 5.8d-55) then
tmp = x * ((y - a) / z)
else if (a <= 4.4d+29) then
tmp = t_1
else if (a <= 2.3d+91) then
tmp = t_2
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 = t - (t * (y / z));
double t_2 = (t - x) * (y / a);
double tmp;
if (a <= -8e+107) {
tmp = x;
} else if (a <= -10.8) {
tmp = t_2;
} else if (a <= 2.7e-242) {
tmp = t_1;
} else if (a <= 5.8e-55) {
tmp = x * ((y - a) / z);
} else if (a <= 4.4e+29) {
tmp = t_1;
} else if (a <= 2.3e+91) {
tmp = t_2;
} else if (a <= 1.2e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (t * (y / z)) t_2 = (t - x) * (y / a) tmp = 0 if a <= -8e+107: tmp = x elif a <= -10.8: tmp = t_2 elif a <= 2.7e-242: tmp = t_1 elif a <= 5.8e-55: tmp = x * ((y - a) / z) elif a <= 4.4e+29: tmp = t_1 elif a <= 2.3e+91: tmp = t_2 elif a <= 1.2e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(t * Float64(y / z))) t_2 = Float64(Float64(t - x) * Float64(y / a)) tmp = 0.0 if (a <= -8e+107) tmp = x; elseif (a <= -10.8) tmp = t_2; elseif (a <= 2.7e-242) tmp = t_1; elseif (a <= 5.8e-55) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 4.4e+29) tmp = t_1; elseif (a <= 2.3e+91) tmp = t_2; 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 = t - (t * (y / z)); t_2 = (t - x) * (y / a); tmp = 0.0; if (a <= -8e+107) tmp = x; elseif (a <= -10.8) tmp = t_2; elseif (a <= 2.7e-242) tmp = t_1; elseif (a <= 5.8e-55) tmp = x * ((y - a) / z); elseif (a <= 4.4e+29) tmp = t_1; elseif (a <= 2.3e+91) tmp = t_2; 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[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -8e+107], x, If[LessEqual[a, -10.8], t$95$2, If[LessEqual[a, 2.7e-242], t$95$1, If[LessEqual[a, 5.8e-55], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.4e+29], t$95$1, If[LessEqual[a, 2.3e+91], t$95$2, If[LessEqual[a, 1.2e+96], t, x]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - t \cdot \frac{y}{z}\\
t_2 := \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -8 \cdot 10^{+107}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -10.8:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-242}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.8 \cdot 10^{-55}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 4.4 \cdot 10^{+29}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.3 \cdot 10^{+91}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -7.9999999999999998e107 or 1.19999999999999996e96 < a Initial program 62.0%
associate-*l/89.7%
Simplified89.7%
Taylor expanded in a around inf 54.8%
if -7.9999999999999998e107 < a < -10.800000000000001 or 4.4000000000000003e29 < a < 2.29999999999999991e91Initial program 78.7%
associate-*l/87.5%
Simplified87.5%
Taylor expanded in y around -inf 53.3%
associate-*l/57.0%
Simplified57.0%
Taylor expanded in a around inf 49.4%
if -10.800000000000001 < a < 2.7e-242 or 5.8e-55 < a < 4.4000000000000003e29Initial program 62.0%
associate-*l/76.0%
Simplified76.0%
Taylor expanded in x around 0 54.3%
Taylor expanded in a around 0 50.1%
associate-*r/50.1%
*-commutative50.1%
neg-mul-150.1%
distribute-rgt-neg-in50.1%
Simplified50.1%
Taylor expanded in y around 0 59.8%
mul-1-neg59.8%
unsub-neg59.8%
*-commutative59.8%
associate-*l/64.2%
*-commutative64.2%
Simplified64.2%
if 2.7e-242 < a < 5.8e-55Initial program 71.1%
associate-*l/73.9%
Simplified73.9%
Taylor expanded in z around inf 72.6%
associate--l+72.6%
associate-*r/72.6%
associate-*r/72.6%
div-sub72.6%
distribute-lft-out--72.6%
associate-*r/72.6%
mul-1-neg72.6%
distribute-rgt-out--72.6%
unsub-neg72.6%
associate-/l*78.7%
Simplified78.7%
Taylor expanded in t around 0 51.3%
associate-*r/51.3%
Simplified51.3%
if 2.29999999999999991e91 < a < 1.19999999999999996e96Initial program 56.8%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in z around inf 100.0%
Final simplification56.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* t (/ y z)))) (t_2 (* (- t x) (/ y a))))
(if (<= a -8e+106)
x
(if (<= a -14.2)
t_2
(if (<= a 3.4e-243)
t_1
(if (<= a 1.65e-46)
(/ (* x (- y a)) z)
(if (<= a 2.1e+25)
t_1
(if (<= a 6.6e+90) t_2 (if (<= a 1.4e+96) t x)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (t * (y / z));
double t_2 = (t - x) * (y / a);
double tmp;
if (a <= -8e+106) {
tmp = x;
} else if (a <= -14.2) {
tmp = t_2;
} else if (a <= 3.4e-243) {
tmp = t_1;
} else if (a <= 1.65e-46) {
tmp = (x * (y - a)) / z;
} else if (a <= 2.1e+25) {
tmp = t_1;
} else if (a <= 6.6e+90) {
tmp = t_2;
} else if (a <= 1.4e+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) :: t_2
real(8) :: tmp
t_1 = t - (t * (y / z))
t_2 = (t - x) * (y / a)
if (a <= (-8d+106)) then
tmp = x
else if (a <= (-14.2d0)) then
tmp = t_2
else if (a <= 3.4d-243) then
tmp = t_1
else if (a <= 1.65d-46) then
tmp = (x * (y - a)) / z
else if (a <= 2.1d+25) then
tmp = t_1
else if (a <= 6.6d+90) then
tmp = t_2
else if (a <= 1.4d+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 = t - (t * (y / z));
double t_2 = (t - x) * (y / a);
double tmp;
if (a <= -8e+106) {
tmp = x;
} else if (a <= -14.2) {
tmp = t_2;
} else if (a <= 3.4e-243) {
tmp = t_1;
} else if (a <= 1.65e-46) {
tmp = (x * (y - a)) / z;
} else if (a <= 2.1e+25) {
tmp = t_1;
} else if (a <= 6.6e+90) {
tmp = t_2;
} else if (a <= 1.4e+96) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (t * (y / z)) t_2 = (t - x) * (y / a) tmp = 0 if a <= -8e+106: tmp = x elif a <= -14.2: tmp = t_2 elif a <= 3.4e-243: tmp = t_1 elif a <= 1.65e-46: tmp = (x * (y - a)) / z elif a <= 2.1e+25: tmp = t_1 elif a <= 6.6e+90: tmp = t_2 elif a <= 1.4e+96: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(t * Float64(y / z))) t_2 = Float64(Float64(t - x) * Float64(y / a)) tmp = 0.0 if (a <= -8e+106) tmp = x; elseif (a <= -14.2) tmp = t_2; elseif (a <= 3.4e-243) tmp = t_1; elseif (a <= 1.65e-46) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (a <= 2.1e+25) tmp = t_1; elseif (a <= 6.6e+90) tmp = t_2; elseif (a <= 1.4e+96) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (t * (y / z)); t_2 = (t - x) * (y / a); tmp = 0.0; if (a <= -8e+106) tmp = x; elseif (a <= -14.2) tmp = t_2; elseif (a <= 3.4e-243) tmp = t_1; elseif (a <= 1.65e-46) tmp = (x * (y - a)) / z; elseif (a <= 2.1e+25) tmp = t_1; elseif (a <= 6.6e+90) tmp = t_2; elseif (a <= 1.4e+96) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -8e+106], x, If[LessEqual[a, -14.2], t$95$2, If[LessEqual[a, 3.4e-243], t$95$1, If[LessEqual[a, 1.65e-46], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[a, 2.1e+25], t$95$1, If[LessEqual[a, 6.6e+90], t$95$2, If[LessEqual[a, 1.4e+96], t, x]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - t \cdot \frac{y}{z}\\
t_2 := \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -8 \cdot 10^{+106}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -14.2:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 3.4 \cdot 10^{-243}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{-46}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 6.6 \cdot 10^{+90}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 1.4 \cdot 10^{+96}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -8.00000000000000073e106 or 1.4e96 < a Initial program 62.0%
associate-*l/89.7%
Simplified89.7%
Taylor expanded in a around inf 54.8%
if -8.00000000000000073e106 < a < -14.199999999999999 or 2.0999999999999999e25 < a < 6.60000000000000016e90Initial program 78.7%
associate-*l/87.5%
Simplified87.5%
Taylor expanded in y around -inf 53.3%
associate-*l/57.0%
Simplified57.0%
Taylor expanded in a around inf 49.4%
if -14.199999999999999 < a < 3.39999999999999996e-243 or 1.65000000000000007e-46 < a < 2.0999999999999999e25Initial program 62.4%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in x around 0 54.8%
Taylor expanded in a around 0 50.6%
associate-*r/50.6%
*-commutative50.6%
neg-mul-150.6%
distribute-rgt-neg-in50.6%
Simplified50.6%
Taylor expanded in y around 0 60.5%
mul-1-neg60.5%
unsub-neg60.5%
*-commutative60.5%
associate-*l/64.9%
*-commutative64.9%
Simplified64.9%
if 3.39999999999999996e-243 < a < 1.65000000000000007e-46Initial program 69.9%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 70.6%
associate--l+70.6%
associate-*r/70.6%
associate-*r/70.6%
div-sub70.6%
distribute-lft-out--70.6%
associate-*r/70.6%
mul-1-neg70.6%
distribute-rgt-out--70.6%
unsub-neg70.6%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in t around 0 50.0%
if 6.60000000000000016e90 < a < 1.4e96Initial program 56.8%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in z around inf 100.0%
Final simplification56.9%
(FPCore (x y z t a)
:precision binary64
(if (<= a -9.5e+98)
x
(if (<= a -17.0)
(/ (- x) (/ a y))
(if (<= a -2.05e-43)
t
(if (<= a -2.2e-98)
(- (/ (* t y) z))
(if (<= a 2.4e-242)
t
(if (<= a 5.5e-47) (/ x (/ z y)) (if (<= a 1.9e+38) t x))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -9.5e+98) {
tmp = x;
} else if (a <= -17.0) {
tmp = -x / (a / y);
} else if (a <= -2.05e-43) {
tmp = t;
} else if (a <= -2.2e-98) {
tmp = -((t * y) / z);
} else if (a <= 2.4e-242) {
tmp = t;
} else if (a <= 5.5e-47) {
tmp = x / (z / y);
} else if (a <= 1.9e+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 <= (-9.5d+98)) then
tmp = x
else if (a <= (-17.0d0)) then
tmp = -x / (a / y)
else if (a <= (-2.05d-43)) then
tmp = t
else if (a <= (-2.2d-98)) then
tmp = -((t * y) / z)
else if (a <= 2.4d-242) then
tmp = t
else if (a <= 5.5d-47) then
tmp = x / (z / y)
else if (a <= 1.9d+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 <= -9.5e+98) {
tmp = x;
} else if (a <= -17.0) {
tmp = -x / (a / y);
} else if (a <= -2.05e-43) {
tmp = t;
} else if (a <= -2.2e-98) {
tmp = -((t * y) / z);
} else if (a <= 2.4e-242) {
tmp = t;
} else if (a <= 5.5e-47) {
tmp = x / (z / y);
} else if (a <= 1.9e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -9.5e+98: tmp = x elif a <= -17.0: tmp = -x / (a / y) elif a <= -2.05e-43: tmp = t elif a <= -2.2e-98: tmp = -((t * y) / z) elif a <= 2.4e-242: tmp = t elif a <= 5.5e-47: tmp = x / (z / y) elif a <= 1.9e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -9.5e+98) tmp = x; elseif (a <= -17.0) tmp = Float64(Float64(-x) / Float64(a / y)); elseif (a <= -2.05e-43) tmp = t; elseif (a <= -2.2e-98) tmp = Float64(-Float64(Float64(t * y) / z)); elseif (a <= 2.4e-242) tmp = t; elseif (a <= 5.5e-47) tmp = Float64(x / Float64(z / y)); elseif (a <= 1.9e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -9.5e+98) tmp = x; elseif (a <= -17.0) tmp = -x / (a / y); elseif (a <= -2.05e-43) tmp = t; elseif (a <= -2.2e-98) tmp = -((t * y) / z); elseif (a <= 2.4e-242) tmp = t; elseif (a <= 5.5e-47) tmp = x / (z / y); elseif (a <= 1.9e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -9.5e+98], x, If[LessEqual[a, -17.0], N[((-x) / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.05e-43], t, If[LessEqual[a, -2.2e-98], (-N[(N[(t * y), $MachinePrecision] / z), $MachinePrecision]), If[LessEqual[a, 2.4e-242], t, If[LessEqual[a, 5.5e-47], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.9e+38], t, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -9.5 \cdot 10^{+98}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -17:\\
\;\;\;\;\frac{-x}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq -2.05 \cdot 10^{-43}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq -2.2 \cdot 10^{-98}:\\
\;\;\;\;-\frac{t \cdot y}{z}\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{-242}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 5.5 \cdot 10^{-47}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 1.9 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -9.5000000000000001e98 or 1.8999999999999999e38 < a Initial program 66.1%
associate-*l/89.1%
Simplified89.1%
Taylor expanded in a around inf 48.6%
if -9.5000000000000001e98 < a < -17Initial program 72.2%
associate-*l/88.4%
Simplified88.4%
Taylor expanded in y around -inf 54.4%
associate-*l/61.4%
Simplified61.4%
Taylor expanded in t around 0 32.0%
mul-1-neg32.0%
associate-/l*38.8%
Simplified38.8%
Taylor expanded in a around inf 25.3%
associate-/l*32.1%
Simplified32.1%
if -17 < a < -2.0499999999999999e-43 or -2.19999999999999996e-98 < a < 2.4000000000000001e-242 or 5.5000000000000002e-47 < a < 1.8999999999999999e38Initial program 60.3%
associate-*l/74.8%
Simplified74.8%
Taylor expanded in z around inf 49.5%
if -2.0499999999999999e-43 < a < -2.19999999999999996e-98Initial program 89.0%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in x around 0 67.4%
Taylor expanded in a around 0 57.0%
associate-*r/57.0%
*-commutative57.0%
neg-mul-157.0%
distribute-rgt-neg-in57.0%
Simplified57.0%
Taylor expanded in y around inf 56.8%
associate-*r/56.8%
mul-1-neg56.8%
Simplified56.8%
if 2.4000000000000001e-242 < a < 5.5000000000000002e-47Initial program 69.9%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in y around -inf 56.3%
associate-*l/59.1%
Simplified59.1%
Taylor expanded in t around 0 41.2%
mul-1-neg41.2%
associate-/l*41.3%
Simplified41.3%
Taylor expanded in a around 0 41.7%
mul-1-neg41.7%
associate-/l*41.8%
distribute-neg-frac41.8%
Simplified41.8%
Final simplification46.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ y (- a z)))))
(if (<= z -1.5e+98)
t
(if (<= z -6.6e-63)
t_1
(if (<= z -3e-125)
t
(if (<= z -5.6e-162)
x
(if (<= z -1.4e-269) t_1 (if (<= z 5.5e+109) x t))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (y / (a - z));
double tmp;
if (z <= -1.5e+98) {
tmp = t;
} else if (z <= -6.6e-63) {
tmp = t_1;
} else if (z <= -3e-125) {
tmp = t;
} else if (z <= -5.6e-162) {
tmp = x;
} else if (z <= -1.4e-269) {
tmp = t_1;
} else if (z <= 5.5e+109) {
tmp = x;
} else {
tmp = t;
}
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 / (a - z))
if (z <= (-1.5d+98)) then
tmp = t
else if (z <= (-6.6d-63)) then
tmp = t_1
else if (z <= (-3d-125)) then
tmp = t
else if (z <= (-5.6d-162)) then
tmp = x
else if (z <= (-1.4d-269)) then
tmp = t_1
else if (z <= 5.5d+109) then
tmp = x
else
tmp = t
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 / (a - z));
double tmp;
if (z <= -1.5e+98) {
tmp = t;
} else if (z <= -6.6e-63) {
tmp = t_1;
} else if (z <= -3e-125) {
tmp = t;
} else if (z <= -5.6e-162) {
tmp = x;
} else if (z <= -1.4e-269) {
tmp = t_1;
} else if (z <= 5.5e+109) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (y / (a - z)) tmp = 0 if z <= -1.5e+98: tmp = t elif z <= -6.6e-63: tmp = t_1 elif z <= -3e-125: tmp = t elif z <= -5.6e-162: tmp = x elif z <= -1.4e-269: tmp = t_1 elif z <= 5.5e+109: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(y / Float64(a - z))) tmp = 0.0 if (z <= -1.5e+98) tmp = t; elseif (z <= -6.6e-63) tmp = t_1; elseif (z <= -3e-125) tmp = t; elseif (z <= -5.6e-162) tmp = x; elseif (z <= -1.4e-269) tmp = t_1; elseif (z <= 5.5e+109) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (y / (a - z)); tmp = 0.0; if (z <= -1.5e+98) tmp = t; elseif (z <= -6.6e-63) tmp = t_1; elseif (z <= -3e-125) tmp = t; elseif (z <= -5.6e-162) tmp = x; elseif (z <= -1.4e-269) tmp = t_1; elseif (z <= 5.5e+109) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.5e+98], t, If[LessEqual[z, -6.6e-63], t$95$1, If[LessEqual[z, -3e-125], t, If[LessEqual[z, -5.6e-162], x, If[LessEqual[z, -1.4e-269], t$95$1, If[LessEqual[z, 5.5e+109], x, t]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y}{a - z}\\
\mathbf{if}\;z \leq -1.5 \cdot 10^{+98}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -6.6 \cdot 10^{-63}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-125}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -5.6 \cdot 10^{-162}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -1.4 \cdot 10^{-269}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{+109}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.5000000000000001e98 or -6.59999999999999987e-63 < z < -2.9999999999999999e-125 or 5.4999999999999998e109 < z Initial program 33.4%
associate-*l/64.0%
Simplified64.0%
Taylor expanded in z around inf 46.4%
if -1.5000000000000001e98 < z < -6.59999999999999987e-63 or -5.60000000000000043e-162 < z < -1.39999999999999997e-269Initial program 82.0%
associate-*l/91.7%
Simplified91.7%
Taylor expanded in y around -inf 56.5%
associate-*l/63.0%
Simplified63.0%
Taylor expanded in t around inf 35.8%
associate-*r/42.4%
Simplified42.4%
if -2.9999999999999999e-125 < z < -5.60000000000000043e-162 or -1.39999999999999997e-269 < z < 5.4999999999999998e109Initial program 88.5%
associate-*l/95.6%
Simplified95.6%
Taylor expanded in a around inf 46.4%
Final simplification45.3%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.2e+106)
x
(if (<= a -4.6)
(* (- t x) (/ y a))
(if (<= a 2.75e-242)
(- t (* t (/ y z)))
(if (<= a 2e-46)
(/ (* x (- y a)) z)
(if (<= a 4.8e+99) (- t (/ a (/ z x))) x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.2e+106) {
tmp = x;
} else if (a <= -4.6) {
tmp = (t - x) * (y / a);
} else if (a <= 2.75e-242) {
tmp = t - (t * (y / z));
} else if (a <= 2e-46) {
tmp = (x * (y - a)) / z;
} else if (a <= 4.8e+99) {
tmp = t - (a / (z / x));
} 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.2d+106)) then
tmp = x
else if (a <= (-4.6d0)) then
tmp = (t - x) * (y / a)
else if (a <= 2.75d-242) then
tmp = t - (t * (y / z))
else if (a <= 2d-46) then
tmp = (x * (y - a)) / z
else if (a <= 4.8d+99) then
tmp = t - (a / (z / x))
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.2e+106) {
tmp = x;
} else if (a <= -4.6) {
tmp = (t - x) * (y / a);
} else if (a <= 2.75e-242) {
tmp = t - (t * (y / z));
} else if (a <= 2e-46) {
tmp = (x * (y - a)) / z;
} else if (a <= 4.8e+99) {
tmp = t - (a / (z / x));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.2e+106: tmp = x elif a <= -4.6: tmp = (t - x) * (y / a) elif a <= 2.75e-242: tmp = t - (t * (y / z)) elif a <= 2e-46: tmp = (x * (y - a)) / z elif a <= 4.8e+99: tmp = t - (a / (z / x)) else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.2e+106) tmp = x; elseif (a <= -4.6) tmp = Float64(Float64(t - x) * Float64(y / a)); elseif (a <= 2.75e-242) tmp = Float64(t - Float64(t * Float64(y / z))); elseif (a <= 2e-46) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (a <= 4.8e+99) tmp = Float64(t - Float64(a / Float64(z / x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.2e+106) tmp = x; elseif (a <= -4.6) tmp = (t - x) * (y / a); elseif (a <= 2.75e-242) tmp = t - (t * (y / z)); elseif (a <= 2e-46) tmp = (x * (y - a)) / z; elseif (a <= 4.8e+99) tmp = t - (a / (z / x)); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.2e+106], x, If[LessEqual[a, -4.6], N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.75e-242], N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2e-46], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[a, 4.8e+99], N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.2 \cdot 10^{+106}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -4.6:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{elif}\;a \leq 2.75 \cdot 10^{-242}:\\
\;\;\;\;t - t \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 2 \cdot 10^{-46}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;a \leq 4.8 \cdot 10^{+99}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.2e106 or 4.8000000000000002e99 < a Initial program 62.7%
associate-*l/90.7%
Simplified90.7%
Taylor expanded in a around inf 55.3%
if -1.2e106 < a < -4.5999999999999996Initial program 75.7%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in y around -inf 54.2%
associate-*l/60.3%
Simplified60.3%
Taylor expanded in a around inf 51.3%
if -4.5999999999999996 < a < 2.7499999999999999e-242Initial program 64.9%
associate-*l/76.7%
Simplified76.7%
Taylor expanded in x around 0 57.1%
Taylor expanded in a around 0 52.3%
associate-*r/52.3%
*-commutative52.3%
neg-mul-152.3%
distribute-rgt-neg-in52.3%
Simplified52.3%
Taylor expanded in y around 0 61.4%
mul-1-neg61.4%
unsub-neg61.4%
*-commutative61.4%
associate-*l/65.3%
*-commutative65.3%
Simplified65.3%
if 2.7499999999999999e-242 < a < 2.00000000000000005e-46Initial program 69.9%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 70.6%
associate--l+70.6%
associate-*r/70.6%
associate-*r/70.6%
div-sub70.6%
distribute-lft-out--70.6%
associate-*r/70.6%
mul-1-neg70.6%
distribute-rgt-out--70.6%
unsub-neg70.6%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in t around 0 50.0%
if 2.00000000000000005e-46 < a < 4.8000000000000002e99Initial program 66.2%
associate-*l/77.0%
Simplified77.0%
Taylor expanded in z around inf 37.4%
associate--l+37.4%
associate-*r/37.4%
associate-*r/37.4%
div-sub40.5%
distribute-lft-out--40.5%
associate-*r/40.5%
mul-1-neg40.5%
distribute-rgt-out--40.5%
unsub-neg40.5%
associate-/l*57.2%
Simplified57.2%
Taylor expanded in y around 0 37.4%
sub-neg37.4%
associate-*r/37.4%
associate-*r*37.4%
neg-mul-137.4%
associate-*r/51.3%
distribute-lft-neg-out51.3%
remove-double-neg51.3%
Simplified51.3%
Taylor expanded in t around 0 40.8%
mul-1-neg40.8%
associate-/l*51.8%
distribute-neg-frac51.8%
Simplified51.8%
Final simplification56.5%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.5e+108)
x
(if (<= a -46.0)
(* (- t x) (/ y a))
(if (<= a 1.15e-242)
(/ t (/ (- z) (- y z)))
(if (<= a 4.6e-47)
(/ (* x (- y a)) z)
(if (<= a 6.5e+96) (- t (/ a (/ z x))) x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.5e+108) {
tmp = x;
} else if (a <= -46.0) {
tmp = (t - x) * (y / a);
} else if (a <= 1.15e-242) {
tmp = t / (-z / (y - z));
} else if (a <= 4.6e-47) {
tmp = (x * (y - a)) / z;
} else if (a <= 6.5e+96) {
tmp = t - (a / (z / x));
} 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.5d+108)) then
tmp = x
else if (a <= (-46.0d0)) then
tmp = (t - x) * (y / a)
else if (a <= 1.15d-242) then
tmp = t / (-z / (y - z))
else if (a <= 4.6d-47) then
tmp = (x * (y - a)) / z
else if (a <= 6.5d+96) then
tmp = t - (a / (z / x))
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.5e+108) {
tmp = x;
} else if (a <= -46.0) {
tmp = (t - x) * (y / a);
} else if (a <= 1.15e-242) {
tmp = t / (-z / (y - z));
} else if (a <= 4.6e-47) {
tmp = (x * (y - a)) / z;
} else if (a <= 6.5e+96) {
tmp = t - (a / (z / x));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.5e+108: tmp = x elif a <= -46.0: tmp = (t - x) * (y / a) elif a <= 1.15e-242: tmp = t / (-z / (y - z)) elif a <= 4.6e-47: tmp = (x * (y - a)) / z elif a <= 6.5e+96: tmp = t - (a / (z / x)) else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.5e+108) tmp = x; elseif (a <= -46.0) tmp = Float64(Float64(t - x) * Float64(y / a)); elseif (a <= 1.15e-242) tmp = Float64(t / Float64(Float64(-z) / Float64(y - z))); elseif (a <= 4.6e-47) tmp = Float64(Float64(x * Float64(y - a)) / z); elseif (a <= 6.5e+96) tmp = Float64(t - Float64(a / Float64(z / x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.5e+108) tmp = x; elseif (a <= -46.0) tmp = (t - x) * (y / a); elseif (a <= 1.15e-242) tmp = t / (-z / (y - z)); elseif (a <= 4.6e-47) tmp = (x * (y - a)) / z; elseif (a <= 6.5e+96) tmp = t - (a / (z / x)); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.5e+108], x, If[LessEqual[a, -46.0], N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.15e-242], N[(t / N[((-z) / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.6e-47], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[a, 6.5e+96], N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.5 \cdot 10^{+108}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -46:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{elif}\;a \leq 1.15 \cdot 10^{-242}:\\
\;\;\;\;\frac{t}{\frac{-z}{y - z}}\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{-47}:\\
\;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\
\mathbf{elif}\;a \leq 6.5 \cdot 10^{+96}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.49999999999999992e108 or 6.5e96 < a Initial program 62.7%
associate-*l/90.7%
Simplified90.7%
Taylor expanded in a around inf 55.3%
if -1.49999999999999992e108 < a < -46Initial program 75.7%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in y around -inf 54.2%
associate-*l/60.3%
Simplified60.3%
Taylor expanded in a around inf 51.3%
if -46 < a < 1.14999999999999992e-242Initial program 64.9%
associate-*l/76.7%
Simplified76.7%
Taylor expanded in x around 0 57.1%
associate-/l*68.8%
Simplified68.8%
Taylor expanded in a around 0 65.3%
neg-mul-165.3%
distribute-neg-frac65.3%
Simplified65.3%
if 1.14999999999999992e-242 < a < 4.59999999999999964e-47Initial program 69.9%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 70.6%
associate--l+70.6%
associate-*r/70.6%
associate-*r/70.6%
div-sub70.6%
distribute-lft-out--70.6%
associate-*r/70.6%
mul-1-neg70.6%
distribute-rgt-out--70.6%
unsub-neg70.6%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in t around 0 50.0%
if 4.59999999999999964e-47 < a < 6.5e96Initial program 66.2%
associate-*l/77.0%
Simplified77.0%
Taylor expanded in z around inf 37.4%
associate--l+37.4%
associate-*r/37.4%
associate-*r/37.4%
div-sub40.5%
distribute-lft-out--40.5%
associate-*r/40.5%
mul-1-neg40.5%
distribute-rgt-out--40.5%
unsub-neg40.5%
associate-/l*57.2%
Simplified57.2%
Taylor expanded in y around 0 37.4%
sub-neg37.4%
associate-*r/37.4%
associate-*r*37.4%
neg-mul-137.4%
associate-*r/51.3%
distribute-lft-neg-out51.3%
remove-double-neg51.3%
Simplified51.3%
Taylor expanded in t around 0 40.8%
mul-1-neg40.8%
associate-/l*51.8%
distribute-neg-frac51.8%
Simplified51.8%
Final simplification56.5%
(FPCore (x y z t a)
:precision binary64
(if (or (<= a -0.29)
(and (not (<= a 5.6e-124))
(or (<= a 1.35e-85) (not (<= a 1.18e+38)))))
(+ x (* (- t x) (/ (- y z) a)))
(+ t (/ (* y (- x t)) z))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -0.29) || (!(a <= 5.6e-124) && ((a <= 1.35e-85) || !(a <= 1.18e+38)))) {
tmp = x + ((t - x) * ((y - z) / a));
} else {
tmp = t + ((y * (x - t)) / 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) :: tmp
if ((a <= (-0.29d0)) .or. (.not. (a <= 5.6d-124)) .and. (a <= 1.35d-85) .or. (.not. (a <= 1.18d+38))) then
tmp = x + ((t - x) * ((y - z) / a))
else
tmp = t + ((y * (x - t)) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -0.29) || (!(a <= 5.6e-124) && ((a <= 1.35e-85) || !(a <= 1.18e+38)))) {
tmp = x + ((t - x) * ((y - z) / a));
} else {
tmp = t + ((y * (x - t)) / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -0.29) or (not (a <= 5.6e-124) and ((a <= 1.35e-85) or not (a <= 1.18e+38))): tmp = x + ((t - x) * ((y - z) / a)) else: tmp = t + ((y * (x - t)) / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -0.29) || (!(a <= 5.6e-124) && ((a <= 1.35e-85) || !(a <= 1.18e+38)))) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / a))); else tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -0.29) || (~((a <= 5.6e-124)) && ((a <= 1.35e-85) || ~((a <= 1.18e+38))))) tmp = x + ((t - x) * ((y - z) / a)); else tmp = t + ((y * (x - t)) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -0.29], And[N[Not[LessEqual[a, 5.6e-124]], $MachinePrecision], Or[LessEqual[a, 1.35e-85], N[Not[LessEqual[a, 1.18e+38]], $MachinePrecision]]]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -0.29 \lor \neg \left(a \leq 5.6 \cdot 10^{-124}\right) \land \left(a \leq 1.35 \cdot 10^{-85} \lor \neg \left(a \leq 1.18 \cdot 10^{+38}\right)\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\end{array}
\end{array}
if a < -0.28999999999999998 or 5.59999999999999996e-124 < a < 1.3500000000000001e-85 or 1.18e38 < a Initial program 68.9%
associate-*l/89.5%
Simplified89.5%
Taylor expanded in a around inf 77.9%
if -0.28999999999999998 < a < 5.59999999999999996e-124 or 1.3500000000000001e-85 < a < 1.18e38Initial program 62.9%
associate-*l/74.3%
Simplified74.3%
Taylor expanded in z around inf 77.1%
associate--l+77.1%
associate-*r/77.1%
associate-*r/77.1%
div-sub78.0%
distribute-lft-out--78.0%
associate-*r/78.0%
mul-1-neg78.0%
distribute-rgt-out--78.0%
unsub-neg78.0%
associate-/l*82.5%
Simplified82.5%
Taylor expanded in y around inf 73.1%
Final simplification75.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (/ (* y (- x t)) z))) (t_2 (+ x (* (- t x) (/ (- y z) a)))))
(if (<= a -18.0)
t_2
(if (<= a 2.15e-125)
t_1
(if (<= a 1.55e-85)
t_2
(if (<= a 1.18e+38) t_1 (+ x (/ (- t x) (/ a (- y z))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((y * (x - t)) / z);
double t_2 = x + ((t - x) * ((y - z) / a));
double tmp;
if (a <= -18.0) {
tmp = t_2;
} else if (a <= 2.15e-125) {
tmp = t_1;
} else if (a <= 1.55e-85) {
tmp = t_2;
} else if (a <= 1.18e+38) {
tmp = t_1;
} else {
tmp = x + ((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 * (x - t)) / z)
t_2 = x + ((t - x) * ((y - z) / a))
if (a <= (-18.0d0)) then
tmp = t_2
else if (a <= 2.15d-125) then
tmp = t_1
else if (a <= 1.55d-85) then
tmp = t_2
else if (a <= 1.18d+38) then
tmp = t_1
else
tmp = x + ((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 * (x - t)) / z);
double t_2 = x + ((t - x) * ((y - z) / a));
double tmp;
if (a <= -18.0) {
tmp = t_2;
} else if (a <= 2.15e-125) {
tmp = t_1;
} else if (a <= 1.55e-85) {
tmp = t_2;
} else if (a <= 1.18e+38) {
tmp = t_1;
} else {
tmp = x + ((t - x) / (a / (y - z)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + ((y * (x - t)) / z) t_2 = x + ((t - x) * ((y - z) / a)) tmp = 0 if a <= -18.0: tmp = t_2 elif a <= 2.15e-125: tmp = t_1 elif a <= 1.55e-85: tmp = t_2 elif a <= 1.18e+38: tmp = t_1 else: tmp = x + ((t - x) / (a / (y - z))) return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(y * Float64(x - t)) / z)) t_2 = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / a))) tmp = 0.0 if (a <= -18.0) tmp = t_2; elseif (a <= 2.15e-125) tmp = t_1; elseif (a <= 1.55e-85) tmp = t_2; elseif (a <= 1.18e+38) tmp = t_1; else tmp = Float64(x + Float64(Float64(t - x) / Float64(a / Float64(y - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + ((y * (x - t)) / z); t_2 = x + ((t - x) * ((y - z) / a)); tmp = 0.0; if (a <= -18.0) tmp = t_2; elseif (a <= 2.15e-125) tmp = t_1; elseif (a <= 1.55e-85) tmp = t_2; elseif (a <= 1.18e+38) tmp = t_1; else tmp = x + ((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 * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -18.0], t$95$2, If[LessEqual[a, 2.15e-125], t$95$1, If[LessEqual[a, 1.55e-85], t$95$2, If[LessEqual[a, 1.18e+38], t$95$1, N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{y \cdot \left(x - t\right)}{z}\\
t_2 := x + \left(t - x\right) \cdot \frac{y - z}{a}\\
\mathbf{if}\;a \leq -18:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 2.15 \cdot 10^{-125}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.55 \cdot 10^{-85}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 1.18 \cdot 10^{+38}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y - z}}\\
\end{array}
\end{array}
if a < -18 or 2.1500000000000001e-125 < a < 1.5500000000000001e-85Initial program 69.0%
associate-*l/91.8%
Simplified91.8%
Taylor expanded in a around inf 80.0%
if -18 < a < 2.1500000000000001e-125 or 1.5500000000000001e-85 < a < 1.18e38Initial program 62.9%
associate-*l/74.3%
Simplified74.3%
Taylor expanded in z around inf 77.1%
associate--l+77.1%
associate-*r/77.1%
associate-*r/77.1%
div-sub78.0%
distribute-lft-out--78.0%
associate-*r/78.0%
mul-1-neg78.0%
distribute-rgt-out--78.0%
unsub-neg78.0%
associate-/l*82.5%
Simplified82.5%
Taylor expanded in y around inf 73.1%
if 1.18e38 < a Initial program 68.6%
associate-*l/86.1%
Simplified86.1%
Taylor expanded in a around inf 61.9%
associate-/l*74.9%
Simplified74.9%
Final simplification75.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (/ (- x t) (/ z (- y a)))))
(t_2 (+ x (* (- t x) (/ (- y z) a)))))
(if (<= a -3.3)
t_2
(if (<= a 5.6e-124)
t_1
(if (<= a 1.14e-85)
t_2
(if (<= a 9.6e+26) t_1 (+ x (/ (- t x) (/ a (- y z))))))))))
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 + ((t - x) * ((y - z) / a));
double tmp;
if (a <= -3.3) {
tmp = t_2;
} else if (a <= 5.6e-124) {
tmp = t_1;
} else if (a <= 1.14e-85) {
tmp = t_2;
} else if (a <= 9.6e+26) {
tmp = t_1;
} else {
tmp = x + ((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 + ((x - t) / (z / (y - a)))
t_2 = x + ((t - x) * ((y - z) / a))
if (a <= (-3.3d0)) then
tmp = t_2
else if (a <= 5.6d-124) then
tmp = t_1
else if (a <= 1.14d-85) then
tmp = t_2
else if (a <= 9.6d+26) then
tmp = t_1
else
tmp = x + ((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 + ((x - t) / (z / (y - a)));
double t_2 = x + ((t - x) * ((y - z) / a));
double tmp;
if (a <= -3.3) {
tmp = t_2;
} else if (a <= 5.6e-124) {
tmp = t_1;
} else if (a <= 1.14e-85) {
tmp = t_2;
} else if (a <= 9.6e+26) {
tmp = t_1;
} else {
tmp = x + ((t - x) / (a / (y - z)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + ((x - t) / (z / (y - a))) t_2 = x + ((t - x) * ((y - z) / a)) tmp = 0 if a <= -3.3: tmp = t_2 elif a <= 5.6e-124: tmp = t_1 elif a <= 1.14e-85: tmp = t_2 elif a <= 9.6e+26: tmp = t_1 else: tmp = x + ((t - x) / (a / (y - z))) 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(t - x) * Float64(Float64(y - z) / a))) tmp = 0.0 if (a <= -3.3) tmp = t_2; elseif (a <= 5.6e-124) tmp = t_1; elseif (a <= 1.14e-85) tmp = t_2; elseif (a <= 9.6e+26) tmp = t_1; else tmp = Float64(x + Float64(Float64(t - x) / Float64(a / Float64(y - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + ((x - t) / (z / (y - a))); t_2 = x + ((t - x) * ((y - z) / a)); tmp = 0.0; if (a <= -3.3) tmp = t_2; elseif (a <= 5.6e-124) tmp = t_1; elseif (a <= 1.14e-85) tmp = t_2; elseif (a <= 9.6e+26) tmp = t_1; else tmp = x + ((t - x) / (a / (y - z))); 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[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.3], t$95$2, If[LessEqual[a, 5.6e-124], t$95$1, If[LessEqual[a, 1.14e-85], t$95$2, If[LessEqual[a, 9.6e+26], t$95$1, N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{x - t}{\frac{z}{y - a}}\\
t_2 := x + \left(t - x\right) \cdot \frac{y - z}{a}\\
\mathbf{if}\;a \leq -3.3:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-124}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.14 \cdot 10^{-85}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 9.6 \cdot 10^{+26}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y - z}}\\
\end{array}
\end{array}
if a < -3.2999999999999998 or 5.59999999999999996e-124 < a < 1.1400000000000001e-85Initial program 69.0%
associate-*l/91.8%
Simplified91.8%
Taylor expanded in a around inf 80.0%
if -3.2999999999999998 < a < 5.59999999999999996e-124 or 1.1400000000000001e-85 < a < 9.60000000000000018e26Initial program 62.3%
associate-*l/73.9%
Simplified73.9%
Taylor expanded in z around inf 77.5%
associate--l+77.5%
associate-*r/77.5%
associate-*r/77.5%
div-sub78.5%
distribute-lft-out--78.5%
associate-*r/78.5%
mul-1-neg78.5%
distribute-rgt-out--78.5%
unsub-neg78.5%
associate-/l*83.1%
Simplified83.1%
if 9.60000000000000018e26 < a Initial program 69.6%
associate-*l/86.6%
Simplified86.6%
Taylor expanded in a around inf 61.5%
associate-/l*74.1%
Simplified74.1%
Final simplification80.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))))
(if (<= t -2.65e-123)
t_1
(if (<= t 1.45e-239)
(/ (- x) (/ (- a z) y))
(if (<= t 4.5e-188) x (if (<= t 1.9e-179) (/ x (/ z y)) 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.65e-123) {
tmp = t_1;
} else if (t <= 1.45e-239) {
tmp = -x / ((a - z) / y);
} else if (t <= 4.5e-188) {
tmp = x;
} else if (t <= 1.9e-179) {
tmp = x / (z / y);
} 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.65d-123)) then
tmp = t_1
else if (t <= 1.45d-239) then
tmp = -x / ((a - z) / y)
else if (t <= 4.5d-188) then
tmp = x
else if (t <= 1.9d-179) then
tmp = x / (z / y)
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.65e-123) {
tmp = t_1;
} else if (t <= 1.45e-239) {
tmp = -x / ((a - z) / y);
} else if (t <= 4.5e-188) {
tmp = x;
} else if (t <= 1.9e-179) {
tmp = x / (z / y);
} 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.65e-123: tmp = t_1 elif t <= 1.45e-239: tmp = -x / ((a - z) / y) elif t <= 4.5e-188: tmp = x elif t <= 1.9e-179: tmp = x / (z / y) 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.65e-123) tmp = t_1; elseif (t <= 1.45e-239) tmp = Float64(Float64(-x) / Float64(Float64(a - z) / y)); elseif (t <= 4.5e-188) tmp = x; elseif (t <= 1.9e-179) tmp = Float64(x / Float64(z / y)); 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.65e-123) tmp = t_1; elseif (t <= 1.45e-239) tmp = -x / ((a - z) / y); elseif (t <= 4.5e-188) tmp = x; elseif (t <= 1.9e-179) tmp = x / (z / y); 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.65e-123], t$95$1, If[LessEqual[t, 1.45e-239], N[((-x) / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.5e-188], x, If[LessEqual[t, 1.9e-179], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;t \leq -2.65 \cdot 10^{-123}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.45 \cdot 10^{-239}:\\
\;\;\;\;\frac{-x}{\frac{a - z}{y}}\\
\mathbf{elif}\;t \leq 4.5 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{-179}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.64999999999999985e-123 or 1.89999999999999987e-179 < t Initial program 62.9%
associate-*l/84.4%
Simplified84.4%
Taylor expanded in x around 0 47.9%
associate-/l*62.5%
div-inv62.5%
clear-num62.6%
Applied egg-rr62.6%
if -2.64999999999999985e-123 < t < 1.4500000000000001e-239Initial program 75.6%
associate-*l/78.7%
Simplified78.7%
Taylor expanded in y around -inf 51.8%
associate-*l/53.2%
Simplified53.2%
Taylor expanded in t around 0 47.1%
mul-1-neg47.1%
associate-/l*49.2%
Simplified49.2%
if 1.4500000000000001e-239 < t < 4.49999999999999993e-188Initial program 67.3%
associate-*l/74.0%
Simplified74.0%
Taylor expanded in a around inf 50.3%
if 4.49999999999999993e-188 < t < 1.89999999999999987e-179Initial program 100.0%
associate-*l/99.2%
Simplified99.2%
Taylor expanded in y around -inf 52.1%
associate-*l/51.3%
Simplified51.3%
Taylor expanded in t around 0 52.1%
mul-1-neg52.1%
associate-/l*52.1%
Simplified52.1%
Taylor expanded in a around 0 53.9%
mul-1-neg53.9%
associate-/l*53.9%
distribute-neg-frac53.9%
Simplified53.9%
Final simplification58.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- t x) (/ y a)))) (t_2 (* t (/ (- y z) (- a z)))))
(if (<= z -1.1e-26)
t_2
(if (<= z -8.5e-89)
t_1
(if (<= z -6e-217) t_2 (if (<= z 1.5e+128) t_1 (- t (/ a (/ z x)))))))))
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 (z <= -1.1e-26) {
tmp = t_2;
} else if (z <= -8.5e-89) {
tmp = t_1;
} else if (z <= -6e-217) {
tmp = t_2;
} else if (z <= 1.5e+128) {
tmp = t_1;
} else {
tmp = t - (a / (z / 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) :: t_2
real(8) :: tmp
t_1 = x + ((t - x) * (y / a))
t_2 = t * ((y - z) / (a - z))
if (z <= (-1.1d-26)) then
tmp = t_2
else if (z <= (-8.5d-89)) then
tmp = t_1
else if (z <= (-6d-217)) then
tmp = t_2
else if (z <= 1.5d+128) then
tmp = t_1
else
tmp = t - (a / (z / 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 t_2 = t * ((y - z) / (a - z));
double tmp;
if (z <= -1.1e-26) {
tmp = t_2;
} else if (z <= -8.5e-89) {
tmp = t_1;
} else if (z <= -6e-217) {
tmp = t_2;
} else if (z <= 1.5e+128) {
tmp = t_1;
} else {
tmp = t - (a / (z / x));
}
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 z <= -1.1e-26: tmp = t_2 elif z <= -8.5e-89: tmp = t_1 elif z <= -6e-217: tmp = t_2 elif z <= 1.5e+128: tmp = t_1 else: tmp = t - (a / (z / x)) 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 (z <= -1.1e-26) tmp = t_2; elseif (z <= -8.5e-89) tmp = t_1; elseif (z <= -6e-217) tmp = t_2; elseif (z <= 1.5e+128) tmp = t_1; else tmp = Float64(t - Float64(a / Float64(z / x))); 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 (z <= -1.1e-26) tmp = t_2; elseif (z <= -8.5e-89) tmp = t_1; elseif (z <= -6e-217) tmp = t_2; elseif (z <= 1.5e+128) tmp = t_1; else tmp = t - (a / (z / 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]}, Block[{t$95$2 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.1e-26], t$95$2, If[LessEqual[z, -8.5e-89], t$95$1, If[LessEqual[z, -6e-217], t$95$2, If[LessEqual[z, 1.5e+128], t$95$1, N[(t - N[(a / N[(z / x), $MachinePrecision]), $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}\;z \leq -1.1 \cdot 10^{-26}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -8.5 \cdot 10^{-89}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -6 \cdot 10^{-217}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 1.5 \cdot 10^{+128}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\end{array}
\end{array}
if z < -1.1e-26 or -8.49999999999999937e-89 < z < -6.00000000000000009e-217Initial program 55.5%
associate-*l/76.2%
Simplified76.2%
Taylor expanded in x around 0 43.9%
associate-/l*60.5%
div-inv60.6%
clear-num60.6%
Applied egg-rr60.6%
if -1.1e-26 < z < -8.49999999999999937e-89 or -6.00000000000000009e-217 < z < 1.4999999999999999e128Initial program 86.9%
associate-*l/94.9%
Simplified94.9%
Taylor expanded in z around 0 75.9%
if 1.4999999999999999e128 < z Initial program 29.2%
associate-*l/62.2%
Simplified62.2%
Taylor expanded in z around inf 58.3%
associate--l+58.3%
associate-*r/58.3%
associate-*r/58.3%
div-sub58.3%
distribute-lft-out--58.3%
associate-*r/58.3%
mul-1-neg58.3%
distribute-rgt-out--58.5%
unsub-neg58.5%
associate-/l*81.2%
Simplified81.2%
Taylor expanded in y around 0 52.2%
sub-neg52.2%
associate-*r/52.2%
associate-*r*52.2%
neg-mul-152.2%
associate-*r/66.3%
distribute-lft-neg-out66.3%
remove-double-neg66.3%
Simplified66.3%
Taylor expanded in t around 0 55.9%
mul-1-neg55.9%
associate-/l*66.9%
distribute-neg-frac66.9%
Simplified66.9%
Final simplification68.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.3e+192)
t
(if (<= z -3.8e+125)
(* x (/ (- y a) z))
(if (<= z -1.32e+98)
t
(if (<= z -1.12e-269) (* t (/ y (- a z))) (if (<= z 6.8e+106) x t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.3e+192) {
tmp = t;
} else if (z <= -3.8e+125) {
tmp = x * ((y - a) / z);
} else if (z <= -1.32e+98) {
tmp = t;
} else if (z <= -1.12e-269) {
tmp = t * (y / (a - z));
} else if (z <= 6.8e+106) {
tmp = x;
} else {
tmp = t;
}
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 (z <= (-1.3d+192)) then
tmp = t
else if (z <= (-3.8d+125)) then
tmp = x * ((y - a) / z)
else if (z <= (-1.32d+98)) then
tmp = t
else if (z <= (-1.12d-269)) then
tmp = t * (y / (a - z))
else if (z <= 6.8d+106) then
tmp = x
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.3e+192) {
tmp = t;
} else if (z <= -3.8e+125) {
tmp = x * ((y - a) / z);
} else if (z <= -1.32e+98) {
tmp = t;
} else if (z <= -1.12e-269) {
tmp = t * (y / (a - z));
} else if (z <= 6.8e+106) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.3e+192: tmp = t elif z <= -3.8e+125: tmp = x * ((y - a) / z) elif z <= -1.32e+98: tmp = t elif z <= -1.12e-269: tmp = t * (y / (a - z)) elif z <= 6.8e+106: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.3e+192) tmp = t; elseif (z <= -3.8e+125) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= -1.32e+98) tmp = t; elseif (z <= -1.12e-269) tmp = Float64(t * Float64(y / Float64(a - z))); elseif (z <= 6.8e+106) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.3e+192) tmp = t; elseif (z <= -3.8e+125) tmp = x * ((y - a) / z); elseif (z <= -1.32e+98) tmp = t; elseif (z <= -1.12e-269) tmp = t * (y / (a - z)); elseif (z <= 6.8e+106) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.3e+192], t, If[LessEqual[z, -3.8e+125], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.32e+98], t, If[LessEqual[z, -1.12e-269], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.8e+106], x, t]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.3 \cdot 10^{+192}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{+125}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq -1.32 \cdot 10^{+98}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.12 \cdot 10^{-269}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;z \leq 6.8 \cdot 10^{+106}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.30000000000000002e192 or -3.80000000000000002e125 < z < -1.3200000000000001e98 or 6.79999999999999989e106 < z Initial program 26.1%
associate-*l/62.4%
Simplified62.4%
Taylor expanded in z around inf 53.2%
if -1.30000000000000002e192 < z < -3.80000000000000002e125Initial program 32.8%
associate-*l/56.9%
Simplified56.9%
Taylor expanded in z around inf 60.6%
associate--l+60.6%
associate-*r/60.6%
associate-*r/60.6%
div-sub60.6%
distribute-lft-out--60.6%
associate-*r/60.6%
mul-1-neg60.6%
distribute-rgt-out--60.6%
unsub-neg60.6%
associate-/l*76.4%
Simplified76.4%
Taylor expanded in t around 0 44.3%
associate-*r/51.8%
Simplified51.8%
if -1.3200000000000001e98 < z < -1.12e-269Initial program 81.7%
associate-*l/89.8%
Simplified89.8%
Taylor expanded in y around -inf 51.9%
associate-*l/57.0%
Simplified57.0%
Taylor expanded in t around inf 30.1%
associate-*r/36.4%
Simplified36.4%
if -1.12e-269 < z < 6.79999999999999989e106Initial program 89.1%
associate-*l/96.5%
Simplified96.5%
Taylor expanded in a around inf 46.1%
Final simplification45.1%
(FPCore (x y z t a)
:precision binary64
(if (<= a -9.5e+98)
x
(if (<= a -11.8)
(/ (- x) (/ a y))
(if (<= a -2.75e-43)
t
(if (<= a -1.9e-98) (* (/ y z) (- t)) (if (<= a 1.45e+38) t x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -9.5e+98) {
tmp = x;
} else if (a <= -11.8) {
tmp = -x / (a / y);
} else if (a <= -2.75e-43) {
tmp = t;
} else if (a <= -1.9e-98) {
tmp = (y / z) * -t;
} else if (a <= 1.45e+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 <= (-9.5d+98)) then
tmp = x
else if (a <= (-11.8d0)) then
tmp = -x / (a / y)
else if (a <= (-2.75d-43)) then
tmp = t
else if (a <= (-1.9d-98)) then
tmp = (y / z) * -t
else if (a <= 1.45d+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 <= -9.5e+98) {
tmp = x;
} else if (a <= -11.8) {
tmp = -x / (a / y);
} else if (a <= -2.75e-43) {
tmp = t;
} else if (a <= -1.9e-98) {
tmp = (y / z) * -t;
} else if (a <= 1.45e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -9.5e+98: tmp = x elif a <= -11.8: tmp = -x / (a / y) elif a <= -2.75e-43: tmp = t elif a <= -1.9e-98: tmp = (y / z) * -t elif a <= 1.45e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -9.5e+98) tmp = x; elseif (a <= -11.8) tmp = Float64(Float64(-x) / Float64(a / y)); elseif (a <= -2.75e-43) tmp = t; elseif (a <= -1.9e-98) tmp = Float64(Float64(y / z) * Float64(-t)); elseif (a <= 1.45e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -9.5e+98) tmp = x; elseif (a <= -11.8) tmp = -x / (a / y); elseif (a <= -2.75e-43) tmp = t; elseif (a <= -1.9e-98) tmp = (y / z) * -t; elseif (a <= 1.45e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -9.5e+98], x, If[LessEqual[a, -11.8], N[((-x) / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.75e-43], t, If[LessEqual[a, -1.9e-98], N[(N[(y / z), $MachinePrecision] * (-t)), $MachinePrecision], If[LessEqual[a, 1.45e+38], t, x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -9.5 \cdot 10^{+98}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -11.8:\\
\;\;\;\;\frac{-x}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq -2.75 \cdot 10^{-43}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq -1.9 \cdot 10^{-98}:\\
\;\;\;\;\frac{y}{z} \cdot \left(-t\right)\\
\mathbf{elif}\;a \leq 1.45 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -9.5000000000000001e98 or 1.45000000000000003e38 < a Initial program 66.1%
associate-*l/89.1%
Simplified89.1%
Taylor expanded in a around inf 48.6%
if -9.5000000000000001e98 < a < -11.800000000000001Initial program 72.2%
associate-*l/88.4%
Simplified88.4%
Taylor expanded in y around -inf 54.4%
associate-*l/61.4%
Simplified61.4%
Taylor expanded in t around 0 32.0%
mul-1-neg32.0%
associate-/l*38.8%
Simplified38.8%
Taylor expanded in a around inf 25.3%
associate-/l*32.1%
Simplified32.1%
if -11.800000000000001 < a < -2.75000000000000006e-43 or -1.9000000000000002e-98 < a < 1.45000000000000003e38Initial program 63.1%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 42.0%
if -2.75000000000000006e-43 < a < -1.9000000000000002e-98Initial program 89.0%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in y around -inf 89.2%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in t around inf 67.3%
associate-*r/67.0%
Simplified67.0%
Taylor expanded in a around 0 56.6%
associate-*r/56.6%
neg-mul-156.6%
Simplified56.6%
Final simplification44.3%
(FPCore (x y z t a)
:precision binary64
(if (<= a -9e+98)
x
(if (<= a -4.5)
(/ (- x) (/ a y))
(if (<= a -2.05e-43)
t
(if (<= a -2.6e-98) (- (/ (* t y) z)) (if (<= a 1.65e+38) t x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -9e+98) {
tmp = x;
} else if (a <= -4.5) {
tmp = -x / (a / y);
} else if (a <= -2.05e-43) {
tmp = t;
} else if (a <= -2.6e-98) {
tmp = -((t * y) / z);
} else if (a <= 1.65e+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 <= (-9d+98)) then
tmp = x
else if (a <= (-4.5d0)) then
tmp = -x / (a / y)
else if (a <= (-2.05d-43)) then
tmp = t
else if (a <= (-2.6d-98)) then
tmp = -((t * y) / z)
else if (a <= 1.65d+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 <= -9e+98) {
tmp = x;
} else if (a <= -4.5) {
tmp = -x / (a / y);
} else if (a <= -2.05e-43) {
tmp = t;
} else if (a <= -2.6e-98) {
tmp = -((t * y) / z);
} else if (a <= 1.65e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -9e+98: tmp = x elif a <= -4.5: tmp = -x / (a / y) elif a <= -2.05e-43: tmp = t elif a <= -2.6e-98: tmp = -((t * y) / z) elif a <= 1.65e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -9e+98) tmp = x; elseif (a <= -4.5) tmp = Float64(Float64(-x) / Float64(a / y)); elseif (a <= -2.05e-43) tmp = t; elseif (a <= -2.6e-98) tmp = Float64(-Float64(Float64(t * y) / z)); elseif (a <= 1.65e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -9e+98) tmp = x; elseif (a <= -4.5) tmp = -x / (a / y); elseif (a <= -2.05e-43) tmp = t; elseif (a <= -2.6e-98) tmp = -((t * y) / z); elseif (a <= 1.65e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -9e+98], x, If[LessEqual[a, -4.5], N[((-x) / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.05e-43], t, If[LessEqual[a, -2.6e-98], (-N[(N[(t * y), $MachinePrecision] / z), $MachinePrecision]), If[LessEqual[a, 1.65e+38], t, x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -9 \cdot 10^{+98}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -4.5:\\
\;\;\;\;\frac{-x}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq -2.05 \cdot 10^{-43}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq -2.6 \cdot 10^{-98}:\\
\;\;\;\;-\frac{t \cdot y}{z}\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -9.0000000000000004e98 or 1.65e38 < a Initial program 66.1%
associate-*l/89.1%
Simplified89.1%
Taylor expanded in a around inf 48.6%
if -9.0000000000000004e98 < a < -4.5Initial program 72.2%
associate-*l/88.4%
Simplified88.4%
Taylor expanded in y around -inf 54.4%
associate-*l/61.4%
Simplified61.4%
Taylor expanded in t around 0 32.0%
mul-1-neg32.0%
associate-/l*38.8%
Simplified38.8%
Taylor expanded in a around inf 25.3%
associate-/l*32.1%
Simplified32.1%
if -4.5 < a < -2.0499999999999999e-43 or -2.60000000000000013e-98 < a < 1.65e38Initial program 63.1%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 42.0%
if -2.0499999999999999e-43 < a < -2.60000000000000013e-98Initial program 89.0%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in x around 0 67.4%
Taylor expanded in a around 0 57.0%
associate-*r/57.0%
*-commutative57.0%
neg-mul-157.0%
distribute-rgt-neg-in57.0%
Simplified57.0%
Taylor expanded in y around inf 56.8%
associate-*r/56.8%
mul-1-neg56.8%
Simplified56.8%
Final simplification44.3%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -6.2e+71) (not (<= z 3.2e+165))) (+ t (/ (- x t) (/ z (- y a)))) (- x (* (- t x) (/ (- z y) (- a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6.2e+71) || !(z <= 3.2e+165)) {
tmp = t + ((x - t) / (z / (y - a)));
} else {
tmp = x - ((t - x) * ((z - y) / (a - 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) :: tmp
if ((z <= (-6.2d+71)) .or. (.not. (z <= 3.2d+165))) then
tmp = t + ((x - t) / (z / (y - a)))
else
tmp = x - ((t - x) * ((z - y) / (a - z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -6.2e+71) || !(z <= 3.2e+165)) {
tmp = t + ((x - t) / (z / (y - a)));
} else {
tmp = x - ((t - x) * ((z - y) / (a - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -6.2e+71) or not (z <= 3.2e+165): tmp = t + ((x - t) / (z / (y - a))) else: tmp = x - ((t - x) * ((z - y) / (a - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -6.2e+71) || !(z <= 3.2e+165)) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); else tmp = Float64(x - Float64(Float64(t - x) * Float64(Float64(z - y) / Float64(a - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -6.2e+71) || ~((z <= 3.2e+165))) tmp = t + ((x - t) / (z / (y - a))); else tmp = x - ((t - x) * ((z - y) / (a - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -6.2e+71], N[Not[LessEqual[z, 3.2e+165]], $MachinePrecision]], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[(t - x), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.2 \cdot 10^{+71} \lor \neg \left(z \leq 3.2 \cdot 10^{+165}\right):\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;x - \left(t - x\right) \cdot \frac{z - y}{a - z}\\
\end{array}
\end{array}
if z < -6.20000000000000036e71 or 3.2e165 < z Initial program 25.7%
associate-*l/57.2%
Simplified57.2%
Taylor expanded in z around inf 62.8%
associate--l+62.8%
associate-*r/62.8%
associate-*r/62.8%
div-sub62.8%
distribute-lft-out--62.8%
associate-*r/62.8%
mul-1-neg62.8%
distribute-rgt-out--62.9%
unsub-neg62.9%
associate-/l*85.1%
Simplified85.1%
if -6.20000000000000036e71 < z < 3.2e165Initial program 83.7%
associate-*l/93.8%
Simplified93.8%
Final simplification91.2%
(FPCore (x y z t a)
:precision binary64
(if (<= a -4.8e+108)
x
(if (<= a -1.25e+59)
(* t (/ y a))
(if (<= a -5800000000000.0) x (if (<= a 1.95e+38) t x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -4.8e+108) {
tmp = x;
} else if (a <= -1.25e+59) {
tmp = t * (y / a);
} else if (a <= -5800000000000.0) {
tmp = x;
} else if (a <= 1.95e+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 <= (-4.8d+108)) then
tmp = x
else if (a <= (-1.25d+59)) then
tmp = t * (y / a)
else if (a <= (-5800000000000.0d0)) then
tmp = x
else if (a <= 1.95d+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 <= -4.8e+108) {
tmp = x;
} else if (a <= -1.25e+59) {
tmp = t * (y / a);
} else if (a <= -5800000000000.0) {
tmp = x;
} else if (a <= 1.95e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -4.8e+108: tmp = x elif a <= -1.25e+59: tmp = t * (y / a) elif a <= -5800000000000.0: tmp = x elif a <= 1.95e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -4.8e+108) tmp = x; elseif (a <= -1.25e+59) tmp = Float64(t * Float64(y / a)); elseif (a <= -5800000000000.0) tmp = x; elseif (a <= 1.95e+38) 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+108) tmp = x; elseif (a <= -1.25e+59) tmp = t * (y / a); elseif (a <= -5800000000000.0) tmp = x; elseif (a <= 1.95e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -4.8e+108], x, If[LessEqual[a, -1.25e+59], N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -5800000000000.0], x, If[LessEqual[a, 1.95e+38], t, x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4.8 \cdot 10^{+108}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.25 \cdot 10^{+59}:\\
\;\;\;\;t \cdot \frac{y}{a}\\
\mathbf{elif}\;a \leq -5800000000000:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.95 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -4.80000000000000037e108 or -1.2499999999999999e59 < a < -5.8e12 or 1.95000000000000012e38 < a Initial program 64.5%
associate-*l/88.0%
Simplified88.0%
Taylor expanded in a around inf 47.6%
if -4.80000000000000037e108 < a < -1.2499999999999999e59Initial program 82.3%
associate-*l/94.2%
Simplified94.2%
Taylor expanded in y around -inf 59.9%
associate-*l/60.3%
Simplified60.3%
Taylor expanded in t around inf 37.8%
associate-*r/38.1%
Simplified38.1%
Taylor expanded in a around inf 38.1%
if -5.8e12 < a < 1.95000000000000012e38Initial program 65.6%
associate-*l/76.2%
Simplified76.2%
Taylor expanded in z around inf 38.4%
Final simplification42.6%
(FPCore (x y z t a) :precision binary64 (if (<= a -8.8e+98) x (if (<= a -3.2) (* x (/ (- y) a)) (if (<= a 1.65e+38) t 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 <= -3.2) {
tmp = x * (-y / a);
} else if (a <= 1.65e+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 <= (-8.8d+98)) then
tmp = x
else if (a <= (-3.2d0)) then
tmp = x * (-y / a)
else if (a <= 1.65d+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 <= -8.8e+98) {
tmp = x;
} else if (a <= -3.2) {
tmp = x * (-y / a);
} else if (a <= 1.65e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -8.8e+98: tmp = x elif a <= -3.2: tmp = x * (-y / a) elif a <= 1.65e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -8.8e+98) tmp = x; elseif (a <= -3.2) tmp = Float64(x * Float64(Float64(-y) / a)); elseif (a <= 1.65e+38) tmp = t; 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 <= -3.2) tmp = x * (-y / a); elseif (a <= 1.65e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -8.8e+98], x, If[LessEqual[a, -3.2], N[(x * N[((-y) / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.65e+38], t, x]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -8.8 \cdot 10^{+98}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -3.2:\\
\;\;\;\;x \cdot \frac{-y}{a}\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -8.80000000000000034e98 or 1.65e38 < a Initial program 66.1%
associate-*l/89.1%
Simplified89.1%
Taylor expanded in a around inf 48.6%
if -8.80000000000000034e98 < a < -3.2000000000000002Initial program 72.2%
associate-*l/88.4%
Simplified88.4%
Taylor expanded in y around -inf 54.4%
associate-*l/61.4%
Simplified61.4%
Taylor expanded in t around 0 32.0%
mul-1-neg32.0%
associate-/l*38.8%
Simplified38.8%
Taylor expanded in a around inf 25.3%
*-lft-identity25.3%
times-frac32.1%
/-rgt-identity32.1%
Simplified32.1%
if -3.2000000000000002 < a < 1.65e38Initial program 65.1%
associate-*l/75.8%
Simplified75.8%
Taylor expanded in z around inf 39.0%
Final simplification42.4%
(FPCore (x y z t a) :precision binary64 (if (<= a -8.8e+98) x (if (<= a -4.1) (/ (- x) (/ a y)) (if (<= a 1.35e+38) t 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 <= -4.1) {
tmp = -x / (a / y);
} 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 <= (-8.8d+98)) then
tmp = x
else if (a <= (-4.1d0)) then
tmp = -x / (a / y)
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 <= -8.8e+98) {
tmp = x;
} else if (a <= -4.1) {
tmp = -x / (a / y);
} else if (a <= 1.35e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -8.8e+98: tmp = x elif a <= -4.1: tmp = -x / (a / y) elif a <= 1.35e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -8.8e+98) tmp = x; elseif (a <= -4.1) tmp = Float64(Float64(-x) / Float64(a / y)); 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 <= -8.8e+98) tmp = x; elseif (a <= -4.1) tmp = -x / (a / y); elseif (a <= 1.35e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -8.8e+98], x, If[LessEqual[a, -4.1], N[((-x) / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+38], t, x]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -8.8 \cdot 10^{+98}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -4.1:\\
\;\;\;\;\frac{-x}{\frac{a}{y}}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -8.80000000000000034e98 or 1.34999999999999998e38 < a Initial program 66.1%
associate-*l/89.1%
Simplified89.1%
Taylor expanded in a around inf 48.6%
if -8.80000000000000034e98 < a < -4.0999999999999996Initial program 72.2%
associate-*l/88.4%
Simplified88.4%
Taylor expanded in y around -inf 54.4%
associate-*l/61.4%
Simplified61.4%
Taylor expanded in t around 0 32.0%
mul-1-neg32.0%
associate-/l*38.8%
Simplified38.8%
Taylor expanded in a around inf 25.3%
associate-/l*32.1%
Simplified32.1%
if -4.0999999999999996 < a < 1.34999999999999998e38Initial program 65.1%
associate-*l/75.8%
Simplified75.8%
Taylor expanded in z around inf 39.0%
Final simplification42.4%
(FPCore (x y z t a) :precision binary64 (if (<= a -5600000000.0) x (if (<= a 1.18e+38) t x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -5600000000.0) {
tmp = x;
} else if (a <= 1.18e+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 <= (-5600000000.0d0)) then
tmp = x
else if (a <= 1.18d+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 <= -5600000000.0) {
tmp = x;
} else if (a <= 1.18e+38) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -5600000000.0: tmp = x elif a <= 1.18e+38: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -5600000000.0) tmp = x; elseif (a <= 1.18e+38) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -5600000000.0) tmp = x; elseif (a <= 1.18e+38) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -5600000000.0], x, If[LessEqual[a, 1.18e+38], t, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5600000000:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.18 \cdot 10^{+38}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -5.6e9 or 1.18e38 < a Initial program 66.8%
associate-*l/88.8%
Simplified88.8%
Taylor expanded in a around inf 42.7%
if -5.6e9 < a < 1.18e38Initial program 65.6%
associate-*l/76.2%
Simplified76.2%
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 66.2%
associate-*l/82.8%
Simplified82.8%
Taylor expanded in z around inf 24.6%
Final simplification24.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* (/ y z) (- t x)))))
(if (< z -1.2536131056095036e+188)
t_1
(if (< z 4.446702369113811e+64)
(+ x (/ (- y z) (/ (- a z) (- t x))))
t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - 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) * (t - x))
if (z < (-1.2536131056095036d+188)) then
tmp = t_1
else if (z < 4.446702369113811d+64) then
tmp = x + ((y - z) / ((a - z) / (t - 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) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - ((y / z) * (t - x)) tmp = 0 if z < -1.2536131056095036e+188: tmp = t_1 elif z < 4.446702369113811e+64: tmp = x + ((y - z) / ((a - z) / (t - x))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(Float64(y / z) * Float64(t - x))) tmp = 0.0 if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / Float64(t - x)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - ((y / z) * (t - x)); tmp = 0.0; if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = x + ((y - z) / ((a - z) / (t - 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[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -1.2536131056095036e+188], t$95$1, If[Less[z, 4.446702369113811e+64], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{y}{z} \cdot \left(t - x\right)\\
\mathbf{if}\;z < -1.2536131056095036 \cdot 10^{+188}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z < 4.446702369113811 \cdot 10^{+64}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
herbie shell --seed 2024027
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:invLinMap from Chart-1.5.3"
:precision binary64
:herbie-target
(if (< z -1.2536131056095036e+188) (- t (* (/ y z) (- t x))) (if (< z 4.446702369113811e+64) (+ x (/ (- y z) (/ (- a z) (- t x)))) (- t (* (/ y z) (- t x)))))
(+ x (/ (* (- y z) (- t x)) (- a z))))