
(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 19 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
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -5e-293) (not (<= t_1 0.0)))
(fma (/ (- y z) (- a z)) (- t x) x)
(fma (/ (- y a) z) (- x t) t))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-293) || !(t_1 <= 0.0)) {
tmp = fma(((y - z) / (a - z)), (t - x), x);
} else {
tmp = fma(((y - a) / z), (x - t), t);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -5e-293) || !(t_1 <= 0.0)) tmp = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x); else tmp = fma(Float64(Float64(y - a) / z), Float64(x - t), t); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-293], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], N[(N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision] * N[(x - t), $MachinePrecision] + t), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t_1 \leq -5 \cdot 10^{-293} \lor \neg \left(t_1 \leq 0\right):\\
\;\;\;\;\mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y - a}{z}, x - t, t\right)\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.0000000000000003e-293 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 72.6%
+-commutative72.6%
associate-*l/90.6%
fma-def90.6%
Simplified90.6%
if -5.0000000000000003e-293 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
associate-*l/3.9%
Simplified3.9%
Taylor expanded in z around inf 99.4%
associate--l+99.4%
associate-*r/99.4%
associate-*r/99.4%
div-sub99.4%
distribute-lft-out--99.4%
associate-*r/99.4%
distribute-rgt-out--99.4%
mul-1-neg99.4%
unsub-neg99.4%
associate-/l*99.4%
Simplified99.4%
Taylor expanded in t around -inf 99.4%
neg-mul-199.4%
unsub-neg99.4%
distribute-lft-out--99.4%
*-rgt-identity99.4%
associate-*r/99.7%
associate-+l-99.7%
distribute-rgt-out--99.7%
associate-*l/99.4%
associate-*r/99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
+-commutative99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
associate-*r/99.4%
associate-*l/99.7%
distribute-rgt-neg-in99.7%
fma-def99.8%
Simplified99.8%
Final simplification91.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -5e-293) (not (<= t_1 0.0)))
(+ x (* (- t x) (/ (- y z) (- a z))))
(fma (/ (- y a) z) (- x t) t))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-293) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = fma(((y - a) / z), (x - t), t);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -5e-293) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / Float64(a - z)))); else tmp = fma(Float64(Float64(y - a) / z), Float64(x - t), t); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-293], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision] * N[(x - t), $MachinePrecision] + t), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t_1 \leq -5 \cdot 10^{-293} \lor \neg \left(t_1 \leq 0\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y - a}{z}, x - t, t\right)\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.0000000000000003e-293 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 72.6%
associate-*l/90.6%
Simplified90.6%
if -5.0000000000000003e-293 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
associate-*l/3.9%
Simplified3.9%
Taylor expanded in z around inf 99.4%
associate--l+99.4%
associate-*r/99.4%
associate-*r/99.4%
div-sub99.4%
distribute-lft-out--99.4%
associate-*r/99.4%
distribute-rgt-out--99.4%
mul-1-neg99.4%
unsub-neg99.4%
associate-/l*99.4%
Simplified99.4%
Taylor expanded in t around -inf 99.4%
neg-mul-199.4%
unsub-neg99.4%
distribute-lft-out--99.4%
*-rgt-identity99.4%
associate-*r/99.7%
associate-+l-99.7%
distribute-rgt-out--99.7%
associate-*l/99.4%
associate-*r/99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
+-commutative99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
associate-*r/99.4%
associate-*l/99.7%
distribute-rgt-neg-in99.7%
fma-def99.8%
Simplified99.8%
Final simplification91.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -5e-293) (not (<= t_1 0.0)))
(+ x (* (- t x) (/ (- y z) (- a z))))
(+ t (/ (- x t) (/ z (- y a)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-293) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (((y - z) * (t - x)) / (a - z))
if ((t_1 <= (-5d-293)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x + ((t - x) * ((y - z) / (a - z)))
else
tmp = t + ((x - t) / (z / (y - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-293) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - z) * (t - x)) / (a - z)) tmp = 0 if (t_1 <= -5e-293) or not (t_1 <= 0.0): tmp = x + ((t - x) * ((y - z) / (a - z))) else: tmp = t + ((x - t) / (z / (y - a))) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -5e-293) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((y - z) * (t - x)) / (a - z)); tmp = 0.0; if ((t_1 <= -5e-293) || ~((t_1 <= 0.0))) tmp = x + ((t - x) * ((y - z) / (a - z))); else tmp = t + ((x - t) / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-293], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t_1 \leq -5 \cdot 10^{-293} \lor \neg \left(t_1 \leq 0\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.0000000000000003e-293 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 72.6%
associate-*l/90.6%
Simplified90.6%
if -5.0000000000000003e-293 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
associate-*l/3.9%
Simplified3.9%
Taylor expanded in z around inf 99.4%
associate--l+99.4%
associate-*r/99.4%
associate-*r/99.4%
div-sub99.4%
distribute-lft-out--99.4%
associate-*r/99.4%
distribute-rgt-out--99.4%
mul-1-neg99.4%
unsub-neg99.4%
associate-/l*99.4%
Simplified99.4%
Final simplification91.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (+ t (/ (- x t) (/ z (- y a))))))
(if (<= z -1.35e+94)
t_2
(if (<= z -4.1e+41)
(+ x (/ y (/ a (- t x))))
(if (<= z -2e+36)
(* x (/ (- y a) z))
(if (<= z -1.1e+14)
(+ x (* z (/ (- x t) (- a z))))
(if (<= z -2.1e-24)
t_1
(if (<= z -2.9e-75)
(* x (+ (/ (- z y) (- a z)) 1.0))
(if (<= z -4.5e-95)
t_1
(if (<= z 1.8e+61) (+ x (* (- t x) (/ y a))) t_2))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = t + ((x - t) / (z / (y - a)));
double tmp;
if (z <= -1.35e+94) {
tmp = t_2;
} else if (z <= -4.1e+41) {
tmp = x + (y / (a / (t - x)));
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -1.1e+14) {
tmp = x + (z * ((x - t) / (a - z)));
} else if (z <= -2.1e-24) {
tmp = t_1;
} else if (z <= -2.9e-75) {
tmp = x * (((z - y) / (a - z)) + 1.0);
} else if (z <= -4.5e-95) {
tmp = t_1;
} else if (z <= 1.8e+61) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = t + ((x - t) / (z / (y - a)))
if (z <= (-1.35d+94)) then
tmp = t_2
else if (z <= (-4.1d+41)) then
tmp = x + (y / (a / (t - x)))
else if (z <= (-2d+36)) then
tmp = x * ((y - a) / z)
else if (z <= (-1.1d+14)) then
tmp = x + (z * ((x - t) / (a - z)))
else if (z <= (-2.1d-24)) then
tmp = t_1
else if (z <= (-2.9d-75)) then
tmp = x * (((z - y) / (a - z)) + 1.0d0)
else if (z <= (-4.5d-95)) then
tmp = t_1
else if (z <= 1.8d+61) then
tmp = x + ((t - x) * (y / a))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = t + ((x - t) / (z / (y - a)));
double tmp;
if (z <= -1.35e+94) {
tmp = t_2;
} else if (z <= -4.1e+41) {
tmp = x + (y / (a / (t - x)));
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -1.1e+14) {
tmp = x + (z * ((x - t) / (a - z)));
} else if (z <= -2.1e-24) {
tmp = t_1;
} else if (z <= -2.9e-75) {
tmp = x * (((z - y) / (a - z)) + 1.0);
} else if (z <= -4.5e-95) {
tmp = t_1;
} else if (z <= 1.8e+61) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = t + ((x - t) / (z / (y - a))) tmp = 0 if z <= -1.35e+94: tmp = t_2 elif z <= -4.1e+41: tmp = x + (y / (a / (t - x))) elif z <= -2e+36: tmp = x * ((y - a) / z) elif z <= -1.1e+14: tmp = x + (z * ((x - t) / (a - z))) elif z <= -2.1e-24: tmp = t_1 elif z <= -2.9e-75: tmp = x * (((z - y) / (a - z)) + 1.0) elif z <= -4.5e-95: tmp = t_1 elif z <= 1.8e+61: tmp = x + ((t - x) * (y / a)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))) tmp = 0.0 if (z <= -1.35e+94) tmp = t_2; elseif (z <= -4.1e+41) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); elseif (z <= -2e+36) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= -1.1e+14) tmp = Float64(x + Float64(z * Float64(Float64(x - t) / Float64(a - z)))); elseif (z <= -2.1e-24) tmp = t_1; elseif (z <= -2.9e-75) tmp = Float64(x * Float64(Float64(Float64(z - y) / Float64(a - z)) + 1.0)); elseif (z <= -4.5e-95) tmp = t_1; elseif (z <= 1.8e+61) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = t + ((x - t) / (z / (y - a))); tmp = 0.0; if (z <= -1.35e+94) tmp = t_2; elseif (z <= -4.1e+41) tmp = x + (y / (a / (t - x))); elseif (z <= -2e+36) tmp = x * ((y - a) / z); elseif (z <= -1.1e+14) tmp = x + (z * ((x - t) / (a - z))); elseif (z <= -2.1e-24) tmp = t_1; elseif (z <= -2.9e-75) tmp = x * (((z - y) / (a - z)) + 1.0); elseif (z <= -4.5e-95) tmp = t_1; elseif (z <= 1.8e+61) tmp = x + ((t - x) * (y / a)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.35e+94], t$95$2, If[LessEqual[z, -4.1e+41], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2e+36], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.1e+14], N[(x + N[(z * N[(N[(x - t), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.1e-24], t$95$1, If[LessEqual[z, -2.9e-75], N[(x * N[(N[(N[(z - y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.5e-95], t$95$1, If[LessEqual[z, 1.8e+61], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := t + \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{if}\;z \leq -1.35 \cdot 10^{+94}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -4.1 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{elif}\;z \leq -2 \cdot 10^{+36}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq -1.1 \cdot 10^{+14}:\\
\;\;\;\;x + z \cdot \frac{x - t}{a - z}\\
\mathbf{elif}\;z \leq -2.1 \cdot 10^{-24}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -2.9 \cdot 10^{-75}:\\
\;\;\;\;x \cdot \left(\frac{z - y}{a - z} + 1\right)\\
\mathbf{elif}\;z \leq -4.5 \cdot 10^{-95}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.8 \cdot 10^{+61}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -1.3500000000000001e94 or 1.80000000000000005e61 < z Initial program 44.3%
associate-*l/71.9%
Simplified71.9%
Taylor expanded in z around inf 64.0%
associate--l+64.0%
associate-*r/64.0%
associate-*r/64.0%
div-sub64.0%
distribute-lft-out--64.0%
associate-*r/64.0%
distribute-rgt-out--64.1%
mul-1-neg64.1%
unsub-neg64.1%
associate-/l*84.1%
Simplified84.1%
if -1.3500000000000001e94 < z < -4.1000000000000004e41Initial program 58.0%
associate-*l/89.0%
Simplified89.0%
Taylor expanded in z around 0 63.2%
associate-/l*80.8%
Simplified80.8%
if -4.1000000000000004e41 < z < -2.00000000000000008e36Initial program 2.8%
associate-*l/2.8%
Simplified2.8%
Taylor expanded in z around inf 99.2%
associate--l+99.2%
associate-*r/99.2%
associate-*r/99.2%
div-sub99.2%
distribute-lft-out--99.2%
associate-*r/99.2%
distribute-rgt-out--99.2%
mul-1-neg99.2%
unsub-neg99.2%
associate-/l*99.6%
Simplified99.6%
Taylor expanded in t around 0 99.2%
associate-*r/100.0%
Simplified100.0%
if -2.00000000000000008e36 < z < -1.1e14Initial program 80.6%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in y around 0 80.6%
mul-1-neg80.6%
associate-*r/100.0%
unsub-neg100.0%
Simplified100.0%
if -1.1e14 < z < -2.0999999999999999e-24 or -2.9000000000000002e-75 < z < -4.5e-95Initial program 89.2%
associate-*l/89.2%
Simplified89.2%
Taylor expanded in x around 0 78.5%
associate-*r/89.0%
Simplified89.0%
if -2.0999999999999999e-24 < z < -2.9000000000000002e-75Initial program 90.6%
associate-*l/90.5%
Simplified90.5%
Taylor expanded in x around inf 80.1%
mul-1-neg80.1%
unsub-neg80.1%
Simplified80.1%
if -4.5e-95 < z < 1.80000000000000005e61Initial program 87.1%
associate-*l/96.1%
Simplified96.1%
Taylor expanded in z around 0 79.5%
Final simplification82.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ a (- t x))) (t_2 (+ t (/ (- x t) (/ z (- y a))))))
(if (<= z -1.35e+94)
t_2
(if (<= z -5.5e+41)
(+ x (/ y t_1))
(if (<= z -2e+36)
(* x (/ (- y a) z))
(if (<= z -37000000000000.0)
(- x (/ z t_1))
(if (<= z -1.55e-9)
t_2
(if (<= z -6.6e-63)
(* y (/ (- t x) (- a z)))
(if (<= z 8.5e+61) (+ x (* (- t x) (/ y a))) t_2)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = a / (t - x);
double t_2 = t + ((x - t) / (z / (y - a)));
double tmp;
if (z <= -1.35e+94) {
tmp = t_2;
} else if (z <= -5.5e+41) {
tmp = x + (y / t_1);
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -37000000000000.0) {
tmp = x - (z / t_1);
} else if (z <= -1.55e-9) {
tmp = t_2;
} else if (z <= -6.6e-63) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 8.5e+61) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a / (t - x)
t_2 = t + ((x - t) / (z / (y - a)))
if (z <= (-1.35d+94)) then
tmp = t_2
else if (z <= (-5.5d+41)) then
tmp = x + (y / t_1)
else if (z <= (-2d+36)) then
tmp = x * ((y - a) / z)
else if (z <= (-37000000000000.0d0)) then
tmp = x - (z / t_1)
else if (z <= (-1.55d-9)) then
tmp = t_2
else if (z <= (-6.6d-63)) then
tmp = y * ((t - x) / (a - z))
else if (z <= 8.5d+61) then
tmp = x + ((t - x) * (y / a))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = a / (t - x);
double t_2 = t + ((x - t) / (z / (y - a)));
double tmp;
if (z <= -1.35e+94) {
tmp = t_2;
} else if (z <= -5.5e+41) {
tmp = x + (y / t_1);
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -37000000000000.0) {
tmp = x - (z / t_1);
} else if (z <= -1.55e-9) {
tmp = t_2;
} else if (z <= -6.6e-63) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 8.5e+61) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = a / (t - x) t_2 = t + ((x - t) / (z / (y - a))) tmp = 0 if z <= -1.35e+94: tmp = t_2 elif z <= -5.5e+41: tmp = x + (y / t_1) elif z <= -2e+36: tmp = x * ((y - a) / z) elif z <= -37000000000000.0: tmp = x - (z / t_1) elif z <= -1.55e-9: tmp = t_2 elif z <= -6.6e-63: tmp = y * ((t - x) / (a - z)) elif z <= 8.5e+61: tmp = x + ((t - x) * (y / a)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(a / Float64(t - x)) t_2 = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))) tmp = 0.0 if (z <= -1.35e+94) tmp = t_2; elseif (z <= -5.5e+41) tmp = Float64(x + Float64(y / t_1)); elseif (z <= -2e+36) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= -37000000000000.0) tmp = Float64(x - Float64(z / t_1)); elseif (z <= -1.55e-9) tmp = t_2; elseif (z <= -6.6e-63) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (z <= 8.5e+61) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = a / (t - x); t_2 = t + ((x - t) / (z / (y - a))); tmp = 0.0; if (z <= -1.35e+94) tmp = t_2; elseif (z <= -5.5e+41) tmp = x + (y / t_1); elseif (z <= -2e+36) tmp = x * ((y - a) / z); elseif (z <= -37000000000000.0) tmp = x - (z / t_1); elseif (z <= -1.55e-9) tmp = t_2; elseif (z <= -6.6e-63) tmp = y * ((t - x) / (a - z)); elseif (z <= 8.5e+61) tmp = x + ((t - x) * (y / a)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.35e+94], t$95$2, If[LessEqual[z, -5.5e+41], N[(x + N[(y / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2e+36], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -37000000000000.0], N[(x - N[(z / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.55e-9], t$95$2, If[LessEqual[z, -6.6e-63], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.5e+61], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{a}{t - x}\\
t_2 := t + \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{if}\;z \leq -1.35 \cdot 10^{+94}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -5.5 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{t_1}\\
\mathbf{elif}\;z \leq -2 \cdot 10^{+36}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq -37000000000000:\\
\;\;\;\;x - \frac{z}{t_1}\\
\mathbf{elif}\;z \leq -1.55 \cdot 10^{-9}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -6.6 \cdot 10^{-63}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;z \leq 8.5 \cdot 10^{+61}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -1.3500000000000001e94 or -3.7e13 < z < -1.55000000000000002e-9 or 8.50000000000000035e61 < z Initial program 45.9%
associate-*l/72.3%
Simplified72.3%
Taylor expanded in z around inf 64.7%
associate--l+64.7%
associate-*r/64.7%
associate-*r/64.7%
div-sub64.7%
distribute-lft-out--64.7%
associate-*r/64.7%
distribute-rgt-out--64.9%
mul-1-neg64.9%
unsub-neg64.9%
associate-/l*83.9%
Simplified83.9%
if -1.3500000000000001e94 < z < -5.5000000000000003e41Initial program 58.0%
associate-*l/89.0%
Simplified89.0%
Taylor expanded in z around 0 63.2%
associate-/l*80.8%
Simplified80.8%
if -5.5000000000000003e41 < z < -2.00000000000000008e36Initial program 2.8%
associate-*l/2.8%
Simplified2.8%
Taylor expanded in z around inf 99.2%
associate--l+99.2%
associate-*r/99.2%
associate-*r/99.2%
div-sub99.2%
distribute-lft-out--99.2%
associate-*r/99.2%
distribute-rgt-out--99.2%
mul-1-neg99.2%
unsub-neg99.2%
associate-/l*99.6%
Simplified99.6%
Taylor expanded in t around 0 99.2%
associate-*r/100.0%
Simplified100.0%
if -2.00000000000000008e36 < z < -3.7e13Initial program 80.6%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in y around 0 80.6%
mul-1-neg80.6%
associate-*r/100.0%
unsub-neg100.0%
Simplified100.0%
Taylor expanded in a around inf 80.6%
mul-1-neg80.6%
unsub-neg80.6%
associate-/l*99.7%
Simplified99.7%
if -1.55000000000000002e-9 < z < -6.59999999999999987e-63Initial program 86.5%
associate-*l/86.4%
Simplified86.4%
Taylor expanded in y around inf 85.9%
div-sub85.9%
Simplified85.9%
if -6.59999999999999987e-63 < z < 8.50000000000000035e61Initial program 87.9%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in z around 0 79.1%
Final simplification82.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ a (- t x))) (t_2 (+ t (* y (/ (- x t) z)))))
(if (<= z -1.65e+94)
t_2
(if (<= z -3.4e+41)
(+ x (/ y t_1))
(if (<= z -2e+36)
(* x (/ (- y a) z))
(if (<= z -1.05e+14)
(- x (/ z t_1))
(if (<= z -6.2e-10)
(* t (/ (- y z) (- a z)))
(if (<= z -3.4e-63)
(* y (/ (- t x) (- a z)))
(if (<= z 6.6e+64) (+ x (* (- t x) (/ y a))) t_2)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = a / (t - x);
double t_2 = t + (y * ((x - t) / z));
double tmp;
if (z <= -1.65e+94) {
tmp = t_2;
} else if (z <= -3.4e+41) {
tmp = x + (y / t_1);
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -1.05e+14) {
tmp = x - (z / t_1);
} else if (z <= -6.2e-10) {
tmp = t * ((y - z) / (a - z));
} else if (z <= -3.4e-63) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 6.6e+64) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a / (t - x)
t_2 = t + (y * ((x - t) / z))
if (z <= (-1.65d+94)) then
tmp = t_2
else if (z <= (-3.4d+41)) then
tmp = x + (y / t_1)
else if (z <= (-2d+36)) then
tmp = x * ((y - a) / z)
else if (z <= (-1.05d+14)) then
tmp = x - (z / t_1)
else if (z <= (-6.2d-10)) then
tmp = t * ((y - z) / (a - z))
else if (z <= (-3.4d-63)) then
tmp = y * ((t - x) / (a - z))
else if (z <= 6.6d+64) then
tmp = x + ((t - x) * (y / a))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = a / (t - x);
double t_2 = t + (y * ((x - t) / z));
double tmp;
if (z <= -1.65e+94) {
tmp = t_2;
} else if (z <= -3.4e+41) {
tmp = x + (y / t_1);
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -1.05e+14) {
tmp = x - (z / t_1);
} else if (z <= -6.2e-10) {
tmp = t * ((y - z) / (a - z));
} else if (z <= -3.4e-63) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 6.6e+64) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = a / (t - x) t_2 = t + (y * ((x - t) / z)) tmp = 0 if z <= -1.65e+94: tmp = t_2 elif z <= -3.4e+41: tmp = x + (y / t_1) elif z <= -2e+36: tmp = x * ((y - a) / z) elif z <= -1.05e+14: tmp = x - (z / t_1) elif z <= -6.2e-10: tmp = t * ((y - z) / (a - z)) elif z <= -3.4e-63: tmp = y * ((t - x) / (a - z)) elif z <= 6.6e+64: tmp = x + ((t - x) * (y / a)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(a / Float64(t - x)) t_2 = Float64(t + Float64(y * Float64(Float64(x - t) / z))) tmp = 0.0 if (z <= -1.65e+94) tmp = t_2; elseif (z <= -3.4e+41) tmp = Float64(x + Float64(y / t_1)); elseif (z <= -2e+36) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= -1.05e+14) tmp = Float64(x - Float64(z / t_1)); elseif (z <= -6.2e-10) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); elseif (z <= -3.4e-63) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (z <= 6.6e+64) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = a / (t - x); t_2 = t + (y * ((x - t) / z)); tmp = 0.0; if (z <= -1.65e+94) tmp = t_2; elseif (z <= -3.4e+41) tmp = x + (y / t_1); elseif (z <= -2e+36) tmp = x * ((y - a) / z); elseif (z <= -1.05e+14) tmp = x - (z / t_1); elseif (z <= -6.2e-10) tmp = t * ((y - z) / (a - z)); elseif (z <= -3.4e-63) tmp = y * ((t - x) / (a - z)); elseif (z <= 6.6e+64) tmp = x + ((t - x) * (y / a)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.65e+94], t$95$2, If[LessEqual[z, -3.4e+41], N[(x + N[(y / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2e+36], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.05e+14], N[(x - N[(z / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -6.2e-10], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.4e-63], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.6e+64], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{a}{t - x}\\
t_2 := t + y \cdot \frac{x - t}{z}\\
\mathbf{if}\;z \leq -1.65 \cdot 10^{+94}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -3.4 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{t_1}\\
\mathbf{elif}\;z \leq -2 \cdot 10^{+36}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq -1.05 \cdot 10^{+14}:\\
\;\;\;\;x - \frac{z}{t_1}\\
\mathbf{elif}\;z \leq -6.2 \cdot 10^{-10}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{elif}\;z \leq -3.4 \cdot 10^{-63}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;z \leq 6.6 \cdot 10^{+64}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -1.65e94 or 6.59999999999999976e64 < z Initial program 44.3%
associate-*l/71.9%
Simplified71.9%
Taylor expanded in z around inf 64.0%
associate--l+64.0%
associate-*r/64.0%
associate-*r/64.0%
div-sub64.0%
distribute-lft-out--64.0%
associate-*r/64.0%
distribute-rgt-out--64.1%
mul-1-neg64.1%
unsub-neg64.1%
associate-/l*84.1%
Simplified84.1%
Taylor expanded in y around inf 60.3%
associate-*r/71.2%
Simplified71.2%
if -1.65e94 < z < -3.39999999999999998e41Initial program 58.0%
associate-*l/89.0%
Simplified89.0%
Taylor expanded in z around 0 63.2%
associate-/l*80.8%
Simplified80.8%
if -3.39999999999999998e41 < z < -2.00000000000000008e36Initial program 2.8%
associate-*l/2.8%
Simplified2.8%
Taylor expanded in z around inf 99.2%
associate--l+99.2%
associate-*r/99.2%
associate-*r/99.2%
div-sub99.2%
distribute-lft-out--99.2%
associate-*r/99.2%
distribute-rgt-out--99.2%
mul-1-neg99.2%
unsub-neg99.2%
associate-/l*99.6%
Simplified99.6%
Taylor expanded in t around 0 99.2%
associate-*r/100.0%
Simplified100.0%
if -2.00000000000000008e36 < z < -1.05e14Initial program 80.6%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in y around 0 80.6%
mul-1-neg80.6%
associate-*r/100.0%
unsub-neg100.0%
Simplified100.0%
Taylor expanded in a around inf 80.6%
mul-1-neg80.6%
unsub-neg80.6%
associate-/l*99.7%
Simplified99.7%
if -1.05e14 < z < -6.2000000000000003e-10Initial program 80.5%
associate-*l/80.5%
Simplified80.5%
Taylor expanded in x around 0 80.3%
associate-*r/80.3%
Simplified80.3%
if -6.2000000000000003e-10 < z < -3.39999999999999998e-63Initial program 86.5%
associate-*l/86.4%
Simplified86.4%
Taylor expanded in y around inf 85.9%
div-sub85.9%
Simplified85.9%
if -3.39999999999999998e-63 < z < 6.59999999999999976e64Initial program 87.9%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in z around 0 79.1%
Final simplification76.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ y a)))))
(if (<= a -3e+41)
t_1
(if (<= a -2.2e-155)
(* y (/ (- t x) (- a z)))
(if (<= a -7e-309)
(/ (- t) (/ z (- y z)))
(if (<= a 1.05e-228)
(/ (- y) (/ z (- t x)))
(if (<= a 2.2e+119) (* t (/ (- y z) (- a z))) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double tmp;
if (a <= -3e+41) {
tmp = t_1;
} else if (a <= -2.2e-155) {
tmp = y * ((t - x) / (a - z));
} else if (a <= -7e-309) {
tmp = -t / (z / (y - z));
} else if (a <= 1.05e-228) {
tmp = -y / (z / (t - x));
} else if (a <= 2.2e+119) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (t * (y / a))
if (a <= (-3d+41)) then
tmp = t_1
else if (a <= (-2.2d-155)) then
tmp = y * ((t - x) / (a - z))
else if (a <= (-7d-309)) then
tmp = -t / (z / (y - z))
else if (a <= 1.05d-228) then
tmp = -y / (z / (t - x))
else if (a <= 2.2d+119) then
tmp = t * ((y - z) / (a - z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double tmp;
if (a <= -3e+41) {
tmp = t_1;
} else if (a <= -2.2e-155) {
tmp = y * ((t - x) / (a - z));
} else if (a <= -7e-309) {
tmp = -t / (z / (y - z));
} else if (a <= 1.05e-228) {
tmp = -y / (z / (t - x));
} else if (a <= 2.2e+119) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * (y / a)) tmp = 0 if a <= -3e+41: tmp = t_1 elif a <= -2.2e-155: tmp = y * ((t - x) / (a - z)) elif a <= -7e-309: tmp = -t / (z / (y - z)) elif a <= 1.05e-228: tmp = -y / (z / (t - x)) elif a <= 2.2e+119: tmp = t * ((y - z) / (a - z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(y / a))) tmp = 0.0 if (a <= -3e+41) tmp = t_1; elseif (a <= -2.2e-155) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= -7e-309) tmp = Float64(Float64(-t) / Float64(z / Float64(y - z))); elseif (a <= 1.05e-228) tmp = Float64(Float64(-y) / Float64(z / Float64(t - x))); elseif (a <= 2.2e+119) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * (y / a)); tmp = 0.0; if (a <= -3e+41) tmp = t_1; elseif (a <= -2.2e-155) tmp = y * ((t - x) / (a - z)); elseif (a <= -7e-309) tmp = -t / (z / (y - z)); elseif (a <= 1.05e-228) tmp = -y / (z / (t - x)); elseif (a <= 2.2e+119) tmp = t * ((y - z) / (a - z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3e+41], t$95$1, If[LessEqual[a, -2.2e-155], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -7e-309], N[((-t) / N[(z / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.05e-228], N[((-y) / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.2e+119], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -3 \cdot 10^{+41}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -2.2 \cdot 10^{-155}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq -7 \cdot 10^{-309}:\\
\;\;\;\;\frac{-t}{\frac{z}{y - z}}\\
\mathbf{elif}\;a \leq 1.05 \cdot 10^{-228}:\\
\;\;\;\;\frac{-y}{\frac{z}{t - x}}\\
\mathbf{elif}\;a \leq 2.2 \cdot 10^{+119}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -2.9999999999999998e41 or 2.2000000000000001e119 < a Initial program 71.5%
associate-*l/90.5%
Simplified90.5%
Taylor expanded in z around 0 71.3%
Taylor expanded in t around inf 62.5%
associate-*r/66.4%
Simplified66.4%
if -2.9999999999999998e41 < a < -2.1999999999999999e-155Initial program 62.2%
associate-*l/67.6%
Simplified67.6%
Taylor expanded in y around inf 50.3%
div-sub50.3%
Simplified50.3%
if -2.1999999999999999e-155 < a < -6.9999999999999984e-309Initial program 65.7%
associate-*l/79.3%
Simplified79.3%
Taylor expanded in x around 0 60.8%
Taylor expanded in a around 0 64.7%
mul-1-neg64.7%
associate-/l*74.8%
distribute-neg-frac74.8%
Simplified74.8%
if -6.9999999999999984e-309 < a < 1.04999999999999995e-228Initial program 78.4%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in y around -inf 77.8%
associate-*l/84.8%
Simplified84.8%
Taylor expanded in a around 0 77.8%
mul-1-neg77.8%
associate-/l*84.9%
distribute-neg-frac84.9%
Simplified84.9%
if 1.04999999999999995e-228 < a < 2.2000000000000001e119Initial program 61.9%
associate-*l/82.9%
Simplified82.9%
Taylor expanded in x around 0 43.5%
associate-*r/60.8%
Simplified60.8%
Final simplification64.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ y a)))))
(if (<= a -1.15e+39)
t_1
(if (<= a -2.1e-149)
(* (- t x) (/ y (- a z)))
(if (<= a 2.7e-306)
(/ (- t) (/ z (- y z)))
(if (<= a 1.85e-228)
(/ (- y) (/ z (- t x)))
(if (<= a 3.4e+115) (* t (/ (- y z) (- a z))) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double tmp;
if (a <= -1.15e+39) {
tmp = t_1;
} else if (a <= -2.1e-149) {
tmp = (t - x) * (y / (a - z));
} else if (a <= 2.7e-306) {
tmp = -t / (z / (y - z));
} else if (a <= 1.85e-228) {
tmp = -y / (z / (t - x));
} else if (a <= 3.4e+115) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (t * (y / a))
if (a <= (-1.15d+39)) then
tmp = t_1
else if (a <= (-2.1d-149)) then
tmp = (t - x) * (y / (a - z))
else if (a <= 2.7d-306) then
tmp = -t / (z / (y - z))
else if (a <= 1.85d-228) then
tmp = -y / (z / (t - x))
else if (a <= 3.4d+115) then
tmp = t * ((y - z) / (a - z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double tmp;
if (a <= -1.15e+39) {
tmp = t_1;
} else if (a <= -2.1e-149) {
tmp = (t - x) * (y / (a - z));
} else if (a <= 2.7e-306) {
tmp = -t / (z / (y - z));
} else if (a <= 1.85e-228) {
tmp = -y / (z / (t - x));
} else if (a <= 3.4e+115) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * (y / a)) tmp = 0 if a <= -1.15e+39: tmp = t_1 elif a <= -2.1e-149: tmp = (t - x) * (y / (a - z)) elif a <= 2.7e-306: tmp = -t / (z / (y - z)) elif a <= 1.85e-228: tmp = -y / (z / (t - x)) elif a <= 3.4e+115: tmp = t * ((y - z) / (a - z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(y / a))) tmp = 0.0 if (a <= -1.15e+39) tmp = t_1; elseif (a <= -2.1e-149) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); elseif (a <= 2.7e-306) tmp = Float64(Float64(-t) / Float64(z / Float64(y - z))); elseif (a <= 1.85e-228) tmp = Float64(Float64(-y) / Float64(z / Float64(t - x))); elseif (a <= 3.4e+115) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * (y / a)); tmp = 0.0; if (a <= -1.15e+39) tmp = t_1; elseif (a <= -2.1e-149) tmp = (t - x) * (y / (a - z)); elseif (a <= 2.7e-306) tmp = -t / (z / (y - z)); elseif (a <= 1.85e-228) tmp = -y / (z / (t - x)); elseif (a <= 3.4e+115) tmp = t * ((y - z) / (a - z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.15e+39], t$95$1, If[LessEqual[a, -2.1e-149], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.7e-306], N[((-t) / N[(z / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.85e-228], N[((-y) / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.4e+115], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -1.15 \cdot 10^{+39}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -2.1 \cdot 10^{-149}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-306}:\\
\;\;\;\;\frac{-t}{\frac{z}{y - z}}\\
\mathbf{elif}\;a \leq 1.85 \cdot 10^{-228}:\\
\;\;\;\;\frac{-y}{\frac{z}{t - x}}\\
\mathbf{elif}\;a \leq 3.4 \cdot 10^{+115}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -1.15000000000000006e39 or 3.4000000000000001e115 < a Initial program 71.5%
associate-*l/90.5%
Simplified90.5%
Taylor expanded in z around 0 71.3%
Taylor expanded in t around inf 62.5%
associate-*r/66.4%
Simplified66.4%
if -1.15000000000000006e39 < a < -2.10000000000000011e-149Initial program 62.2%
associate-*l/67.6%
Simplified67.6%
Taylor expanded in y around -inf 42.5%
associate-*l/50.4%
Simplified50.4%
if -2.10000000000000011e-149 < a < 2.70000000000000009e-306Initial program 65.7%
associate-*l/79.3%
Simplified79.3%
Taylor expanded in x around 0 60.8%
Taylor expanded in a around 0 64.7%
mul-1-neg64.7%
associate-/l*74.8%
distribute-neg-frac74.8%
Simplified74.8%
if 2.70000000000000009e-306 < a < 1.85e-228Initial program 78.4%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in y around -inf 77.8%
associate-*l/84.8%
Simplified84.8%
Taylor expanded in a around 0 77.8%
mul-1-neg77.8%
associate-/l*84.9%
distribute-neg-frac84.9%
Simplified84.9%
if 1.85e-228 < a < 3.4000000000000001e115Initial program 61.9%
associate-*l/82.9%
Simplified82.9%
Taylor expanded in x around 0 43.5%
associate-*r/60.8%
Simplified60.8%
Final simplification64.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* y (/ (- x t) z)))))
(if (<= z -1.65e+94)
t_1
(if (<= z -3.4e+41)
(+ x (/ y (/ a (- t x))))
(if (<= z -2e+36)
(* x (/ (- y a) z))
(if (<= z -4.9e-45)
(* t (/ (- y z) (- a z)))
(if (<= z 2e+62) (+ x (* (- t x) (/ y a))) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -1.65e+94) {
tmp = t_1;
} else if (z <= -3.4e+41) {
tmp = x + (y / (a / (t - x)));
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -4.9e-45) {
tmp = t * ((y - z) / (a - z));
} else if (z <= 2e+62) {
tmp = x + ((t - x) * (y / a));
} 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 * ((x - t) / z))
if (z <= (-1.65d+94)) then
tmp = t_1
else if (z <= (-3.4d+41)) then
tmp = x + (y / (a / (t - x)))
else if (z <= (-2d+36)) then
tmp = x * ((y - a) / z)
else if (z <= (-4.9d-45)) then
tmp = t * ((y - z) / (a - z))
else if (z <= 2d+62) then
tmp = x + ((t - x) * (y / a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -1.65e+94) {
tmp = t_1;
} else if (z <= -3.4e+41) {
tmp = x + (y / (a / (t - x)));
} else if (z <= -2e+36) {
tmp = x * ((y - a) / z);
} else if (z <= -4.9e-45) {
tmp = t * ((y - z) / (a - z));
} else if (z <= 2e+62) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (y * ((x - t) / z)) tmp = 0 if z <= -1.65e+94: tmp = t_1 elif z <= -3.4e+41: tmp = x + (y / (a / (t - x))) elif z <= -2e+36: tmp = x * ((y - a) / z) elif z <= -4.9e-45: tmp = t * ((y - z) / (a - z)) elif z <= 2e+62: tmp = x + ((t - x) * (y / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(y * Float64(Float64(x - t) / z))) tmp = 0.0 if (z <= -1.65e+94) tmp = t_1; elseif (z <= -3.4e+41) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); elseif (z <= -2e+36) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= -4.9e-45) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); elseif (z <= 2e+62) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (y * ((x - t) / z)); tmp = 0.0; if (z <= -1.65e+94) tmp = t_1; elseif (z <= -3.4e+41) tmp = x + (y / (a / (t - x))); elseif (z <= -2e+36) tmp = x * ((y - a) / z); elseif (z <= -4.9e-45) tmp = t * ((y - z) / (a - z)); elseif (z <= 2e+62) tmp = x + ((t - x) * (y / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.65e+94], t$95$1, If[LessEqual[z, -3.4e+41], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2e+36], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.9e-45], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2e+62], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot \frac{x - t}{z}\\
\mathbf{if}\;z \leq -1.65 \cdot 10^{+94}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -3.4 \cdot 10^{+41}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{elif}\;z \leq -2 \cdot 10^{+36}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq -4.9 \cdot 10^{-45}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{elif}\;z \leq 2 \cdot 10^{+62}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.65e94 or 2.00000000000000007e62 < z Initial program 44.3%
associate-*l/71.9%
Simplified71.9%
Taylor expanded in z around inf 64.0%
associate--l+64.0%
associate-*r/64.0%
associate-*r/64.0%
div-sub64.0%
distribute-lft-out--64.0%
associate-*r/64.0%
distribute-rgt-out--64.1%
mul-1-neg64.1%
unsub-neg64.1%
associate-/l*84.1%
Simplified84.1%
Taylor expanded in y around inf 60.3%
associate-*r/71.2%
Simplified71.2%
if -1.65e94 < z < -3.39999999999999998e41Initial program 58.0%
associate-*l/89.0%
Simplified89.0%
Taylor expanded in z around 0 63.2%
associate-/l*80.8%
Simplified80.8%
if -3.39999999999999998e41 < z < -2.00000000000000008e36Initial program 2.8%
associate-*l/2.8%
Simplified2.8%
Taylor expanded in z around inf 99.2%
associate--l+99.2%
associate-*r/99.2%
associate-*r/99.2%
div-sub99.2%
distribute-lft-out--99.2%
associate-*r/99.2%
distribute-rgt-out--99.2%
mul-1-neg99.2%
unsub-neg99.2%
associate-/l*99.6%
Simplified99.6%
Taylor expanded in t around 0 99.2%
associate-*r/100.0%
Simplified100.0%
if -2.00000000000000008e36 < z < -4.8999999999999998e-45Initial program 86.1%
associate-*l/93.0%
Simplified93.0%
Taylor expanded in x around 0 44.8%
associate-*r/58.4%
Simplified58.4%
if -4.8999999999999998e-45 < z < 2.00000000000000007e62Initial program 87.4%
associate-*l/95.7%
Simplified95.7%
Taylor expanded in z around 0 78.9%
Final simplification75.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ y (- a z)))))
(if (<= z -8.2e+115)
t
(if (<= z -750000000000.0)
x
(if (<= z -1.2e-62)
t_1
(if (<= z 1.05e-289)
x
(if (<= z 2.25e-185) t_1 (if (<= z 1.96e+65) 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 <= -8.2e+115) {
tmp = t;
} else if (z <= -750000000000.0) {
tmp = x;
} else if (z <= -1.2e-62) {
tmp = t_1;
} else if (z <= 1.05e-289) {
tmp = x;
} else if (z <= 2.25e-185) {
tmp = t_1;
} else if (z <= 1.96e+65) {
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 <= (-8.2d+115)) then
tmp = t
else if (z <= (-750000000000.0d0)) then
tmp = x
else if (z <= (-1.2d-62)) then
tmp = t_1
else if (z <= 1.05d-289) then
tmp = x
else if (z <= 2.25d-185) then
tmp = t_1
else if (z <= 1.96d+65) 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 <= -8.2e+115) {
tmp = t;
} else if (z <= -750000000000.0) {
tmp = x;
} else if (z <= -1.2e-62) {
tmp = t_1;
} else if (z <= 1.05e-289) {
tmp = x;
} else if (z <= 2.25e-185) {
tmp = t_1;
} else if (z <= 1.96e+65) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (y / (a - z)) tmp = 0 if z <= -8.2e+115: tmp = t elif z <= -750000000000.0: tmp = x elif z <= -1.2e-62: tmp = t_1 elif z <= 1.05e-289: tmp = x elif z <= 2.25e-185: tmp = t_1 elif z <= 1.96e+65: 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 <= -8.2e+115) tmp = t; elseif (z <= -750000000000.0) tmp = x; elseif (z <= -1.2e-62) tmp = t_1; elseif (z <= 1.05e-289) tmp = x; elseif (z <= 2.25e-185) tmp = t_1; elseif (z <= 1.96e+65) 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 <= -8.2e+115) tmp = t; elseif (z <= -750000000000.0) tmp = x; elseif (z <= -1.2e-62) tmp = t_1; elseif (z <= 1.05e-289) tmp = x; elseif (z <= 2.25e-185) tmp = t_1; elseif (z <= 1.96e+65) 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, -8.2e+115], t, If[LessEqual[z, -750000000000.0], x, If[LessEqual[z, -1.2e-62], t$95$1, If[LessEqual[z, 1.05e-289], x, If[LessEqual[z, 2.25e-185], t$95$1, If[LessEqual[z, 1.96e+65], x, t]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y}{a - z}\\
\mathbf{if}\;z \leq -8.2 \cdot 10^{+115}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -750000000000:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -1.2 \cdot 10^{-62}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-289}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{-185}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.96 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.19999999999999925e115 or 1.9600000000000001e65 < z Initial program 41.3%
associate-*l/69.8%
Simplified69.8%
Taylor expanded in z around inf 51.0%
if -8.19999999999999925e115 < z < -7.5e11 or -1.19999999999999992e-62 < z < 1.0499999999999999e-289 or 2.2500000000000001e-185 < z < 1.9600000000000001e65Initial program 82.0%
associate-*l/92.8%
Simplified92.8%
Taylor expanded in a around inf 44.7%
if -7.5e11 < z < -1.19999999999999992e-62 or 1.0499999999999999e-289 < z < 2.2500000000000001e-185Initial program 90.0%
associate-*l/93.3%
Simplified93.3%
Taylor expanded in y around -inf 58.6%
associate-*l/61.9%
Simplified61.9%
Taylor expanded in t around inf 42.3%
associate-*r/55.2%
Simplified55.2%
Final simplification48.2%
(FPCore (x y z t a)
:precision binary64
(if (<= z -5e+127)
(+ t (/ a (/ z (- t x))))
(if (<= z 2.5e+62)
(+ x (* (- t x) (/ y a)))
(if (<= z 4.5e+91)
(* t (/ (- y z) (- a z)))
(if (<= z 4.5e+114)
(* y (/ (- t x) (- a z)))
(+ t (/ a (/ (- z) x))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5e+127) {
tmp = t + (a / (z / (t - x)));
} else if (z <= 2.5e+62) {
tmp = x + ((t - x) * (y / a));
} else if (z <= 4.5e+91) {
tmp = t * ((y - z) / (a - z));
} else if (z <= 4.5e+114) {
tmp = y * ((t - x) / (a - z));
} 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) :: tmp
if (z <= (-5d+127)) then
tmp = t + (a / (z / (t - x)))
else if (z <= 2.5d+62) then
tmp = x + ((t - x) * (y / a))
else if (z <= 4.5d+91) then
tmp = t * ((y - z) / (a - z))
else if (z <= 4.5d+114) then
tmp = y * ((t - x) / (a - z))
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 tmp;
if (z <= -5e+127) {
tmp = t + (a / (z / (t - x)));
} else if (z <= 2.5e+62) {
tmp = x + ((t - x) * (y / a));
} else if (z <= 4.5e+91) {
tmp = t * ((y - z) / (a - z));
} else if (z <= 4.5e+114) {
tmp = y * ((t - x) / (a - z));
} else {
tmp = t + (a / (-z / x));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -5e+127: tmp = t + (a / (z / (t - x))) elif z <= 2.5e+62: tmp = x + ((t - x) * (y / a)) elif z <= 4.5e+91: tmp = t * ((y - z) / (a - z)) elif z <= 4.5e+114: tmp = y * ((t - x) / (a - z)) else: tmp = t + (a / (-z / x)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5e+127) tmp = Float64(t + Float64(a / Float64(z / Float64(t - x)))); elseif (z <= 2.5e+62) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); elseif (z <= 4.5e+91) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); elseif (z <= 4.5e+114) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); else tmp = Float64(t + Float64(a / Float64(Float64(-z) / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -5e+127) tmp = t + (a / (z / (t - x))); elseif (z <= 2.5e+62) tmp = x + ((t - x) * (y / a)); elseif (z <= 4.5e+91) tmp = t * ((y - z) / (a - z)); elseif (z <= 4.5e+114) tmp = y * ((t - x) / (a - z)); else tmp = t + (a / (-z / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5e+127], N[(t + N[(a / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.5e+62], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.5e+91], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.5e+114], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(a / N[((-z) / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5 \cdot 10^{+127}:\\
\;\;\;\;t + \frac{a}{\frac{z}{t - x}}\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{+62}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{+91}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{+114}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{a}{\frac{-z}{x}}\\
\end{array}
\end{array}
if z < -5.0000000000000004e127Initial program 30.3%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 60.9%
associate--l+60.9%
associate-*r/60.9%
associate-*r/60.9%
div-sub60.9%
distribute-lft-out--60.9%
associate-*r/60.9%
distribute-rgt-out--61.4%
mul-1-neg61.4%
unsub-neg61.4%
associate-/l*90.5%
Simplified90.5%
Taylor expanded in y around 0 54.6%
sub-neg54.6%
mul-1-neg54.6%
remove-double-neg54.6%
associate-/l*66.3%
Simplified66.3%
if -5.0000000000000004e127 < z < 2.50000000000000014e62Initial program 83.5%
associate-*l/93.0%
Simplified93.0%
Taylor expanded in z around 0 73.3%
if 2.50000000000000014e62 < z < 4.5e91Initial program 64.2%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in x around 0 64.5%
associate-*r/76.4%
Simplified76.4%
if 4.5e91 < z < 4.5000000000000001e114Initial program 44.1%
associate-*l/80.6%
Simplified80.6%
Taylor expanded in y around inf 91.6%
div-sub91.6%
Simplified91.6%
if 4.5000000000000001e114 < z Initial program 46.3%
associate-*l/69.5%
Simplified69.5%
Taylor expanded in z around inf 67.3%
associate--l+67.3%
associate-*r/67.3%
associate-*r/67.3%
div-sub67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
distribute-rgt-out--67.3%
mul-1-neg67.3%
unsub-neg67.3%
associate-/l*85.9%
Simplified85.9%
Taylor expanded in y around 0 57.7%
sub-neg57.7%
mul-1-neg57.7%
remove-double-neg57.7%
associate-/l*69.6%
Simplified69.6%
Taylor expanded in t around 0 69.6%
associate-*r/69.6%
neg-mul-169.6%
Simplified69.6%
Final simplification72.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ y a)))) (t_2 (+ t (/ a (/ (- z) x)))))
(if (<= z -5.6e+125)
t_2
(if (<= z -1.15e-141)
t_1
(if (<= z 4.5e-291)
(* x (- 1.0 (/ y a)))
(if (<= z 5.8e+114) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double t_2 = t + (a / (-z / x));
double tmp;
if (z <= -5.6e+125) {
tmp = t_2;
} else if (z <= -1.15e-141) {
tmp = t_1;
} else if (z <= 4.5e-291) {
tmp = x * (1.0 - (y / a));
} else if (z <= 5.8e+114) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t * (y / a))
t_2 = t + (a / (-z / x))
if (z <= (-5.6d+125)) then
tmp = t_2
else if (z <= (-1.15d-141)) then
tmp = t_1
else if (z <= 4.5d-291) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 5.8d+114) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double t_2 = t + (a / (-z / x));
double tmp;
if (z <= -5.6e+125) {
tmp = t_2;
} else if (z <= -1.15e-141) {
tmp = t_1;
} else if (z <= 4.5e-291) {
tmp = x * (1.0 - (y / a));
} else if (z <= 5.8e+114) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * (y / a)) t_2 = t + (a / (-z / x)) tmp = 0 if z <= -5.6e+125: tmp = t_2 elif z <= -1.15e-141: tmp = t_1 elif z <= 4.5e-291: tmp = x * (1.0 - (y / a)) elif z <= 5.8e+114: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(y / a))) t_2 = Float64(t + Float64(a / Float64(Float64(-z) / x))) tmp = 0.0 if (z <= -5.6e+125) tmp = t_2; elseif (z <= -1.15e-141) tmp = t_1; elseif (z <= 4.5e-291) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 5.8e+114) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * (y / a)); t_2 = t + (a / (-z / x)); tmp = 0.0; if (z <= -5.6e+125) tmp = t_2; elseif (z <= -1.15e-141) tmp = t_1; elseif (z <= 4.5e-291) tmp = x * (1.0 - (y / a)); elseif (z <= 5.8e+114) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(a / N[((-z) / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.6e+125], t$95$2, If[LessEqual[z, -1.15e-141], t$95$1, If[LessEqual[z, 4.5e-291], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.8e+114], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y}{a}\\
t_2 := t + \frac{a}{\frac{-z}{x}}\\
\mathbf{if}\;z \leq -5.6 \cdot 10^{+125}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -1.15 \cdot 10^{-141}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{-291}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 5.8 \cdot 10^{+114}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -5.6000000000000002e125 or 5.8000000000000001e114 < z Initial program 38.2%
associate-*l/68.3%
Simplified68.3%
Taylor expanded in z around inf 64.1%
associate--l+64.1%
associate-*r/64.1%
associate-*r/64.1%
div-sub64.1%
distribute-lft-out--64.1%
associate-*r/64.1%
distribute-rgt-out--64.3%
mul-1-neg64.3%
unsub-neg64.3%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in y around 0 56.1%
sub-neg56.1%
mul-1-neg56.1%
remove-double-neg56.1%
associate-/l*67.9%
Simplified67.9%
Taylor expanded in t around 0 67.5%
associate-*r/67.5%
neg-mul-167.5%
Simplified67.5%
if -5.6000000000000002e125 < z < -1.14999999999999997e-141 or 4.49999999999999974e-291 < z < 5.8000000000000001e114Initial program 78.5%
associate-*l/90.0%
Simplified90.0%
Taylor expanded in z around 0 65.0%
Taylor expanded in t around inf 53.4%
associate-*r/57.1%
Simplified57.1%
if -1.14999999999999997e-141 < z < 4.49999999999999974e-291Initial program 95.0%
associate-*l/99.9%
Simplified99.9%
Taylor expanded in z around 0 93.6%
Taylor expanded in x around inf 82.7%
mul-1-neg82.7%
unsub-neg82.7%
Simplified82.7%
Final simplification63.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ y a)))))
(if (<= z -3.8e+130)
t
(if (<= z -3.8e-140)
t_1
(if (<= z 9e-291) (* x (- 1.0 (/ y a))) (if (<= z 1.75e+115) t_1 t))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double tmp;
if (z <= -3.8e+130) {
tmp = t;
} else if (z <= -3.8e-140) {
tmp = t_1;
} else if (z <= 9e-291) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.75e+115) {
tmp = t_1;
} 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 = x + (t * (y / a))
if (z <= (-3.8d+130)) then
tmp = t
else if (z <= (-3.8d-140)) then
tmp = t_1
else if (z <= 9d-291) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 1.75d+115) then
tmp = t_1
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 = x + (t * (y / a));
double tmp;
if (z <= -3.8e+130) {
tmp = t;
} else if (z <= -3.8e-140) {
tmp = t_1;
} else if (z <= 9e-291) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.75e+115) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * (y / a)) tmp = 0 if z <= -3.8e+130: tmp = t elif z <= -3.8e-140: tmp = t_1 elif z <= 9e-291: tmp = x * (1.0 - (y / a)) elif z <= 1.75e+115: tmp = t_1 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(y / a))) tmp = 0.0 if (z <= -3.8e+130) tmp = t; elseif (z <= -3.8e-140) tmp = t_1; elseif (z <= 9e-291) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 1.75e+115) tmp = t_1; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * (y / a)); tmp = 0.0; if (z <= -3.8e+130) tmp = t; elseif (z <= -3.8e-140) tmp = t_1; elseif (z <= 9e-291) tmp = x * (1.0 - (y / a)); elseif (z <= 1.75e+115) tmp = t_1; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.8e+130], t, If[LessEqual[z, -3.8e-140], t$95$1, If[LessEqual[z, 9e-291], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.75e+115], t$95$1, t]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y}{a}\\
\mathbf{if}\;z \leq -3.8 \cdot 10^{+130}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{-140}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 9 \cdot 10^{-291}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 1.75 \cdot 10^{+115}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3.8000000000000002e130 or 1.75000000000000003e115 < z Initial program 38.2%
associate-*l/68.3%
Simplified68.3%
Taylor expanded in z around inf 54.4%
if -3.8000000000000002e130 < z < -3.79999999999999998e-140 or 8.99999999999999948e-291 < z < 1.75000000000000003e115Initial program 78.5%
associate-*l/90.0%
Simplified90.0%
Taylor expanded in z around 0 65.0%
Taylor expanded in t around inf 53.4%
associate-*r/57.1%
Simplified57.1%
if -3.79999999999999998e-140 < z < 8.99999999999999948e-291Initial program 95.0%
associate-*l/99.9%
Simplified99.9%
Taylor expanded in z around 0 93.6%
Taylor expanded in x around inf 82.7%
mul-1-neg82.7%
unsub-neg82.7%
Simplified82.7%
Final simplification59.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ y a)))) (t_2 (/ t (- 1.0 (/ a z)))))
(if (<= z -6.2e+115)
t_2
(if (<= z -2.7e-142)
t_1
(if (<= z 9e-291)
(* x (- 1.0 (/ y a)))
(if (<= z 9.5e+114) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double t_2 = t / (1.0 - (a / z));
double tmp;
if (z <= -6.2e+115) {
tmp = t_2;
} else if (z <= -2.7e-142) {
tmp = t_1;
} else if (z <= 9e-291) {
tmp = x * (1.0 - (y / a));
} else if (z <= 9.5e+114) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t * (y / a))
t_2 = t / (1.0d0 - (a / z))
if (z <= (-6.2d+115)) then
tmp = t_2
else if (z <= (-2.7d-142)) then
tmp = t_1
else if (z <= 9d-291) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 9.5d+114) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double t_2 = t / (1.0 - (a / z));
double tmp;
if (z <= -6.2e+115) {
tmp = t_2;
} else if (z <= -2.7e-142) {
tmp = t_1;
} else if (z <= 9e-291) {
tmp = x * (1.0 - (y / a));
} else if (z <= 9.5e+114) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * (y / a)) t_2 = t / (1.0 - (a / z)) tmp = 0 if z <= -6.2e+115: tmp = t_2 elif z <= -2.7e-142: tmp = t_1 elif z <= 9e-291: tmp = x * (1.0 - (y / a)) elif z <= 9.5e+114: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(y / a))) t_2 = Float64(t / Float64(1.0 - Float64(a / z))) tmp = 0.0 if (z <= -6.2e+115) tmp = t_2; elseif (z <= -2.7e-142) tmp = t_1; elseif (z <= 9e-291) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 9.5e+114) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * (y / a)); t_2 = t / (1.0 - (a / z)); tmp = 0.0; if (z <= -6.2e+115) tmp = t_2; elseif (z <= -2.7e-142) tmp = t_1; elseif (z <= 9e-291) tmp = x * (1.0 - (y / a)); elseif (z <= 9.5e+114) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t / N[(1.0 - N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6.2e+115], t$95$2, If[LessEqual[z, -2.7e-142], t$95$1, If[LessEqual[z, 9e-291], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9.5e+114], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y}{a}\\
t_2 := \frac{t}{1 - \frac{a}{z}}\\
\mathbf{if}\;z \leq -6.2 \cdot 10^{+115}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{-142}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 9 \cdot 10^{-291}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 9.5 \cdot 10^{+114}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -6.2000000000000001e115 or 9.5000000000000001e114 < z Initial program 39.6%
associate-*l/69.0%
Simplified69.0%
Taylor expanded in x around 0 37.5%
Taylor expanded in y around 0 34.4%
mul-1-neg34.4%
associate-/l*58.0%
distribute-neg-frac58.0%
Simplified58.0%
distribute-frac-neg58.0%
neg-sub058.0%
div-sub58.0%
*-inverses58.0%
sub-neg58.0%
metadata-eval58.0%
Applied egg-rr58.0%
neg-sub058.0%
neg-mul-158.0%
metadata-eval58.0%
times-frac58.0%
*-commutative58.0%
neg-mul-158.0%
*-rgt-identity58.0%
neg-sub058.0%
+-commutative58.0%
associate--r+58.0%
metadata-eval58.0%
Simplified58.0%
if -6.2000000000000001e115 < z < -2.6999999999999998e-142 or 8.99999999999999948e-291 < z < 9.5000000000000001e114Initial program 78.2%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in z around 0 65.2%
Taylor expanded in t around inf 53.4%
associate-*r/57.2%
Simplified57.2%
if -2.6999999999999998e-142 < z < 8.99999999999999948e-291Initial program 95.0%
associate-*l/99.9%
Simplified99.9%
Taylor expanded in z around 0 93.6%
Taylor expanded in x around inf 82.7%
mul-1-neg82.7%
unsub-neg82.7%
Simplified82.7%
Final simplification60.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ y a)))))
(if (<= a -2.1e+38)
t_1
(if (<= a -3.8e-106)
(* y (/ (- x) (- a z)))
(if (<= a 2.35e+117) (* t (/ (- y z) (- a z))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double tmp;
if (a <= -2.1e+38) {
tmp = t_1;
} else if (a <= -3.8e-106) {
tmp = y * (-x / (a - z));
} else if (a <= 2.35e+117) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (t * (y / a))
if (a <= (-2.1d+38)) then
tmp = t_1
else if (a <= (-3.8d-106)) then
tmp = y * (-x / (a - z))
else if (a <= 2.35d+117) then
tmp = t * ((y - z) / (a - z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / a));
double tmp;
if (a <= -2.1e+38) {
tmp = t_1;
} else if (a <= -3.8e-106) {
tmp = y * (-x / (a - z));
} else if (a <= 2.35e+117) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * (y / a)) tmp = 0 if a <= -2.1e+38: tmp = t_1 elif a <= -3.8e-106: tmp = y * (-x / (a - z)) elif a <= 2.35e+117: tmp = t * ((y - z) / (a - z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(y / a))) tmp = 0.0 if (a <= -2.1e+38) tmp = t_1; elseif (a <= -3.8e-106) tmp = Float64(y * Float64(Float64(-x) / Float64(a - z))); elseif (a <= 2.35e+117) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * (y / a)); tmp = 0.0; if (a <= -2.1e+38) tmp = t_1; elseif (a <= -3.8e-106) tmp = y * (-x / (a - z)); elseif (a <= 2.35e+117) tmp = t * ((y - z) / (a - z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.1e+38], t$95$1, If[LessEqual[a, -3.8e-106], N[(y * N[((-x) / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.35e+117], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -2.1 \cdot 10^{+38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -3.8 \cdot 10^{-106}:\\
\;\;\;\;y \cdot \frac{-x}{a - z}\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+117}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -2.1e38 or 2.35000000000000003e117 < a Initial program 71.5%
associate-*l/90.5%
Simplified90.5%
Taylor expanded in z around 0 71.3%
Taylor expanded in t around inf 62.5%
associate-*r/66.4%
Simplified66.4%
if -2.1e38 < a < -3.7999999999999999e-106Initial program 59.9%
associate-*l/66.4%
Simplified66.4%
Taylor expanded in y around inf 50.3%
div-sub50.3%
Simplified50.3%
Taylor expanded in t around 0 46.8%
neg-mul-146.8%
distribute-neg-frac46.8%
Simplified46.8%
if -3.7999999999999999e-106 < a < 2.35000000000000003e117Initial program 65.3%
associate-*l/82.4%
Simplified82.4%
Taylor expanded in x around 0 47.4%
associate-*r/61.6%
Simplified61.6%
Final simplification62.0%
(FPCore (x y z t a)
:precision binary64
(if (<= z -8.2e+115)
t
(if (<= z 2.8e-289)
x
(if (<= z 3.3e-216) (* t (/ y a)) (if (<= z 2.1e+65) x t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.2e+115) {
tmp = t;
} else if (z <= 2.8e-289) {
tmp = x;
} else if (z <= 3.3e-216) {
tmp = t * (y / a);
} else if (z <= 2.1e+65) {
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 <= (-8.2d+115)) then
tmp = t
else if (z <= 2.8d-289) then
tmp = x
else if (z <= 3.3d-216) then
tmp = t * (y / a)
else if (z <= 2.1d+65) 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 <= -8.2e+115) {
tmp = t;
} else if (z <= 2.8e-289) {
tmp = x;
} else if (z <= 3.3e-216) {
tmp = t * (y / a);
} else if (z <= 2.1e+65) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -8.2e+115: tmp = t elif z <= 2.8e-289: tmp = x elif z <= 3.3e-216: tmp = t * (y / a) elif z <= 2.1e+65: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8.2e+115) tmp = t; elseif (z <= 2.8e-289) tmp = x; elseif (z <= 3.3e-216) tmp = Float64(t * Float64(y / a)); elseif (z <= 2.1e+65) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -8.2e+115) tmp = t; elseif (z <= 2.8e-289) tmp = x; elseif (z <= 3.3e-216) tmp = t * (y / a); elseif (z <= 2.1e+65) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8.2e+115], t, If[LessEqual[z, 2.8e-289], x, If[LessEqual[z, 3.3e-216], N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.1e+65], x, t]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.2 \cdot 10^{+115}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.8 \cdot 10^{-289}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 3.3 \cdot 10^{-216}:\\
\;\;\;\;t \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 2.1 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.19999999999999925e115 or 2.09999999999999991e65 < z Initial program 41.3%
associate-*l/69.8%
Simplified69.8%
Taylor expanded in z around inf 51.0%
if -8.19999999999999925e115 < z < 2.79999999999999985e-289 or 3.29999999999999969e-216 < z < 2.09999999999999991e65Initial program 83.0%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in a around inf 41.9%
if 2.79999999999999985e-289 < z < 3.29999999999999969e-216Initial program 90.2%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in y around -inf 70.8%
associate-*l/80.5%
Simplified80.5%
Taylor expanded in t around inf 61.5%
associate-*r/71.2%
Simplified71.2%
Taylor expanded in a around inf 71.2%
Final simplification46.5%
(FPCore (x y z t a) :precision binary64 (if (<= z -6.2e+115) t (if (<= z 2e+65) (* x (- 1.0 (/ y a))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.2e+115) {
tmp = t;
} else if (z <= 2e+65) {
tmp = x * (1.0 - (y / a));
} 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 <= (-6.2d+115)) then
tmp = t
else if (z <= 2d+65) then
tmp = x * (1.0d0 - (y / a))
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 <= -6.2e+115) {
tmp = t;
} else if (z <= 2e+65) {
tmp = x * (1.0 - (y / a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -6.2e+115: tmp = t elif z <= 2e+65: tmp = x * (1.0 - (y / a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -6.2e+115) tmp = t; elseif (z <= 2e+65) tmp = Float64(x * Float64(1.0 - Float64(y / a))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -6.2e+115) tmp = t; elseif (z <= 2e+65) tmp = x * (1.0 - (y / a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.2e+115], t, If[LessEqual[z, 2e+65], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.2 \cdot 10^{+115}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2 \cdot 10^{+65}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -6.2000000000000001e115 or 2e65 < z Initial program 41.3%
associate-*l/69.8%
Simplified69.8%
Taylor expanded in z around inf 51.0%
if -6.2000000000000001e115 < z < 2e65Initial program 83.4%
associate-*l/92.9%
Simplified92.9%
Taylor expanded in z around 0 73.1%
Taylor expanded in x around inf 56.4%
mul-1-neg56.4%
unsub-neg56.4%
Simplified56.4%
Final simplification54.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.05e+116) t (if (<= z 1.96e+65) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.05e+116) {
tmp = t;
} else if (z <= 1.96e+65) {
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.05d+116)) then
tmp = t
else if (z <= 1.96d+65) 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.05e+116) {
tmp = t;
} else if (z <= 1.96e+65) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.05e+116: tmp = t elif z <= 1.96e+65: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.05e+116) tmp = t; elseif (z <= 1.96e+65) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.05e+116) tmp = t; elseif (z <= 1.96e+65) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.05e+116], t, If[LessEqual[z, 1.96e+65], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.05 \cdot 10^{+116}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.96 \cdot 10^{+65}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.0500000000000001e116 or 1.9600000000000001e65 < z Initial program 41.3%
associate-*l/69.8%
Simplified69.8%
Taylor expanded in z around inf 51.0%
if -1.0500000000000001e116 < z < 1.9600000000000001e65Initial program 83.4%
associate-*l/92.9%
Simplified92.9%
Taylor expanded in a around inf 40.7%
Final simplification44.6%
(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 67.5%
associate-*l/84.2%
Simplified84.2%
Taylor expanded in z around inf 23.3%
Final simplification23.3%
(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 2023332
(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))))