
(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 31 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 (<= t_1 (- INFINITY))
(+ x (/ (- y z) (/ (- a z) (- t x))))
(if (<= t_1 -5e-271)
t_1
(if (<= t_1 0.0)
(+ t (/ (* (- t x) (- a y)) z))
(if (<= t_1 5e+306) t_1 (* t (/ (- y z) (- a z)))))))))
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 <= -((double) INFINITY)) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else if (t_1 <= -5e-271) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_1 <= 5e+306) {
tmp = t_1;
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
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 <= -Double.POSITIVE_INFINITY) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else if (t_1 <= -5e-271) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_1 <= 5e+306) {
tmp = t_1;
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - z) * (t - x)) / (a - z)) tmp = 0 if t_1 <= -math.inf: tmp = x + ((y - z) / ((a - z) / (t - x))) elif t_1 <= -5e-271: tmp = t_1 elif t_1 <= 0.0: tmp = t + (((t - x) * (a - y)) / z) elif t_1 <= 5e+306: tmp = t_1 else: tmp = t * ((y - z) / (a - z)) 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 <= Float64(-Inf)) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / Float64(t - x)))); elseif (t_1 <= -5e-271) tmp = t_1; elseif (t_1 <= 0.0) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); elseif (t_1 <= 5e+306) tmp = t_1; else tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); 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 <= -Inf) tmp = x + ((y - z) / ((a - z) / (t - x))); elseif (t_1 <= -5e-271) tmp = t_1; elseif (t_1 <= 0.0) tmp = t + (((t - x) * (a - y)) / z); elseif (t_1 <= 5e+306) tmp = t_1; else tmp = t * ((y - z) / (a - z)); 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[LessEqual[t$95$1, (-Infinity)], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e-271], t$95$1, If[LessEqual[t$95$1, 0.0], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+306], t$95$1, N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $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 -\infty:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t - x}}\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{-271}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+306}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -inf.0Initial program 35.3%
associate-/l*80.8%
Simplified80.8%
clear-num80.8%
un-div-inv80.9%
Applied egg-rr80.9%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.0000000000000002e-271 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 4.99999999999999993e306Initial program 97.0%
if -5.0000000000000002e-271 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.7%
associate-/l*3.3%
Simplified3.3%
Taylor expanded in z around inf 99.9%
associate--l+99.9%
associate-*r/99.9%
associate-*r/99.9%
mul-1-neg99.9%
div-sub99.9%
mul-1-neg99.9%
distribute-lft-out--99.9%
associate-*r/99.9%
mul-1-neg99.9%
unsub-neg99.9%
distribute-rgt-out--99.9%
Simplified99.9%
if 4.99999999999999993e306 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 30.6%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in x around 0 28.4%
associate-/l*77.2%
Simplified77.2%
Final simplification90.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -5e-271) (not (<= t_1 0.0)))
(fma (- t x) (/ (- y z) (- a z)) x)
(+ t (/ (* (- t x) (- a y)) z)))))
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-271) || !(t_1 <= 0.0)) {
tmp = fma((t - x), ((y - z) / (a - z)), x);
} else {
tmp = t + (((t - x) * (a - y)) / z);
}
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-271) || !(t_1 <= 0.0)) tmp = fma(Float64(t - x), Float64(Float64(y - z) / Float64(a - z)), x); else tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); 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-271], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $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^{-271} \lor \neg \left(t\_1 \leq 0\right):\\
\;\;\;\;\mathsf{fma}\left(t - x, \frac{y - z}{a - z}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.0000000000000002e-271 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 72.7%
+-commutative72.7%
*-commutative72.7%
associate-/l*87.4%
fma-define87.4%
Simplified87.4%
if -5.0000000000000002e-271 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.7%
associate-/l*3.3%
Simplified3.3%
Taylor expanded in z around inf 99.9%
associate--l+99.9%
associate-*r/99.9%
associate-*r/99.9%
mul-1-neg99.9%
div-sub99.9%
mul-1-neg99.9%
distribute-lft-out--99.9%
associate-*r/99.9%
mul-1-neg99.9%
unsub-neg99.9%
distribute-rgt-out--99.9%
Simplified99.9%
Final simplification88.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (<= t_1 (- INFINITY))
(+ x (* (- y z) (/ (- x t) (- z a))))
(if (<= t_1 -5e-271)
t_1
(if (<= t_1 0.0)
(+ t (/ (* (- t x) (- a y)) z))
(if (<= t_1 5e+306) t_1 (* t (/ (- y z) (- a z)))))))))
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 <= -((double) INFINITY)) {
tmp = x + ((y - z) * ((x - t) / (z - a)));
} else if (t_1 <= -5e-271) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_1 <= 5e+306) {
tmp = t_1;
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
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 <= -Double.POSITIVE_INFINITY) {
tmp = x + ((y - z) * ((x - t) / (z - a)));
} else if (t_1 <= -5e-271) {
tmp = t_1;
} else if (t_1 <= 0.0) {
tmp = t + (((t - x) * (a - y)) / z);
} else if (t_1 <= 5e+306) {
tmp = t_1;
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - z) * (t - x)) / (a - z)) tmp = 0 if t_1 <= -math.inf: tmp = x + ((y - z) * ((x - t) / (z - a))) elif t_1 <= -5e-271: tmp = t_1 elif t_1 <= 0.0: tmp = t + (((t - x) * (a - y)) / z) elif t_1 <= 5e+306: tmp = t_1 else: tmp = t * ((y - z) / (a - z)) 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 <= Float64(-Inf)) tmp = Float64(x + Float64(Float64(y - z) * Float64(Float64(x - t) / Float64(z - a)))); elseif (t_1 <= -5e-271) tmp = t_1; elseif (t_1 <= 0.0) tmp = Float64(t + Float64(Float64(Float64(t - x) * Float64(a - y)) / z)); elseif (t_1 <= 5e+306) tmp = t_1; else tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); 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 <= -Inf) tmp = x + ((y - z) * ((x - t) / (z - a))); elseif (t_1 <= -5e-271) tmp = t_1; elseif (t_1 <= 0.0) tmp = t + (((t - x) * (a - y)) / z); elseif (t_1 <= 5e+306) tmp = t_1; else tmp = t * ((y - z) / (a - z)); 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[LessEqual[t$95$1, (-Infinity)], N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(x - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e-271], t$95$1, If[LessEqual[t$95$1, 0.0], N[(t + N[(N[(N[(t - x), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+306], t$95$1, N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $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 -\infty:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{x - t}{z - a}\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{-271}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;t + \frac{\left(t - x\right) \cdot \left(a - y\right)}{z}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+306}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -inf.0Initial program 35.3%
associate-/l*80.8%
Simplified80.8%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.0000000000000002e-271 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 4.99999999999999993e306Initial program 97.0%
if -5.0000000000000002e-271 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.7%
associate-/l*3.3%
Simplified3.3%
Taylor expanded in z around inf 99.9%
associate--l+99.9%
associate-*r/99.9%
associate-*r/99.9%
mul-1-neg99.9%
div-sub99.9%
mul-1-neg99.9%
distribute-lft-out--99.9%
associate-*r/99.9%
mul-1-neg99.9%
unsub-neg99.9%
distribute-rgt-out--99.9%
Simplified99.9%
if 4.99999999999999993e306 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 30.6%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in x around 0 28.4%
associate-/l*77.2%
Simplified77.2%
Final simplification90.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z))))
(t_2 (+ x (/ (- y z) (/ a t))))
(t_3 (* y (- x t))))
(if (<= a -7e+81)
t_2
(if (<= a -3.7e-99)
t_1
(if (<= a 6.5e-191)
(+ t (/ t_3 z))
(if (<= a 9.4e-73)
(/ y (/ (- a z) (- t x)))
(if (<= a 2.15e+23)
t_1
(if (<= a 4.6e+52)
(- x (/ t_3 a))
(if (<= a 9.2e+81) (- t (* x (/ a z))) 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 = x + ((y - z) / (a / t));
double t_3 = y * (x - t);
double tmp;
if (a <= -7e+81) {
tmp = t_2;
} else if (a <= -3.7e-99) {
tmp = t_1;
} else if (a <= 6.5e-191) {
tmp = t + (t_3 / z);
} else if (a <= 9.4e-73) {
tmp = y / ((a - z) / (t - x));
} else if (a <= 2.15e+23) {
tmp = t_1;
} else if (a <= 4.6e+52) {
tmp = x - (t_3 / a);
} else if (a <= 9.2e+81) {
tmp = t - (x * (a / z));
} 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) :: t_3
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = x + ((y - z) / (a / t))
t_3 = y * (x - t)
if (a <= (-7d+81)) then
tmp = t_2
else if (a <= (-3.7d-99)) then
tmp = t_1
else if (a <= 6.5d-191) then
tmp = t + (t_3 / z)
else if (a <= 9.4d-73) then
tmp = y / ((a - z) / (t - x))
else if (a <= 2.15d+23) then
tmp = t_1
else if (a <= 4.6d+52) then
tmp = x - (t_3 / a)
else if (a <= 9.2d+81) then
tmp = t - (x * (a / z))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + ((y - z) / (a / t));
double t_3 = y * (x - t);
double tmp;
if (a <= -7e+81) {
tmp = t_2;
} else if (a <= -3.7e-99) {
tmp = t_1;
} else if (a <= 6.5e-191) {
tmp = t + (t_3 / z);
} else if (a <= 9.4e-73) {
tmp = y / ((a - z) / (t - x));
} else if (a <= 2.15e+23) {
tmp = t_1;
} else if (a <= 4.6e+52) {
tmp = x - (t_3 / a);
} else if (a <= 9.2e+81) {
tmp = t - (x * (a / z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + ((y - z) / (a / t)) t_3 = y * (x - t) tmp = 0 if a <= -7e+81: tmp = t_2 elif a <= -3.7e-99: tmp = t_1 elif a <= 6.5e-191: tmp = t + (t_3 / z) elif a <= 9.4e-73: tmp = y / ((a - z) / (t - x)) elif a <= 2.15e+23: tmp = t_1 elif a <= 4.6e+52: tmp = x - (t_3 / a) elif a <= 9.2e+81: tmp = t - (x * (a / z)) 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(x + Float64(Float64(y - z) / Float64(a / t))) t_3 = Float64(y * Float64(x - t)) tmp = 0.0 if (a <= -7e+81) tmp = t_2; elseif (a <= -3.7e-99) tmp = t_1; elseif (a <= 6.5e-191) tmp = Float64(t + Float64(t_3 / z)); elseif (a <= 9.4e-73) tmp = Float64(y / Float64(Float64(a - z) / Float64(t - x))); elseif (a <= 2.15e+23) tmp = t_1; elseif (a <= 4.6e+52) tmp = Float64(x - Float64(t_3 / a)); elseif (a <= 9.2e+81) tmp = Float64(t - Float64(x * Float64(a / z))); 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 = x + ((y - z) / (a / t)); t_3 = y * (x - t); tmp = 0.0; if (a <= -7e+81) tmp = t_2; elseif (a <= -3.7e-99) tmp = t_1; elseif (a <= 6.5e-191) tmp = t + (t_3 / z); elseif (a <= 9.4e-73) tmp = y / ((a - z) / (t - x)); elseif (a <= 2.15e+23) tmp = t_1; elseif (a <= 4.6e+52) tmp = x - (t_3 / a); elseif (a <= 9.2e+81) tmp = t - (x * (a / z)); 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[(x + N[(N[(y - z), $MachinePrecision] / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -7e+81], t$95$2, If[LessEqual[a, -3.7e-99], t$95$1, If[LessEqual[a, 6.5e-191], N[(t + N[(t$95$3 / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 9.4e-73], N[(y / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.15e+23], t$95$1, If[LessEqual[a, 4.6e+52], N[(x - N[(t$95$3 / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 9.2e+81], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + \frac{y - z}{\frac{a}{t}}\\
t_3 := y \cdot \left(x - t\right)\\
\mathbf{if}\;a \leq -7 \cdot 10^{+81}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -3.7 \cdot 10^{-99}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 6.5 \cdot 10^{-191}:\\
\;\;\;\;t + \frac{t\_3}{z}\\
\mathbf{elif}\;a \leq 9.4 \cdot 10^{-73}:\\
\;\;\;\;\frac{y}{\frac{a - z}{t - x}}\\
\mathbf{elif}\;a \leq 2.15 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{+52}:\\
\;\;\;\;x - \frac{t\_3}{a}\\
\mathbf{elif}\;a \leq 9.2 \cdot 10^{+81}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -7.0000000000000001e81 or 9.1999999999999995e81 < a Initial program 70.3%
associate-/l*86.2%
Simplified86.2%
clear-num85.5%
un-div-inv85.6%
Applied egg-rr85.6%
Taylor expanded in t around inf 78.4%
Taylor expanded in a around inf 75.0%
if -7.0000000000000001e81 < a < -3.7e-99 or 9.39999999999999988e-73 < a < 2.1499999999999999e23Initial program 68.2%
associate-/l*76.6%
Simplified76.6%
Taylor expanded in x around 0 53.8%
associate-/l*69.8%
Simplified69.8%
if -3.7e-99 < a < 6.4999999999999995e-191Initial program 60.2%
associate-/l*70.3%
Simplified70.3%
Taylor expanded in z around inf 86.8%
associate--l+86.8%
associate-*r/86.8%
associate-*r/86.8%
mul-1-neg86.8%
div-sub86.8%
mul-1-neg86.8%
distribute-lft-out--86.8%
associate-*r/86.8%
mul-1-neg86.8%
unsub-neg86.8%
distribute-rgt-out--86.8%
Simplified86.8%
Taylor expanded in y around inf 84.8%
if 6.4999999999999995e-191 < a < 9.39999999999999988e-73Initial program 83.5%
associate-/l*83.5%
Simplified83.5%
Taylor expanded in y around inf 76.8%
div-sub76.8%
Simplified76.8%
clear-num76.8%
div-inv76.9%
Applied egg-rr76.9%
if 2.1499999999999999e23 < a < 4.6e52Initial program 100.0%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in z around 0 87.5%
if 4.6e52 < a < 9.1999999999999995e81Initial program 36.5%
associate-/l*57.1%
Simplified57.1%
Taylor expanded in z around inf 56.8%
associate--l+56.8%
associate-*r/56.8%
associate-*r/56.8%
mul-1-neg56.8%
div-sub56.8%
mul-1-neg56.8%
distribute-lft-out--56.8%
associate-*r/56.8%
mul-1-neg56.8%
unsub-neg56.8%
distribute-rgt-out--56.8%
Simplified56.8%
Taylor expanded in t around 0 67.9%
mul-1-neg67.9%
associate-/l*78.2%
distribute-rgt-neg-in78.2%
distribute-neg-frac278.2%
Simplified78.2%
Taylor expanded in y around 0 79.7%
Final simplification76.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z))))
(t_2 (+ x (/ (- y z) (/ a t))))
(t_3 (* y (- x t))))
(if (<= a -6.2e+84)
t_2
(if (<= a -5.2e-97)
t_1
(if (<= a 1.06e-190)
(+ t (/ t_3 z))
(if (<= a 4.7e-86)
(* y (/ (- x t) (- z a)))
(if (<= a 1.45e+25)
t_1
(if (<= a 1.12e+53)
(- x (/ t_3 a))
(if (<= a 2.75e+82) (- t (* x (/ a z))) 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 = x + ((y - z) / (a / t));
double t_3 = y * (x - t);
double tmp;
if (a <= -6.2e+84) {
tmp = t_2;
} else if (a <= -5.2e-97) {
tmp = t_1;
} else if (a <= 1.06e-190) {
tmp = t + (t_3 / z);
} else if (a <= 4.7e-86) {
tmp = y * ((x - t) / (z - a));
} else if (a <= 1.45e+25) {
tmp = t_1;
} else if (a <= 1.12e+53) {
tmp = x - (t_3 / a);
} else if (a <= 2.75e+82) {
tmp = t - (x * (a / z));
} 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) :: t_3
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = x + ((y - z) / (a / t))
t_3 = y * (x - t)
if (a <= (-6.2d+84)) then
tmp = t_2
else if (a <= (-5.2d-97)) then
tmp = t_1
else if (a <= 1.06d-190) then
tmp = t + (t_3 / z)
else if (a <= 4.7d-86) then
tmp = y * ((x - t) / (z - a))
else if (a <= 1.45d+25) then
tmp = t_1
else if (a <= 1.12d+53) then
tmp = x - (t_3 / a)
else if (a <= 2.75d+82) then
tmp = t - (x * (a / z))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + ((y - z) / (a / t));
double t_3 = y * (x - t);
double tmp;
if (a <= -6.2e+84) {
tmp = t_2;
} else if (a <= -5.2e-97) {
tmp = t_1;
} else if (a <= 1.06e-190) {
tmp = t + (t_3 / z);
} else if (a <= 4.7e-86) {
tmp = y * ((x - t) / (z - a));
} else if (a <= 1.45e+25) {
tmp = t_1;
} else if (a <= 1.12e+53) {
tmp = x - (t_3 / a);
} else if (a <= 2.75e+82) {
tmp = t - (x * (a / z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + ((y - z) / (a / t)) t_3 = y * (x - t) tmp = 0 if a <= -6.2e+84: tmp = t_2 elif a <= -5.2e-97: tmp = t_1 elif a <= 1.06e-190: tmp = t + (t_3 / z) elif a <= 4.7e-86: tmp = y * ((x - t) / (z - a)) elif a <= 1.45e+25: tmp = t_1 elif a <= 1.12e+53: tmp = x - (t_3 / a) elif a <= 2.75e+82: tmp = t - (x * (a / z)) 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(x + Float64(Float64(y - z) / Float64(a / t))) t_3 = Float64(y * Float64(x - t)) tmp = 0.0 if (a <= -6.2e+84) tmp = t_2; elseif (a <= -5.2e-97) tmp = t_1; elseif (a <= 1.06e-190) tmp = Float64(t + Float64(t_3 / z)); elseif (a <= 4.7e-86) tmp = Float64(y * Float64(Float64(x - t) / Float64(z - a))); elseif (a <= 1.45e+25) tmp = t_1; elseif (a <= 1.12e+53) tmp = Float64(x - Float64(t_3 / a)); elseif (a <= 2.75e+82) tmp = Float64(t - Float64(x * Float64(a / z))); 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 = x + ((y - z) / (a / t)); t_3 = y * (x - t); tmp = 0.0; if (a <= -6.2e+84) tmp = t_2; elseif (a <= -5.2e-97) tmp = t_1; elseif (a <= 1.06e-190) tmp = t + (t_3 / z); elseif (a <= 4.7e-86) tmp = y * ((x - t) / (z - a)); elseif (a <= 1.45e+25) tmp = t_1; elseif (a <= 1.12e+53) tmp = x - (t_3 / a); elseif (a <= 2.75e+82) tmp = t - (x * (a / z)); 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[(x + N[(N[(y - z), $MachinePrecision] / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6.2e+84], t$95$2, If[LessEqual[a, -5.2e-97], t$95$1, If[LessEqual[a, 1.06e-190], N[(t + N[(t$95$3 / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.7e-86], N[(y * N[(N[(x - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.45e+25], t$95$1, If[LessEqual[a, 1.12e+53], N[(x - N[(t$95$3 / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.75e+82], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + \frac{y - z}{\frac{a}{t}}\\
t_3 := y \cdot \left(x - t\right)\\
\mathbf{if}\;a \leq -6.2 \cdot 10^{+84}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -5.2 \cdot 10^{-97}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.06 \cdot 10^{-190}:\\
\;\;\;\;t + \frac{t\_3}{z}\\
\mathbf{elif}\;a \leq 4.7 \cdot 10^{-86}:\\
\;\;\;\;y \cdot \frac{x - t}{z - a}\\
\mathbf{elif}\;a \leq 1.45 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{+53}:\\
\;\;\;\;x - \frac{t\_3}{a}\\
\mathbf{elif}\;a \leq 2.75 \cdot 10^{+82}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -6.20000000000000006e84 or 2.74999999999999998e82 < a Initial program 70.3%
associate-/l*86.2%
Simplified86.2%
clear-num85.5%
un-div-inv85.6%
Applied egg-rr85.6%
Taylor expanded in t around inf 78.4%
Taylor expanded in a around inf 75.0%
if -6.20000000000000006e84 < a < -5.20000000000000014e-97 or 4.7000000000000001e-86 < a < 1.44999999999999995e25Initial program 68.2%
associate-/l*76.6%
Simplified76.6%
Taylor expanded in x around 0 53.8%
associate-/l*69.8%
Simplified69.8%
if -5.20000000000000014e-97 < a < 1.05999999999999997e-190Initial program 60.2%
associate-/l*70.3%
Simplified70.3%
Taylor expanded in z around inf 86.8%
associate--l+86.8%
associate-*r/86.8%
associate-*r/86.8%
mul-1-neg86.8%
div-sub86.8%
mul-1-neg86.8%
distribute-lft-out--86.8%
associate-*r/86.8%
mul-1-neg86.8%
unsub-neg86.8%
distribute-rgt-out--86.8%
Simplified86.8%
Taylor expanded in y around inf 84.8%
if 1.05999999999999997e-190 < a < 4.7000000000000001e-86Initial program 83.5%
associate-/l*83.5%
Simplified83.5%
Taylor expanded in y around inf 76.8%
div-sub76.8%
Simplified76.8%
if 1.44999999999999995e25 < a < 1.12e53Initial program 100.0%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in z around 0 87.5%
if 1.12e53 < a < 2.74999999999999998e82Initial program 36.5%
associate-/l*57.1%
Simplified57.1%
Taylor expanded in z around inf 56.8%
associate--l+56.8%
associate-*r/56.8%
associate-*r/56.8%
mul-1-neg56.8%
div-sub56.8%
mul-1-neg56.8%
distribute-lft-out--56.8%
associate-*r/56.8%
mul-1-neg56.8%
unsub-neg56.8%
distribute-rgt-out--56.8%
Simplified56.8%
Taylor expanded in t around 0 67.9%
mul-1-neg67.9%
associate-/l*78.2%
distribute-rgt-neg-in78.2%
distribute-neg-frac278.2%
Simplified78.2%
Taylor expanded in y around 0 79.7%
Final simplification76.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (+ x (/ (- y z) (/ a t)))))
(if (<= a -1.3e+93)
t_2
(if (<= a -4.8e-170)
t_1
(if (<= a 1.35e-191)
(+ t (* y (/ x z)))
(if (<= a 3.15e-85)
(* y (/ (- x t) (- z a)))
(if (<= a 3.4e+24)
t_1
(if (<= a 1.04e+52)
(- x (/ (* y (- x t)) a))
(if (<= a 1.45e+82) (- t (* x (/ a z))) 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 = x + ((y - z) / (a / t));
double tmp;
if (a <= -1.3e+93) {
tmp = t_2;
} else if (a <= -4.8e-170) {
tmp = t_1;
} else if (a <= 1.35e-191) {
tmp = t + (y * (x / z));
} else if (a <= 3.15e-85) {
tmp = y * ((x - t) / (z - a));
} else if (a <= 3.4e+24) {
tmp = t_1;
} else if (a <= 1.04e+52) {
tmp = x - ((y * (x - t)) / a);
} else if (a <= 1.45e+82) {
tmp = t - (x * (a / z));
} 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 = x + ((y - z) / (a / t))
if (a <= (-1.3d+93)) then
tmp = t_2
else if (a <= (-4.8d-170)) then
tmp = t_1
else if (a <= 1.35d-191) then
tmp = t + (y * (x / z))
else if (a <= 3.15d-85) then
tmp = y * ((x - t) / (z - a))
else if (a <= 3.4d+24) then
tmp = t_1
else if (a <= 1.04d+52) then
tmp = x - ((y * (x - t)) / a)
else if (a <= 1.45d+82) then
tmp = t - (x * (a / z))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + ((y - z) / (a / t));
double tmp;
if (a <= -1.3e+93) {
tmp = t_2;
} else if (a <= -4.8e-170) {
tmp = t_1;
} else if (a <= 1.35e-191) {
tmp = t + (y * (x / z));
} else if (a <= 3.15e-85) {
tmp = y * ((x - t) / (z - a));
} else if (a <= 3.4e+24) {
tmp = t_1;
} else if (a <= 1.04e+52) {
tmp = x - ((y * (x - t)) / a);
} else if (a <= 1.45e+82) {
tmp = t - (x * (a / z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + ((y - z) / (a / t)) tmp = 0 if a <= -1.3e+93: tmp = t_2 elif a <= -4.8e-170: tmp = t_1 elif a <= 1.35e-191: tmp = t + (y * (x / z)) elif a <= 3.15e-85: tmp = y * ((x - t) / (z - a)) elif a <= 3.4e+24: tmp = t_1 elif a <= 1.04e+52: tmp = x - ((y * (x - t)) / a) elif a <= 1.45e+82: tmp = t - (x * (a / z)) 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(x + Float64(Float64(y - z) / Float64(a / t))) tmp = 0.0 if (a <= -1.3e+93) tmp = t_2; elseif (a <= -4.8e-170) tmp = t_1; elseif (a <= 1.35e-191) tmp = Float64(t + Float64(y * Float64(x / z))); elseif (a <= 3.15e-85) tmp = Float64(y * Float64(Float64(x - t) / Float64(z - a))); elseif (a <= 3.4e+24) tmp = t_1; elseif (a <= 1.04e+52) tmp = Float64(x - Float64(Float64(y * Float64(x - t)) / a)); elseif (a <= 1.45e+82) tmp = Float64(t - Float64(x * Float64(a / z))); 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 = x + ((y - z) / (a / t)); tmp = 0.0; if (a <= -1.3e+93) tmp = t_2; elseif (a <= -4.8e-170) tmp = t_1; elseif (a <= 1.35e-191) tmp = t + (y * (x / z)); elseif (a <= 3.15e-85) tmp = y * ((x - t) / (z - a)); elseif (a <= 3.4e+24) tmp = t_1; elseif (a <= 1.04e+52) tmp = x - ((y * (x - t)) / a); elseif (a <= 1.45e+82) tmp = t - (x * (a / z)); 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[(x + N[(N[(y - z), $MachinePrecision] / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.3e+93], t$95$2, If[LessEqual[a, -4.8e-170], t$95$1, If[LessEqual[a, 1.35e-191], N[(t + N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.15e-85], N[(y * N[(N[(x - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.4e+24], t$95$1, If[LessEqual[a, 1.04e+52], N[(x - N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.45e+82], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + \frac{y - z}{\frac{a}{t}}\\
\mathbf{if}\;a \leq -1.3 \cdot 10^{+93}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -4.8 \cdot 10^{-170}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{-191}:\\
\;\;\;\;t + y \cdot \frac{x}{z}\\
\mathbf{elif}\;a \leq 3.15 \cdot 10^{-85}:\\
\;\;\;\;y \cdot \frac{x - t}{z - a}\\
\mathbf{elif}\;a \leq 3.4 \cdot 10^{+24}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.04 \cdot 10^{+52}:\\
\;\;\;\;x - \frac{y \cdot \left(x - t\right)}{a}\\
\mathbf{elif}\;a \leq 1.45 \cdot 10^{+82}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -1.3e93 or 1.4500000000000001e82 < a Initial program 70.3%
associate-/l*86.2%
Simplified86.2%
clear-num85.5%
un-div-inv85.6%
Applied egg-rr85.6%
Taylor expanded in t around inf 78.4%
Taylor expanded in a around inf 75.0%
if -1.3e93 < a < -4.7999999999999999e-170 or 3.15e-85 < a < 3.4000000000000001e24Initial program 68.5%
associate-/l*76.7%
Simplified76.7%
Taylor expanded in x around 0 55.2%
associate-/l*68.7%
Simplified68.7%
if -4.7999999999999999e-170 < a < 1.34999999999999999e-191Initial program 56.8%
associate-/l*67.8%
Simplified67.8%
Taylor expanded in z around inf 89.8%
associate--l+89.8%
associate-*r/89.8%
associate-*r/89.8%
mul-1-neg89.8%
div-sub89.8%
mul-1-neg89.8%
distribute-lft-out--89.8%
associate-*r/89.8%
mul-1-neg89.8%
unsub-neg89.8%
distribute-rgt-out--89.8%
Simplified89.8%
Taylor expanded in t around 0 81.2%
mul-1-neg81.2%
associate-/l*78.7%
distribute-rgt-neg-in78.7%
distribute-neg-frac278.7%
Simplified78.7%
Taylor expanded in y around inf 81.2%
associate-*r/81.2%
*-commutative81.2%
neg-mul-181.2%
distribute-rgt-neg-in81.2%
associate-*r/81.1%
Simplified81.1%
if 1.34999999999999999e-191 < a < 3.15e-85Initial program 83.5%
associate-/l*83.5%
Simplified83.5%
Taylor expanded in y around inf 76.8%
div-sub76.8%
Simplified76.8%
if 3.4000000000000001e24 < a < 1.04e52Initial program 100.0%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in z around 0 87.5%
if 1.04e52 < a < 1.4500000000000001e82Initial program 36.5%
associate-/l*57.1%
Simplified57.1%
Taylor expanded in z around inf 56.8%
associate--l+56.8%
associate-*r/56.8%
associate-*r/56.8%
mul-1-neg56.8%
div-sub56.8%
mul-1-neg56.8%
distribute-lft-out--56.8%
associate-*r/56.8%
mul-1-neg56.8%
unsub-neg56.8%
distribute-rgt-out--56.8%
Simplified56.8%
Taylor expanded in t around 0 67.9%
mul-1-neg67.9%
associate-/l*78.2%
distribute-rgt-neg-in78.2%
distribute-neg-frac278.2%
Simplified78.2%
Taylor expanded in y around 0 79.7%
Final simplification74.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))))
(if (<= a -1.65e+86)
(+ x (* y (/ t a)))
(if (<= a -3e-170)
t_1
(if (<= a 6.2e-191)
(+ t (* y (/ x z)))
(if (<= a 3.1e-82)
(* y (/ (- x t) (- z a)))
(if (<= a 2.5e+24)
t_1
(if (or (<= a 2.7e+44) (not (<= a 1.2e+84)))
(- x (/ x (/ a y)))
(- t (* x (/ a z)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -1.65e+86) {
tmp = x + (y * (t / a));
} else if (a <= -3e-170) {
tmp = t_1;
} else if (a <= 6.2e-191) {
tmp = t + (y * (x / z));
} else if (a <= 3.1e-82) {
tmp = y * ((x - t) / (z - a));
} else if (a <= 2.5e+24) {
tmp = t_1;
} else if ((a <= 2.7e+44) || !(a <= 1.2e+84)) {
tmp = x - (x / (a / y));
} else {
tmp = t - (x * (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) :: t_1
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
if (a <= (-1.65d+86)) then
tmp = x + (y * (t / a))
else if (a <= (-3d-170)) then
tmp = t_1
else if (a <= 6.2d-191) then
tmp = t + (y * (x / z))
else if (a <= 3.1d-82) then
tmp = y * ((x - t) / (z - a))
else if (a <= 2.5d+24) then
tmp = t_1
else if ((a <= 2.7d+44) .or. (.not. (a <= 1.2d+84))) then
tmp = x - (x / (a / y))
else
tmp = t - (x * (a / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -1.65e+86) {
tmp = x + (y * (t / a));
} else if (a <= -3e-170) {
tmp = t_1;
} else if (a <= 6.2e-191) {
tmp = t + (y * (x / z));
} else if (a <= 3.1e-82) {
tmp = y * ((x - t) / (z - a));
} else if (a <= 2.5e+24) {
tmp = t_1;
} else if ((a <= 2.7e+44) || !(a <= 1.2e+84)) {
tmp = x - (x / (a / y));
} else {
tmp = t - (x * (a / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) tmp = 0 if a <= -1.65e+86: tmp = x + (y * (t / a)) elif a <= -3e-170: tmp = t_1 elif a <= 6.2e-191: tmp = t + (y * (x / z)) elif a <= 3.1e-82: tmp = y * ((x - t) / (z - a)) elif a <= 2.5e+24: tmp = t_1 elif (a <= 2.7e+44) or not (a <= 1.2e+84): tmp = x - (x / (a / y)) else: tmp = t - (x * (a / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (a <= -1.65e+86) tmp = Float64(x + Float64(y * Float64(t / a))); elseif (a <= -3e-170) tmp = t_1; elseif (a <= 6.2e-191) tmp = Float64(t + Float64(y * Float64(x / z))); elseif (a <= 3.1e-82) tmp = Float64(y * Float64(Float64(x - t) / Float64(z - a))); elseif (a <= 2.5e+24) tmp = t_1; elseif ((a <= 2.7e+44) || !(a <= 1.2e+84)) tmp = Float64(x - Float64(x / Float64(a / y))); else tmp = Float64(t - Float64(x * Float64(a / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); tmp = 0.0; if (a <= -1.65e+86) tmp = x + (y * (t / a)); elseif (a <= -3e-170) tmp = t_1; elseif (a <= 6.2e-191) tmp = t + (y * (x / z)); elseif (a <= 3.1e-82) tmp = y * ((x - t) / (z - a)); elseif (a <= 2.5e+24) tmp = t_1; elseif ((a <= 2.7e+44) || ~((a <= 1.2e+84))) tmp = x - (x / (a / y)); else tmp = t - (x * (a / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.65e+86], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -3e-170], t$95$1, If[LessEqual[a, 6.2e-191], N[(t + N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.1e-82], N[(y * N[(N[(x - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.5e+24], t$95$1, If[Or[LessEqual[a, 2.7e+44], N[Not[LessEqual[a, 1.2e+84]], $MachinePrecision]], N[(x - N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;a \leq -1.65 \cdot 10^{+86}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq -3 \cdot 10^{-170}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 6.2 \cdot 10^{-191}:\\
\;\;\;\;t + y \cdot \frac{x}{z}\\
\mathbf{elif}\;a \leq 3.1 \cdot 10^{-82}:\\
\;\;\;\;y \cdot \frac{x - t}{z - a}\\
\mathbf{elif}\;a \leq 2.5 \cdot 10^{+24}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{+44} \lor \neg \left(a \leq 1.2 \cdot 10^{+84}\right):\\
\;\;\;\;x - \frac{x}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\end{array}
\end{array}
if a < -1.65e86Initial program 72.3%
associate-/l*82.8%
Simplified82.8%
clear-num82.7%
un-div-inv82.7%
Applied egg-rr82.7%
Taylor expanded in t around inf 77.8%
Taylor expanded in z around 0 59.6%
*-commutative59.6%
associate-/l*63.5%
Simplified63.5%
if -1.65e86 < a < -3.00000000000000013e-170 or 3.1e-82 < a < 2.50000000000000023e24Initial program 68.5%
associate-/l*76.7%
Simplified76.7%
Taylor expanded in x around 0 55.2%
associate-/l*68.7%
Simplified68.7%
if -3.00000000000000013e-170 < a < 6.2000000000000004e-191Initial program 56.8%
associate-/l*67.8%
Simplified67.8%
Taylor expanded in z around inf 89.8%
associate--l+89.8%
associate-*r/89.8%
associate-*r/89.8%
mul-1-neg89.8%
div-sub89.8%
mul-1-neg89.8%
distribute-lft-out--89.8%
associate-*r/89.8%
mul-1-neg89.8%
unsub-neg89.8%
distribute-rgt-out--89.8%
Simplified89.8%
Taylor expanded in t around 0 81.2%
mul-1-neg81.2%
associate-/l*78.7%
distribute-rgt-neg-in78.7%
distribute-neg-frac278.7%
Simplified78.7%
Taylor expanded in y around inf 81.2%
associate-*r/81.2%
*-commutative81.2%
neg-mul-181.2%
distribute-rgt-neg-in81.2%
associate-*r/81.1%
Simplified81.1%
if 6.2000000000000004e-191 < a < 3.1e-82Initial program 83.5%
associate-/l*83.5%
Simplified83.5%
Taylor expanded in y around inf 76.8%
div-sub76.8%
Simplified76.8%
if 2.50000000000000023e24 < a < 2.7e44 or 1.2e84 < a Initial program 70.8%
associate-/l*89.8%
Simplified89.8%
Taylor expanded in t around 0 61.0%
associate-*r/61.0%
mul-1-neg61.0%
distribute-lft-neg-out61.0%
*-commutative61.0%
Simplified61.0%
Taylor expanded in z around 0 62.9%
mul-1-neg62.9%
unsub-neg62.9%
associate-/l*67.8%
Simplified67.8%
clear-num67.8%
un-div-inv67.9%
Applied egg-rr67.9%
if 2.7e44 < a < 1.2e84Initial program 42.7%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 51.1%
associate--l+51.1%
associate-*r/51.1%
associate-*r/51.1%
mul-1-neg51.1%
div-sub51.1%
mul-1-neg51.1%
distribute-lft-out--51.1%
associate-*r/51.1%
mul-1-neg51.1%
unsub-neg51.1%
distribute-rgt-out--51.1%
Simplified51.1%
Taylor expanded in t around 0 61.7%
mul-1-neg61.7%
associate-/l*71.0%
distribute-rgt-neg-in71.0%
distribute-neg-frac271.0%
Simplified71.0%
Taylor expanded in y around 0 72.3%
Final simplification70.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* t (/ y z)))))
(if (<= a -4.5e+70)
(+ x (* y (/ t a)))
(if (<= a -6e-283)
t_1
(if (<= a 1.15e-79)
(* y (/ x (- z a)))
(if (<= a 4.9e+23)
t_1
(if (or (<= a 2.4e+42) (not (<= a 3.2e+84)))
(- x (/ x (/ a y)))
(- t (* x (/ a z))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (t * (y / z));
double tmp;
if (a <= -4.5e+70) {
tmp = x + (y * (t / a));
} else if (a <= -6e-283) {
tmp = t_1;
} else if (a <= 1.15e-79) {
tmp = y * (x / (z - a));
} else if (a <= 4.9e+23) {
tmp = t_1;
} else if ((a <= 2.4e+42) || !(a <= 3.2e+84)) {
tmp = x - (x / (a / y));
} else {
tmp = t - (x * (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) :: t_1
real(8) :: tmp
t_1 = t - (t * (y / z))
if (a <= (-4.5d+70)) then
tmp = x + (y * (t / a))
else if (a <= (-6d-283)) then
tmp = t_1
else if (a <= 1.15d-79) then
tmp = y * (x / (z - a))
else if (a <= 4.9d+23) then
tmp = t_1
else if ((a <= 2.4d+42) .or. (.not. (a <= 3.2d+84))) then
tmp = x - (x / (a / y))
else
tmp = t - (x * (a / 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 - (t * (y / z));
double tmp;
if (a <= -4.5e+70) {
tmp = x + (y * (t / a));
} else if (a <= -6e-283) {
tmp = t_1;
} else if (a <= 1.15e-79) {
tmp = y * (x / (z - a));
} else if (a <= 4.9e+23) {
tmp = t_1;
} else if ((a <= 2.4e+42) || !(a <= 3.2e+84)) {
tmp = x - (x / (a / y));
} else {
tmp = t - (x * (a / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (t * (y / z)) tmp = 0 if a <= -4.5e+70: tmp = x + (y * (t / a)) elif a <= -6e-283: tmp = t_1 elif a <= 1.15e-79: tmp = y * (x / (z - a)) elif a <= 4.9e+23: tmp = t_1 elif (a <= 2.4e+42) or not (a <= 3.2e+84): tmp = x - (x / (a / y)) else: tmp = t - (x * (a / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(t * Float64(y / z))) tmp = 0.0 if (a <= -4.5e+70) tmp = Float64(x + Float64(y * Float64(t / a))); elseif (a <= -6e-283) tmp = t_1; elseif (a <= 1.15e-79) tmp = Float64(y * Float64(x / Float64(z - a))); elseif (a <= 4.9e+23) tmp = t_1; elseif ((a <= 2.4e+42) || !(a <= 3.2e+84)) tmp = Float64(x - Float64(x / Float64(a / y))); else tmp = Float64(t - Float64(x * Float64(a / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (t * (y / z)); tmp = 0.0; if (a <= -4.5e+70) tmp = x + (y * (t / a)); elseif (a <= -6e-283) tmp = t_1; elseif (a <= 1.15e-79) tmp = y * (x / (z - a)); elseif (a <= 4.9e+23) tmp = t_1; elseif ((a <= 2.4e+42) || ~((a <= 3.2e+84))) tmp = x - (x / (a / y)); else tmp = t - (x * (a / z)); 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]}, If[LessEqual[a, -4.5e+70], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -6e-283], t$95$1, If[LessEqual[a, 1.15e-79], N[(y * N[(x / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.9e+23], t$95$1, If[Or[LessEqual[a, 2.4e+42], N[Not[LessEqual[a, 3.2e+84]], $MachinePrecision]], N[(x - N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - t \cdot \frac{y}{z}\\
\mathbf{if}\;a \leq -4.5 \cdot 10^{+70}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\mathbf{elif}\;a \leq -6 \cdot 10^{-283}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.15 \cdot 10^{-79}:\\
\;\;\;\;y \cdot \frac{x}{z - a}\\
\mathbf{elif}\;a \leq 4.9 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.4 \cdot 10^{+42} \lor \neg \left(a \leq 3.2 \cdot 10^{+84}\right):\\
\;\;\;\;x - \frac{x}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\end{array}
\end{array}
if a < -4.4999999999999999e70Initial program 72.9%
associate-/l*83.1%
Simplified83.1%
clear-num83.1%
un-div-inv83.1%
Applied egg-rr83.1%
Taylor expanded in t around inf 78.3%
Taylor expanded in z around 0 58.4%
*-commutative58.4%
associate-/l*62.2%
Simplified62.2%
if -4.4999999999999999e70 < a < -5.99999999999999992e-283 or 1.15000000000000006e-79 < a < 4.9000000000000003e23Initial program 66.7%
associate-/l*75.1%
Simplified75.1%
Taylor expanded in x around 0 55.4%
Taylor expanded in a around 0 41.5%
associate-*r/41.5%
associate-*r*41.5%
neg-mul-141.5%
*-commutative41.5%
Simplified41.5%
Taylor expanded in y around 0 49.7%
mul-1-neg49.7%
unsub-neg49.7%
associate-/l*55.7%
Simplified55.7%
if -5.99999999999999992e-283 < a < 1.15000000000000006e-79Initial program 69.9%
associate-/l*75.8%
Simplified75.8%
Taylor expanded in y around inf 74.2%
div-sub74.2%
Simplified74.2%
Taylor expanded in t around 0 59.9%
neg-mul-159.9%
distribute-neg-frac259.9%
Simplified59.9%
if 4.9000000000000003e23 < a < 2.3999999999999999e42 or 3.2000000000000001e84 < a Initial program 70.8%
associate-/l*89.8%
Simplified89.8%
Taylor expanded in t around 0 61.0%
associate-*r/61.0%
mul-1-neg61.0%
distribute-lft-neg-out61.0%
*-commutative61.0%
Simplified61.0%
Taylor expanded in z around 0 62.9%
mul-1-neg62.9%
unsub-neg62.9%
associate-/l*67.8%
Simplified67.8%
clear-num67.8%
un-div-inv67.9%
Applied egg-rr67.9%
if 2.3999999999999999e42 < a < 3.2000000000000001e84Initial program 42.7%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 51.1%
associate--l+51.1%
associate-*r/51.1%
associate-*r/51.1%
mul-1-neg51.1%
div-sub51.1%
mul-1-neg51.1%
distribute-lft-out--51.1%
associate-*r/51.1%
mul-1-neg51.1%
unsub-neg51.1%
distribute-rgt-out--51.1%
Simplified51.1%
Taylor expanded in t around 0 61.7%
mul-1-neg61.7%
associate-/l*71.0%
distribute-rgt-neg-in71.0%
distribute-neg-frac271.0%
Simplified71.0%
Taylor expanded in y around 0 72.3%
Final simplification61.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* y (/ t a)))) (t_2 (- t (* t (/ y z)))))
(if (<= z -5.8e+121)
t_2
(if (<= z -1.85e+82)
t_1
(if (<= z -1.9e+70)
t_2
(if (<= z -4.8e-9)
(* y (/ (- x t) z))
(if (<= z -3.8e-170)
(- x (* x (/ y a)))
(if (<= z 1.05e+97) t_1 (- t (* x (/ a z)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (y * (t / a));
double t_2 = t - (t * (y / z));
double tmp;
if (z <= -5.8e+121) {
tmp = t_2;
} else if (z <= -1.85e+82) {
tmp = t_1;
} else if (z <= -1.9e+70) {
tmp = t_2;
} else if (z <= -4.8e-9) {
tmp = y * ((x - t) / z);
} else if (z <= -3.8e-170) {
tmp = x - (x * (y / a));
} else if (z <= 1.05e+97) {
tmp = t_1;
} else {
tmp = t - (x * (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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (y * (t / a))
t_2 = t - (t * (y / z))
if (z <= (-5.8d+121)) then
tmp = t_2
else if (z <= (-1.85d+82)) then
tmp = t_1
else if (z <= (-1.9d+70)) then
tmp = t_2
else if (z <= (-4.8d-9)) then
tmp = y * ((x - t) / z)
else if (z <= (-3.8d-170)) then
tmp = x - (x * (y / a))
else if (z <= 1.05d+97) then
tmp = t_1
else
tmp = t - (x * (a / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (y * (t / a));
double t_2 = t - (t * (y / z));
double tmp;
if (z <= -5.8e+121) {
tmp = t_2;
} else if (z <= -1.85e+82) {
tmp = t_1;
} else if (z <= -1.9e+70) {
tmp = t_2;
} else if (z <= -4.8e-9) {
tmp = y * ((x - t) / z);
} else if (z <= -3.8e-170) {
tmp = x - (x * (y / a));
} else if (z <= 1.05e+97) {
tmp = t_1;
} else {
tmp = t - (x * (a / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (y * (t / a)) t_2 = t - (t * (y / z)) tmp = 0 if z <= -5.8e+121: tmp = t_2 elif z <= -1.85e+82: tmp = t_1 elif z <= -1.9e+70: tmp = t_2 elif z <= -4.8e-9: tmp = y * ((x - t) / z) elif z <= -3.8e-170: tmp = x - (x * (y / a)) elif z <= 1.05e+97: tmp = t_1 else: tmp = t - (x * (a / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(y * Float64(t / a))) t_2 = Float64(t - Float64(t * Float64(y / z))) tmp = 0.0 if (z <= -5.8e+121) tmp = t_2; elseif (z <= -1.85e+82) tmp = t_1; elseif (z <= -1.9e+70) tmp = t_2; elseif (z <= -4.8e-9) tmp = Float64(y * Float64(Float64(x - t) / z)); elseif (z <= -3.8e-170) tmp = Float64(x - Float64(x * Float64(y / a))); elseif (z <= 1.05e+97) tmp = t_1; else tmp = Float64(t - Float64(x * Float64(a / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (y * (t / a)); t_2 = t - (t * (y / z)); tmp = 0.0; if (z <= -5.8e+121) tmp = t_2; elseif (z <= -1.85e+82) tmp = t_1; elseif (z <= -1.9e+70) tmp = t_2; elseif (z <= -4.8e-9) tmp = y * ((x - t) / z); elseif (z <= -3.8e-170) tmp = x - (x * (y / a)); elseif (z <= 1.05e+97) tmp = t_1; else tmp = t - (x * (a / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.8e+121], t$95$2, If[LessEqual[z, -1.85e+82], t$95$1, If[LessEqual[z, -1.9e+70], t$95$2, If[LessEqual[z, -4.8e-9], N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.8e-170], N[(x - N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.05e+97], t$95$1, N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + y \cdot \frac{t}{a}\\
t_2 := t - t \cdot \frac{y}{z}\\
\mathbf{if}\;z \leq -5.8 \cdot 10^{+121}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -1.85 \cdot 10^{+82}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.9 \cdot 10^{+70}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -4.8 \cdot 10^{-9}:\\
\;\;\;\;y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{-170}:\\
\;\;\;\;x - x \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{+97}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\end{array}
\end{array}
if z < -5.7999999999999998e121 or -1.8500000000000001e82 < z < -1.8999999999999999e70Initial program 31.6%
associate-/l*60.7%
Simplified60.7%
Taylor expanded in x around 0 39.7%
Taylor expanded in a around 0 34.7%
associate-*r/34.7%
associate-*r*34.7%
neg-mul-134.7%
*-commutative34.7%
Simplified34.7%
Taylor expanded in y around 0 50.4%
mul-1-neg50.4%
unsub-neg50.4%
associate-/l*62.8%
Simplified62.8%
if -5.7999999999999998e121 < z < -1.8500000000000001e82 or -3.7999999999999998e-170 < z < 1.05000000000000006e97Initial program 83.6%
associate-/l*86.7%
Simplified86.7%
clear-num86.6%
un-div-inv86.7%
Applied egg-rr86.7%
Taylor expanded in t around inf 73.1%
Taylor expanded in z around 0 61.0%
*-commutative61.0%
associate-/l*64.0%
Simplified64.0%
if -1.8999999999999999e70 < z < -4.8e-9Initial program 89.0%
associate-/l*93.5%
Simplified93.5%
Taylor expanded in y around inf 60.3%
div-sub60.3%
Simplified60.3%
Taylor expanded in a around 0 48.9%
mul-1-neg48.9%
associate-/l*48.8%
distribute-rgt-neg-in48.8%
distribute-neg-frac248.8%
Simplified48.8%
if -4.8e-9 < z < -3.7999999999999998e-170Initial program 91.3%
associate-/l*91.4%
Simplified91.4%
Taylor expanded in t around 0 72.7%
associate-*r/72.7%
mul-1-neg72.7%
distribute-lft-neg-out72.7%
*-commutative72.7%
Simplified72.7%
Taylor expanded in z around 0 56.8%
mul-1-neg56.8%
unsub-neg56.8%
associate-/l*59.8%
Simplified59.8%
if 1.05000000000000006e97 < z Initial program 28.2%
associate-/l*59.3%
Simplified59.3%
Taylor expanded in z around inf 59.0%
associate--l+59.0%
associate-*r/59.0%
associate-*r/59.0%
mul-1-neg59.0%
div-sub59.0%
mul-1-neg59.0%
distribute-lft-out--59.0%
associate-*r/59.0%
mul-1-neg59.0%
unsub-neg59.0%
distribute-rgt-out--59.1%
Simplified59.1%
Taylor expanded in t around 0 65.2%
mul-1-neg65.2%
associate-/l*79.5%
distribute-rgt-neg-in79.5%
distribute-neg-frac279.5%
Simplified79.5%
Taylor expanded in y around 0 67.6%
Final simplification62.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ (- y a) z))))
(if (<= y -4.3e+39)
(* y (/ (- t x) a))
(if (<= y -1.4e-66)
t_1
(if (<= y 3.6e-299)
x
(if (<= y 1.66e+16)
t
(if (<= y 3.7e+169) t_1 (* t (/ y (- a z))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (y <= -4.3e+39) {
tmp = y * ((t - x) / a);
} else if (y <= -1.4e-66) {
tmp = t_1;
} else if (y <= 3.6e-299) {
tmp = x;
} else if (y <= 1.66e+16) {
tmp = t;
} else if (y <= 3.7e+169) {
tmp = t_1;
} else {
tmp = t * (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) :: t_1
real(8) :: tmp
t_1 = x * ((y - a) / z)
if (y <= (-4.3d+39)) then
tmp = y * ((t - x) / a)
else if (y <= (-1.4d-66)) then
tmp = t_1
else if (y <= 3.6d-299) then
tmp = x
else if (y <= 1.66d+16) then
tmp = t
else if (y <= 3.7d+169) then
tmp = t_1
else
tmp = t * (y / (a - z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * ((y - a) / z);
double tmp;
if (y <= -4.3e+39) {
tmp = y * ((t - x) / a);
} else if (y <= -1.4e-66) {
tmp = t_1;
} else if (y <= 3.6e-299) {
tmp = x;
} else if (y <= 1.66e+16) {
tmp = t;
} else if (y <= 3.7e+169) {
tmp = t_1;
} else {
tmp = t * (y / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * ((y - a) / z) tmp = 0 if y <= -4.3e+39: tmp = y * ((t - x) / a) elif y <= -1.4e-66: tmp = t_1 elif y <= 3.6e-299: tmp = x elif y <= 1.66e+16: tmp = t elif y <= 3.7e+169: tmp = t_1 else: tmp = t * (y / (a - z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(Float64(y - a) / z)) tmp = 0.0 if (y <= -4.3e+39) tmp = Float64(y * Float64(Float64(t - x) / a)); elseif (y <= -1.4e-66) tmp = t_1; elseif (y <= 3.6e-299) tmp = x; elseif (y <= 1.66e+16) tmp = t; elseif (y <= 3.7e+169) tmp = t_1; else tmp = Float64(t * Float64(y / Float64(a - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * ((y - a) / z); tmp = 0.0; if (y <= -4.3e+39) tmp = y * ((t - x) / a); elseif (y <= -1.4e-66) tmp = t_1; elseif (y <= 3.6e-299) tmp = x; elseif (y <= 1.66e+16) tmp = t; elseif (y <= 3.7e+169) tmp = t_1; else tmp = t * (y / (a - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.3e+39], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.4e-66], t$95$1, If[LessEqual[y, 3.6e-299], x, If[LessEqual[y, 1.66e+16], t, If[LessEqual[y, 3.7e+169], t$95$1, N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y - a}{z}\\
\mathbf{if}\;y \leq -4.3 \cdot 10^{+39}:\\
\;\;\;\;y \cdot \frac{t - x}{a}\\
\mathbf{elif}\;y \leq -1.4 \cdot 10^{-66}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{-299}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.66 \cdot 10^{+16}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 3.7 \cdot 10^{+169}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\end{array}
\end{array}
if y < -4.3e39Initial program 72.9%
associate-/l*87.7%
Simplified87.7%
Taylor expanded in y around inf 66.4%
div-sub66.4%
Simplified66.4%
Taylor expanded in a around inf 47.1%
if -4.3e39 < y < -1.4e-66 or 1.66e16 < y < 3.70000000000000001e169Initial program 60.9%
associate-/l*66.0%
Simplified66.0%
Taylor expanded in z around inf 56.3%
associate--l+56.3%
associate-*r/56.3%
associate-*r/56.3%
mul-1-neg56.3%
div-sub56.3%
mul-1-neg56.3%
distribute-lft-out--56.3%
associate-*r/56.3%
mul-1-neg56.3%
unsub-neg56.3%
distribute-rgt-out--56.6%
Simplified56.6%
Taylor expanded in t around 0 38.1%
associate-/l*41.1%
Simplified41.1%
if -1.4e-66 < y < 3.6e-299Initial program 82.2%
associate-/l*89.4%
Simplified89.4%
Taylor expanded in a around inf 58.4%
if 3.6e-299 < y < 1.66e16Initial program 53.8%
associate-/l*68.9%
Simplified68.9%
Taylor expanded in z around inf 35.7%
if 3.70000000000000001e169 < y Initial program 73.4%
associate-/l*87.8%
Simplified87.8%
Taylor expanded in x around 0 45.0%
Taylor expanded in y around inf 42.2%
associate-/l*52.1%
Simplified52.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) a))))
(if (<= a -2.85e+205)
t_1
(if (<= a -6.6e+100)
x
(if (<= a -1.8e-71)
t_1
(if (<= a -3.9e-276)
t
(if (<= a 1.15e-64)
(* x (/ (- y a) z))
(if (<= a 4.1e+83) t x))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / a);
double tmp;
if (a <= -2.85e+205) {
tmp = t_1;
} else if (a <= -6.6e+100) {
tmp = x;
} else if (a <= -1.8e-71) {
tmp = t_1;
} else if (a <= -3.9e-276) {
tmp = t;
} else if (a <= 1.15e-64) {
tmp = x * ((y - a) / z);
} else if (a <= 4.1e+83) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t * ((y - z) / a)
if (a <= (-2.85d+205)) then
tmp = t_1
else if (a <= (-6.6d+100)) then
tmp = x
else if (a <= (-1.8d-71)) then
tmp = t_1
else if (a <= (-3.9d-276)) then
tmp = t
else if (a <= 1.15d-64) then
tmp = x * ((y - a) / z)
else if (a <= 4.1d+83) 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 * ((y - z) / a);
double tmp;
if (a <= -2.85e+205) {
tmp = t_1;
} else if (a <= -6.6e+100) {
tmp = x;
} else if (a <= -1.8e-71) {
tmp = t_1;
} else if (a <= -3.9e-276) {
tmp = t;
} else if (a <= 1.15e-64) {
tmp = x * ((y - a) / z);
} else if (a <= 4.1e+83) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / a) tmp = 0 if a <= -2.85e+205: tmp = t_1 elif a <= -6.6e+100: tmp = x elif a <= -1.8e-71: tmp = t_1 elif a <= -3.9e-276: tmp = t elif a <= 1.15e-64: tmp = x * ((y - a) / z) elif a <= 4.1e+83: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / a)) tmp = 0.0 if (a <= -2.85e+205) tmp = t_1; elseif (a <= -6.6e+100) tmp = x; elseif (a <= -1.8e-71) tmp = t_1; elseif (a <= -3.9e-276) tmp = t; elseif (a <= 1.15e-64) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (a <= 4.1e+83) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / a); tmp = 0.0; if (a <= -2.85e+205) tmp = t_1; elseif (a <= -6.6e+100) tmp = x; elseif (a <= -1.8e-71) tmp = t_1; elseif (a <= -3.9e-276) tmp = t; elseif (a <= 1.15e-64) tmp = x * ((y - a) / z); elseif (a <= 4.1e+83) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.85e+205], t$95$1, If[LessEqual[a, -6.6e+100], x, If[LessEqual[a, -1.8e-71], t$95$1, If[LessEqual[a, -3.9e-276], t, If[LessEqual[a, 1.15e-64], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.1e+83], t, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a}\\
\mathbf{if}\;a \leq -2.85 \cdot 10^{+205}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -6.6 \cdot 10^{+100}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.8 \cdot 10^{-71}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -3.9 \cdot 10^{-276}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 1.15 \cdot 10^{-64}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;a \leq 4.1 \cdot 10^{+83}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -2.84999999999999981e205 or -6.6000000000000002e100 < a < -1.8e-71Initial program 72.1%
associate-/l*86.5%
Simplified86.5%
Taylor expanded in x around 0 43.5%
Taylor expanded in a around inf 34.9%
associate-/l*48.8%
Simplified48.8%
if -2.84999999999999981e205 < a < -6.6000000000000002e100 or 4.1000000000000001e83 < a Initial program 72.1%
associate-/l*87.9%
Simplified87.9%
Taylor expanded in a around inf 56.6%
if -1.8e-71 < a < -3.9e-276 or 1.1500000000000001e-64 < a < 4.1000000000000001e83Initial program 61.7%
associate-/l*70.5%
Simplified70.5%
Taylor expanded in z around inf 41.0%
if -3.9e-276 < a < 1.1500000000000001e-64Initial program 68.6%
associate-/l*72.2%
Simplified72.2%
Taylor expanded in z around inf 68.8%
associate--l+68.8%
associate-*r/68.8%
associate-*r/68.8%
mul-1-neg68.8%
div-sub68.8%
mul-1-neg68.8%
distribute-lft-out--68.8%
associate-*r/68.8%
mul-1-neg68.8%
unsub-neg68.8%
distribute-rgt-out--68.8%
Simplified68.8%
Taylor expanded in t around 0 49.8%
associate-/l*48.0%
Simplified48.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ y (- a z)))))
(if (<= z -6.5e+130)
t
(if (<= z -1.55e-125)
x
(if (<= z -2.5e-296)
t_1
(if (<= z 4e+19) x (if (<= z 7e+59) t_1 (if (<= z 3.1e+90) 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 <= -6.5e+130) {
tmp = t;
} else if (z <= -1.55e-125) {
tmp = x;
} else if (z <= -2.5e-296) {
tmp = t_1;
} else if (z <= 4e+19) {
tmp = x;
} else if (z <= 7e+59) {
tmp = t_1;
} else if (z <= 3.1e+90) {
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 <= (-6.5d+130)) then
tmp = t
else if (z <= (-1.55d-125)) then
tmp = x
else if (z <= (-2.5d-296)) then
tmp = t_1
else if (z <= 4d+19) then
tmp = x
else if (z <= 7d+59) then
tmp = t_1
else if (z <= 3.1d+90) 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 <= -6.5e+130) {
tmp = t;
} else if (z <= -1.55e-125) {
tmp = x;
} else if (z <= -2.5e-296) {
tmp = t_1;
} else if (z <= 4e+19) {
tmp = x;
} else if (z <= 7e+59) {
tmp = t_1;
} else if (z <= 3.1e+90) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (y / (a - z)) tmp = 0 if z <= -6.5e+130: tmp = t elif z <= -1.55e-125: tmp = x elif z <= -2.5e-296: tmp = t_1 elif z <= 4e+19: tmp = x elif z <= 7e+59: tmp = t_1 elif z <= 3.1e+90: 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 <= -6.5e+130) tmp = t; elseif (z <= -1.55e-125) tmp = x; elseif (z <= -2.5e-296) tmp = t_1; elseif (z <= 4e+19) tmp = x; elseif (z <= 7e+59) tmp = t_1; elseif (z <= 3.1e+90) 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 <= -6.5e+130) tmp = t; elseif (z <= -1.55e-125) tmp = x; elseif (z <= -2.5e-296) tmp = t_1; elseif (z <= 4e+19) tmp = x; elseif (z <= 7e+59) tmp = t_1; elseif (z <= 3.1e+90) 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, -6.5e+130], t, If[LessEqual[z, -1.55e-125], x, If[LessEqual[z, -2.5e-296], t$95$1, If[LessEqual[z, 4e+19], x, If[LessEqual[z, 7e+59], t$95$1, If[LessEqual[z, 3.1e+90], x, t]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y}{a - z}\\
\mathbf{if}\;z \leq -6.5 \cdot 10^{+130}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.55 \cdot 10^{-125}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -2.5 \cdot 10^{-296}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+19}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 7 \cdot 10^{+59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -6.5e130 or 3.09999999999999988e90 < z Initial program 28.5%
associate-/l*58.4%
Simplified58.4%
Taylor expanded in z around inf 52.1%
if -6.5e130 < z < -1.55000000000000006e-125 or -2.50000000000000015e-296 < z < 4e19 or 7e59 < z < 3.09999999999999988e90Initial program 83.0%
associate-/l*85.0%
Simplified85.0%
Taylor expanded in a around inf 38.8%
if -1.55000000000000006e-125 < z < -2.50000000000000015e-296 or 4e19 < z < 7e59Initial program 89.0%
associate-/l*96.7%
Simplified96.7%
Taylor expanded in x around 0 52.4%
Taylor expanded in y around inf 46.5%
associate-/l*51.0%
Simplified51.0%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.26e+197)
(+ t (* x (/ (- y a) z)))
(if (<= z -1.76e+93)
(+ x (/ (- y z) (/ (- a z) t)))
(if (<= z -3.7e+38)
(+ t (* (- y a) (/ x z)))
(if (<= z 2.6e+95)
(+ x (* (- x t) (/ (- z y) a)))
(+ t (* x (* (- y a) (/ 1.0 z)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.26e+197) {
tmp = t + (x * ((y - a) / z));
} else if (z <= -1.76e+93) {
tmp = x + ((y - z) / ((a - z) / t));
} else if (z <= -3.7e+38) {
tmp = t + ((y - a) * (x / z));
} else if (z <= 2.6e+95) {
tmp = x + ((x - t) * ((z - y) / a));
} else {
tmp = t + (x * ((y - a) * (1.0 / 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 <= (-1.26d+197)) then
tmp = t + (x * ((y - a) / z))
else if (z <= (-1.76d+93)) then
tmp = x + ((y - z) / ((a - z) / t))
else if (z <= (-3.7d+38)) then
tmp = t + ((y - a) * (x / z))
else if (z <= 2.6d+95) then
tmp = x + ((x - t) * ((z - y) / a))
else
tmp = t + (x * ((y - a) * (1.0d0 / 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 <= -1.26e+197) {
tmp = t + (x * ((y - a) / z));
} else if (z <= -1.76e+93) {
tmp = x + ((y - z) / ((a - z) / t));
} else if (z <= -3.7e+38) {
tmp = t + ((y - a) * (x / z));
} else if (z <= 2.6e+95) {
tmp = x + ((x - t) * ((z - y) / a));
} else {
tmp = t + (x * ((y - a) * (1.0 / z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.26e+197: tmp = t + (x * ((y - a) / z)) elif z <= -1.76e+93: tmp = x + ((y - z) / ((a - z) / t)) elif z <= -3.7e+38: tmp = t + ((y - a) * (x / z)) elif z <= 2.6e+95: tmp = x + ((x - t) * ((z - y) / a)) else: tmp = t + (x * ((y - a) * (1.0 / z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.26e+197) tmp = Float64(t + Float64(x * Float64(Float64(y - a) / z))); elseif (z <= -1.76e+93) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / t))); elseif (z <= -3.7e+38) tmp = Float64(t + Float64(Float64(y - a) * Float64(x / z))); elseif (z <= 2.6e+95) tmp = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / a))); else tmp = Float64(t + Float64(x * Float64(Float64(y - a) * Float64(1.0 / z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.26e+197) tmp = t + (x * ((y - a) / z)); elseif (z <= -1.76e+93) tmp = x + ((y - z) / ((a - z) / t)); elseif (z <= -3.7e+38) tmp = t + ((y - a) * (x / z)); elseif (z <= 2.6e+95) tmp = x + ((x - t) * ((z - y) / a)); else tmp = t + (x * ((y - a) * (1.0 / z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.26e+197], N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.76e+93], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.7e+38], N[(t + N[(N[(y - a), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.6e+95], N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x * N[(N[(y - a), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.26 \cdot 10^{+197}:\\
\;\;\;\;t + x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq -1.76 \cdot 10^{+93}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t}}\\
\mathbf{elif}\;z \leq -3.7 \cdot 10^{+38}:\\
\;\;\;\;t + \left(y - a\right) \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq 2.6 \cdot 10^{+95}:\\
\;\;\;\;x + \left(x - t\right) \cdot \frac{z - y}{a}\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \left(\left(y - a\right) \cdot \frac{1}{z}\right)\\
\end{array}
\end{array}
if z < -1.26e197Initial program 23.2%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in z around inf 66.0%
associate--l+66.0%
associate-*r/66.0%
associate-*r/66.0%
mul-1-neg66.0%
div-sub66.0%
mul-1-neg66.0%
distribute-lft-out--66.0%
associate-*r/66.0%
mul-1-neg66.0%
unsub-neg66.0%
distribute-rgt-out--66.2%
Simplified66.2%
Taylor expanded in t around 0 72.2%
mul-1-neg72.2%
associate-/l*90.5%
distribute-rgt-neg-in90.5%
distribute-neg-frac290.5%
Simplified90.5%
if -1.26e197 < z < -1.75999999999999994e93Initial program 40.3%
associate-/l*79.5%
Simplified79.5%
clear-num79.4%
un-div-inv79.4%
Applied egg-rr79.4%
Taylor expanded in t around inf 67.6%
if -1.75999999999999994e93 < z < -3.7000000000000001e38Initial program 50.5%
associate-/l*68.4%
Simplified68.4%
Taylor expanded in z around inf 68.6%
associate--l+68.6%
associate-*r/68.6%
associate-*r/68.6%
mul-1-neg68.6%
div-sub68.6%
mul-1-neg68.6%
distribute-lft-out--68.6%
associate-*r/68.6%
mul-1-neg68.6%
unsub-neg68.6%
distribute-rgt-out--69.1%
Simplified69.1%
Taylor expanded in t around 0 68.3%
mul-1-neg68.3%
associate-/l*70.4%
distribute-rgt-neg-in70.4%
distribute-neg-frac270.4%
Simplified70.4%
Taylor expanded in x around 0 68.3%
mul-1-neg68.3%
distribute-neg-frac268.3%
*-commutative68.3%
neg-mul-168.3%
*-commutative68.3%
associate-/l*70.4%
*-commutative70.4%
neg-mul-170.4%
distribute-neg-frac270.4%
distribute-frac-neg70.4%
Simplified70.4%
if -3.7000000000000001e38 < z < 2.5999999999999999e95Initial program 88.9%
associate-/l*90.0%
Simplified90.0%
Taylor expanded in a around inf 72.9%
associate-/l*75.9%
Simplified75.9%
if 2.5999999999999999e95 < z Initial program 28.2%
associate-/l*59.3%
Simplified59.3%
Taylor expanded in z around inf 59.0%
associate--l+59.0%
associate-*r/59.0%
associate-*r/59.0%
mul-1-neg59.0%
div-sub59.0%
mul-1-neg59.0%
distribute-lft-out--59.0%
associate-*r/59.0%
mul-1-neg59.0%
unsub-neg59.0%
distribute-rgt-out--59.1%
Simplified59.1%
Taylor expanded in t around 0 65.2%
mul-1-neg65.2%
associate-/l*79.5%
distribute-rgt-neg-in79.5%
distribute-neg-frac279.5%
Simplified79.5%
frac-2neg79.5%
div-inv79.5%
remove-double-neg79.5%
Applied egg-rr79.5%
Final simplification76.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* x (/ (- y a) z)))))
(if (<= z -4.1e+203)
t_1
(if (<= z -3.3e+93)
(+ x (/ (- y z) (/ (- a z) t)))
(if (<= z -1.65e+39)
(+ t (* (- y a) (/ x z)))
(if (<= z 2.3e+97) (+ x (* (- x t) (/ (- z y) a))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (x * ((y - a) / z));
double tmp;
if (z <= -4.1e+203) {
tmp = t_1;
} else if (z <= -3.3e+93) {
tmp = x + ((y - z) / ((a - z) / t));
} else if (z <= -1.65e+39) {
tmp = t + ((y - a) * (x / z));
} else if (z <= 2.3e+97) {
tmp = x + ((x - t) * ((z - 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 + (x * ((y - a) / z))
if (z <= (-4.1d+203)) then
tmp = t_1
else if (z <= (-3.3d+93)) then
tmp = x + ((y - z) / ((a - z) / t))
else if (z <= (-1.65d+39)) then
tmp = t + ((y - a) * (x / z))
else if (z <= 2.3d+97) then
tmp = x + ((x - t) * ((z - 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 + (x * ((y - a) / z));
double tmp;
if (z <= -4.1e+203) {
tmp = t_1;
} else if (z <= -3.3e+93) {
tmp = x + ((y - z) / ((a - z) / t));
} else if (z <= -1.65e+39) {
tmp = t + ((y - a) * (x / z));
} else if (z <= 2.3e+97) {
tmp = x + ((x - t) * ((z - y) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (x * ((y - a) / z)) tmp = 0 if z <= -4.1e+203: tmp = t_1 elif z <= -3.3e+93: tmp = x + ((y - z) / ((a - z) / t)) elif z <= -1.65e+39: tmp = t + ((y - a) * (x / z)) elif z <= 2.3e+97: tmp = x + ((x - t) * ((z - y) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(x * Float64(Float64(y - a) / z))) tmp = 0.0 if (z <= -4.1e+203) tmp = t_1; elseif (z <= -3.3e+93) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / t))); elseif (z <= -1.65e+39) tmp = Float64(t + Float64(Float64(y - a) * Float64(x / z))); elseif (z <= 2.3e+97) tmp = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (x * ((y - a) / z)); tmp = 0.0; if (z <= -4.1e+203) tmp = t_1; elseif (z <= -3.3e+93) tmp = x + ((y - z) / ((a - z) / t)); elseif (z <= -1.65e+39) tmp = t + ((y - a) * (x / z)); elseif (z <= 2.3e+97) tmp = x + ((x - t) * ((z - y) / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.1e+203], t$95$1, If[LessEqual[z, -3.3e+93], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.65e+39], N[(t + N[(N[(y - a), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.3e+97], N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + x \cdot \frac{y - a}{z}\\
\mathbf{if}\;z \leq -4.1 \cdot 10^{+203}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3.3 \cdot 10^{+93}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t}}\\
\mathbf{elif}\;z \leq -1.65 \cdot 10^{+39}:\\
\;\;\;\;t + \left(y - a\right) \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq 2.3 \cdot 10^{+97}:\\
\;\;\;\;x + \left(x - t\right) \cdot \frac{z - y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -4.10000000000000016e203 or 2.30000000000000006e97 < z Initial program 26.4%
associate-/l*54.3%
Simplified54.3%
Taylor expanded in z around inf 61.4%
associate--l+61.4%
associate-*r/61.4%
associate-*r/61.4%
mul-1-neg61.4%
div-sub61.4%
mul-1-neg61.4%
distribute-lft-out--61.4%
associate-*r/61.4%
mul-1-neg61.4%
unsub-neg61.4%
distribute-rgt-out--61.5%
Simplified61.5%
Taylor expanded in t around 0 67.6%
mul-1-neg67.6%
associate-/l*83.3%
distribute-rgt-neg-in83.3%
distribute-neg-frac283.3%
Simplified83.3%
if -4.10000000000000016e203 < z < -3.30000000000000009e93Initial program 40.3%
associate-/l*79.5%
Simplified79.5%
clear-num79.4%
un-div-inv79.4%
Applied egg-rr79.4%
Taylor expanded in t around inf 67.6%
if -3.30000000000000009e93 < z < -1.6500000000000001e39Initial program 50.5%
associate-/l*68.4%
Simplified68.4%
Taylor expanded in z around inf 68.6%
associate--l+68.6%
associate-*r/68.6%
associate-*r/68.6%
mul-1-neg68.6%
div-sub68.6%
mul-1-neg68.6%
distribute-lft-out--68.6%
associate-*r/68.6%
mul-1-neg68.6%
unsub-neg68.6%
distribute-rgt-out--69.1%
Simplified69.1%
Taylor expanded in t around 0 68.3%
mul-1-neg68.3%
associate-/l*70.4%
distribute-rgt-neg-in70.4%
distribute-neg-frac270.4%
Simplified70.4%
Taylor expanded in x around 0 68.3%
mul-1-neg68.3%
distribute-neg-frac268.3%
*-commutative68.3%
neg-mul-168.3%
*-commutative68.3%
associate-/l*70.4%
*-commutative70.4%
neg-mul-170.4%
distribute-neg-frac270.4%
distribute-frac-neg70.4%
Simplified70.4%
if -1.6500000000000001e39 < z < 2.30000000000000006e97Initial program 88.9%
associate-/l*90.0%
Simplified90.0%
Taylor expanded in a around inf 72.9%
associate-/l*75.9%
Simplified75.9%
Final simplification76.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* x (/ (- y a) z)))))
(if (<= z -1.35e+70)
t_1
(if (<= z -7.5e-81)
(* x (+ (/ (- y z) (- z a)) 1.0))
(if (<= z 2.5e-97)
(+ x (/ (* (- y z) (- t x)) a))
(if (<= z 3.6e+95) (+ x (* (- x t) (/ (- z y) a))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (x * ((y - a) / z));
double tmp;
if (z <= -1.35e+70) {
tmp = t_1;
} else if (z <= -7.5e-81) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else if (z <= 2.5e-97) {
tmp = x + (((y - z) * (t - x)) / a);
} else if (z <= 3.6e+95) {
tmp = x + ((x - t) * ((z - 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 + (x * ((y - a) / z))
if (z <= (-1.35d+70)) then
tmp = t_1
else if (z <= (-7.5d-81)) then
tmp = x * (((y - z) / (z - a)) + 1.0d0)
else if (z <= 2.5d-97) then
tmp = x + (((y - z) * (t - x)) / a)
else if (z <= 3.6d+95) then
tmp = x + ((x - t) * ((z - 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 + (x * ((y - a) / z));
double tmp;
if (z <= -1.35e+70) {
tmp = t_1;
} else if (z <= -7.5e-81) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else if (z <= 2.5e-97) {
tmp = x + (((y - z) * (t - x)) / a);
} else if (z <= 3.6e+95) {
tmp = x + ((x - t) * ((z - y) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (x * ((y - a) / z)) tmp = 0 if z <= -1.35e+70: tmp = t_1 elif z <= -7.5e-81: tmp = x * (((y - z) / (z - a)) + 1.0) elif z <= 2.5e-97: tmp = x + (((y - z) * (t - x)) / a) elif z <= 3.6e+95: tmp = x + ((x - t) * ((z - y) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(x * Float64(Float64(y - a) / z))) tmp = 0.0 if (z <= -1.35e+70) tmp = t_1; elseif (z <= -7.5e-81) tmp = Float64(x * Float64(Float64(Float64(y - z) / Float64(z - a)) + 1.0)); elseif (z <= 2.5e-97) tmp = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / a)); elseif (z <= 3.6e+95) tmp = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (x * ((y - a) / z)); tmp = 0.0; if (z <= -1.35e+70) tmp = t_1; elseif (z <= -7.5e-81) tmp = x * (((y - z) / (z - a)) + 1.0); elseif (z <= 2.5e-97) tmp = x + (((y - z) * (t - x)) / a); elseif (z <= 3.6e+95) tmp = x + ((x - t) * ((z - y) / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.35e+70], t$95$1, If[LessEqual[z, -7.5e-81], N[(x * N[(N[(N[(y - z), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.5e-97], N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.6e+95], N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + x \cdot \frac{y - a}{z}\\
\mathbf{if}\;z \leq -1.35 \cdot 10^{+70}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -7.5 \cdot 10^{-81}:\\
\;\;\;\;x \cdot \left(\frac{y - z}{z - a} + 1\right)\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{-97}:\\
\;\;\;\;x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a}\\
\mathbf{elif}\;z \leq 3.6 \cdot 10^{+95}:\\
\;\;\;\;x + \left(x - t\right) \cdot \frac{z - y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.35e70 or 3.59999999999999978e95 < z Initial program 30.3%
associate-/l*60.3%
Simplified60.3%
Taylor expanded in z around inf 54.7%
associate--l+54.7%
associate-*r/54.7%
associate-*r/54.7%
mul-1-neg54.7%
div-sub54.7%
mul-1-neg54.7%
distribute-lft-out--54.7%
associate-*r/54.7%
mul-1-neg54.7%
unsub-neg54.7%
distribute-rgt-out--55.1%
Simplified55.1%
Taylor expanded in t around 0 61.3%
mul-1-neg61.3%
associate-/l*73.0%
distribute-rgt-neg-in73.0%
distribute-neg-frac273.0%
Simplified73.0%
if -1.35e70 < z < -7.50000000000000018e-81Initial program 86.7%
associate-/l*92.8%
Simplified92.8%
Taylor expanded in x around inf 67.5%
mul-1-neg67.5%
unsub-neg67.5%
Simplified67.5%
if -7.50000000000000018e-81 < z < 2.4999999999999998e-97Initial program 96.9%
associate-/l*94.9%
Simplified94.9%
add-cube-cbrt94.0%
fma-define94.0%
pow294.0%
*-commutative94.0%
associate-*l/96.0%
associate-*r/92.2%
Applied egg-rr92.2%
Taylor expanded in a around inf 86.6%
if 2.4999999999999998e-97 < z < 3.59999999999999978e95Initial program 71.9%
associate-/l*76.4%
Simplified76.4%
Taylor expanded in a around inf 57.3%
associate-/l*68.4%
Simplified68.4%
Final simplification76.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (* y (/ (- x t) a)))) (t_2 (+ t (* y (/ x z)))))
(if (<= z -1.4e+120)
t_2
(if (<= z -6.9e+81)
t_1
(if (<= z -1.35e-13)
t_2
(if (<= z 1.8e+15) t_1 (* t (/ (- y z) (- a z)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - (y * ((x - t) / a));
double t_2 = t + (y * (x / z));
double tmp;
if (z <= -1.4e+120) {
tmp = t_2;
} else if (z <= -6.9e+81) {
tmp = t_1;
} else if (z <= -1.35e-13) {
tmp = t_2;
} else if (z <= 1.8e+15) {
tmp = t_1;
} else {
tmp = t * ((y - z) / (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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x - (y * ((x - t) / a))
t_2 = t + (y * (x / z))
if (z <= (-1.4d+120)) then
tmp = t_2
else if (z <= (-6.9d+81)) then
tmp = t_1
else if (z <= (-1.35d-13)) then
tmp = t_2
else if (z <= 1.8d+15) then
tmp = t_1
else
tmp = t * ((y - z) / (a - z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - (y * ((x - t) / a));
double t_2 = t + (y * (x / z));
double tmp;
if (z <= -1.4e+120) {
tmp = t_2;
} else if (z <= -6.9e+81) {
tmp = t_1;
} else if (z <= -1.35e-13) {
tmp = t_2;
} else if (z <= 1.8e+15) {
tmp = t_1;
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - (y * ((x - t) / a)) t_2 = t + (y * (x / z)) tmp = 0 if z <= -1.4e+120: tmp = t_2 elif z <= -6.9e+81: tmp = t_1 elif z <= -1.35e-13: tmp = t_2 elif z <= 1.8e+15: tmp = t_1 else: tmp = t * ((y - z) / (a - z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(y * Float64(Float64(x - t) / a))) t_2 = Float64(t + Float64(y * Float64(x / z))) tmp = 0.0 if (z <= -1.4e+120) tmp = t_2; elseif (z <= -6.9e+81) tmp = t_1; elseif (z <= -1.35e-13) tmp = t_2; elseif (z <= 1.8e+15) tmp = t_1; else tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - (y * ((x - t) / a)); t_2 = t + (y * (x / z)); tmp = 0.0; if (z <= -1.4e+120) tmp = t_2; elseif (z <= -6.9e+81) tmp = t_1; elseif (z <= -1.35e-13) tmp = t_2; elseif (z <= 1.8e+15) tmp = t_1; else tmp = t * ((y - z) / (a - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(y * N[(N[(x - t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.4e+120], t$95$2, If[LessEqual[z, -6.9e+81], t$95$1, If[LessEqual[z, -1.35e-13], t$95$2, If[LessEqual[z, 1.8e+15], t$95$1, N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - y \cdot \frac{x - t}{a}\\
t_2 := t + y \cdot \frac{x}{z}\\
\mathbf{if}\;z \leq -1.4 \cdot 10^{+120}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -6.9 \cdot 10^{+81}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.35 \cdot 10^{-13}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 1.8 \cdot 10^{+15}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if z < -1.4e120 or -6.8999999999999996e81 < z < -1.35000000000000005e-13Initial program 49.4%
associate-/l*70.3%
Simplified70.3%
Taylor expanded in z around inf 55.9%
associate--l+55.9%
associate-*r/55.9%
associate-*r/55.9%
mul-1-neg55.9%
div-sub55.9%
mul-1-neg55.9%
distribute-lft-out--55.9%
associate-*r/55.9%
mul-1-neg55.9%
unsub-neg55.9%
distribute-rgt-out--56.2%
Simplified56.2%
Taylor expanded in t around 0 59.4%
mul-1-neg59.4%
associate-/l*67.4%
distribute-rgt-neg-in67.4%
distribute-neg-frac267.4%
Simplified67.4%
Taylor expanded in y around inf 58.6%
associate-*r/58.6%
*-commutative58.6%
neg-mul-158.6%
distribute-rgt-neg-in58.6%
associate-*r/64.1%
Simplified64.1%
if -1.4e120 < z < -6.8999999999999996e81 or -1.35000000000000005e-13 < z < 1.8e15Initial program 87.7%
associate-/l*89.2%
Simplified89.2%
add-cube-cbrt88.4%
fma-define88.4%
pow288.4%
*-commutative88.4%
associate-*l/86.9%
associate-*r/88.5%
Applied egg-rr88.5%
Taylor expanded in z around 0 72.3%
associate-/l*75.2%
Simplified75.2%
if 1.8e15 < z Initial program 44.4%
associate-/l*67.3%
Simplified67.3%
Taylor expanded in x around 0 38.9%
associate-/l*62.7%
Simplified62.7%
Final simplification69.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* x (/ (- y a) z)))))
(if (<= z -2.35e+70)
t_1
(if (<= z -1.25e-77)
(* x (+ (/ (- y z) (- z a)) 1.0))
(if (<= z 1.2e+95) (- x (* y (/ (- x t) a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (x * ((y - a) / z));
double tmp;
if (z <= -2.35e+70) {
tmp = t_1;
} else if (z <= -1.25e-77) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else if (z <= 1.2e+95) {
tmp = x - (y * ((x - t) / 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 + (x * ((y - a) / z))
if (z <= (-2.35d+70)) then
tmp = t_1
else if (z <= (-1.25d-77)) then
tmp = x * (((y - z) / (z - a)) + 1.0d0)
else if (z <= 1.2d+95) then
tmp = x - (y * ((x - t) / 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 + (x * ((y - a) / z));
double tmp;
if (z <= -2.35e+70) {
tmp = t_1;
} else if (z <= -1.25e-77) {
tmp = x * (((y - z) / (z - a)) + 1.0);
} else if (z <= 1.2e+95) {
tmp = x - (y * ((x - t) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (x * ((y - a) / z)) tmp = 0 if z <= -2.35e+70: tmp = t_1 elif z <= -1.25e-77: tmp = x * (((y - z) / (z - a)) + 1.0) elif z <= 1.2e+95: tmp = x - (y * ((x - t) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(x * Float64(Float64(y - a) / z))) tmp = 0.0 if (z <= -2.35e+70) tmp = t_1; elseif (z <= -1.25e-77) tmp = Float64(x * Float64(Float64(Float64(y - z) / Float64(z - a)) + 1.0)); elseif (z <= 1.2e+95) tmp = Float64(x - Float64(y * Float64(Float64(x - t) / a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (x * ((y - a) / z)); tmp = 0.0; if (z <= -2.35e+70) tmp = t_1; elseif (z <= -1.25e-77) tmp = x * (((y - z) / (z - a)) + 1.0); elseif (z <= 1.2e+95) tmp = x - (y * ((x - t) / a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.35e+70], t$95$1, If[LessEqual[z, -1.25e-77], N[(x * N[(N[(N[(y - z), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.2e+95], N[(x - N[(y * N[(N[(x - t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + x \cdot \frac{y - a}{z}\\
\mathbf{if}\;z \leq -2.35 \cdot 10^{+70}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.25 \cdot 10^{-77}:\\
\;\;\;\;x \cdot \left(\frac{y - z}{z - a} + 1\right)\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{+95}:\\
\;\;\;\;x - y \cdot \frac{x - t}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.3499999999999999e70 or 1.2e95 < z Initial program 30.3%
associate-/l*60.3%
Simplified60.3%
Taylor expanded in z around inf 54.7%
associate--l+54.7%
associate-*r/54.7%
associate-*r/54.7%
mul-1-neg54.7%
div-sub54.7%
mul-1-neg54.7%
distribute-lft-out--54.7%
associate-*r/54.7%
mul-1-neg54.7%
unsub-neg54.7%
distribute-rgt-out--55.1%
Simplified55.1%
Taylor expanded in t around 0 61.3%
mul-1-neg61.3%
associate-/l*73.0%
distribute-rgt-neg-in73.0%
distribute-neg-frac273.0%
Simplified73.0%
if -2.3499999999999999e70 < z < -1.24999999999999991e-77Initial program 86.7%
associate-/l*92.8%
Simplified92.8%
Taylor expanded in x around inf 67.5%
mul-1-neg67.5%
unsub-neg67.5%
Simplified67.5%
if -1.24999999999999991e-77 < z < 1.2e95Initial program 89.1%
associate-/l*89.1%
Simplified89.1%
add-cube-cbrt88.3%
fma-define88.3%
pow288.3%
*-commutative88.3%
associate-*l/88.3%
associate-*r/89.8%
Applied egg-rr89.8%
Taylor expanded in z around 0 72.0%
associate-/l*72.7%
Simplified72.7%
Final simplification72.2%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.7e-10)
(+ t (* y (/ x z)))
(if (<= z -5.6e-167)
(- x (* x (/ y a)))
(if (<= z 4.7e+14) (+ x (* y (/ t a))) (* t (/ (- y z) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.7e-10) {
tmp = t + (y * (x / z));
} else if (z <= -5.6e-167) {
tmp = x - (x * (y / a));
} else if (z <= 4.7e+14) {
tmp = x + (y * (t / a));
} else {
tmp = t * ((y - z) / (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 <= (-2.7d-10)) then
tmp = t + (y * (x / z))
else if (z <= (-5.6d-167)) then
tmp = x - (x * (y / a))
else if (z <= 4.7d+14) then
tmp = x + (y * (t / a))
else
tmp = t * ((y - z) / (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 <= -2.7e-10) {
tmp = t + (y * (x / z));
} else if (z <= -5.6e-167) {
tmp = x - (x * (y / a));
} else if (z <= 4.7e+14) {
tmp = x + (y * (t / a));
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.7e-10: tmp = t + (y * (x / z)) elif z <= -5.6e-167: tmp = x - (x * (y / a)) elif z <= 4.7e+14: tmp = x + (y * (t / a)) else: tmp = t * ((y - z) / (a - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.7e-10) tmp = Float64(t + Float64(y * Float64(x / z))); elseif (z <= -5.6e-167) tmp = Float64(x - Float64(x * Float64(y / a))); elseif (z <= 4.7e+14) tmp = Float64(x + Float64(y * Float64(t / a))); else tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.7e-10) tmp = t + (y * (x / z)); elseif (z <= -5.6e-167) tmp = x - (x * (y / a)); elseif (z <= 4.7e+14) tmp = x + (y * (t / a)); else tmp = t * ((y - z) / (a - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.7e-10], N[(t + N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -5.6e-167], N[(x - N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.7e+14], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.7 \cdot 10^{-10}:\\
\;\;\;\;t + y \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq -5.6 \cdot 10^{-167}:\\
\;\;\;\;x - x \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 4.7 \cdot 10^{+14}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if z < -2.7e-10Initial program 47.5%
associate-/l*69.9%
Simplified69.9%
Taylor expanded in z around inf 53.0%
associate--l+53.0%
associate-*r/53.0%
associate-*r/53.0%
mul-1-neg53.0%
div-sub53.0%
mul-1-neg53.0%
distribute-lft-out--53.0%
associate-*r/53.0%
mul-1-neg53.0%
unsub-neg53.0%
distribute-rgt-out--53.4%
Simplified53.4%
Taylor expanded in t around 0 56.1%
mul-1-neg56.1%
associate-/l*63.1%
distribute-rgt-neg-in63.1%
distribute-neg-frac263.1%
Simplified63.1%
Taylor expanded in y around inf 53.0%
associate-*r/53.0%
*-commutative53.0%
neg-mul-153.0%
distribute-rgt-neg-in53.0%
associate-*r/57.8%
Simplified57.8%
if -2.7e-10 < z < -5.59999999999999971e-167Initial program 91.0%
associate-/l*91.2%
Simplified91.2%
Taylor expanded in t around 0 74.8%
associate-*r/74.8%
mul-1-neg74.8%
distribute-lft-neg-out74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in z around 0 58.4%
mul-1-neg58.4%
unsub-neg58.4%
associate-/l*61.5%
Simplified61.5%
if -5.59999999999999971e-167 < z < 4.7e14Initial program 91.6%
associate-/l*90.6%
Simplified90.6%
clear-num90.5%
un-div-inv90.5%
Applied egg-rr90.5%
Taylor expanded in t around inf 76.4%
Taylor expanded in z around 0 69.3%
*-commutative69.3%
associate-/l*70.2%
Simplified70.2%
if 4.7e14 < z Initial program 44.4%
associate-/l*67.3%
Simplified67.3%
Taylor expanded in x around 0 38.9%
associate-/l*62.7%
Simplified62.7%
Final simplification64.0%
(FPCore (x y z t a)
:precision binary64
(if (<= z -4.6e+197)
(+ t (* x (/ (- y a) z)))
(if (<= z 8.5e+213)
(+ x (* (- y z) (/ (- x t) (- z a))))
(+ t (* x (* (- y a) (/ 1.0 z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.6e+197) {
tmp = t + (x * ((y - a) / z));
} else if (z <= 8.5e+213) {
tmp = x + ((y - z) * ((x - t) / (z - a)));
} else {
tmp = t + (x * ((y - a) * (1.0 / 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 <= (-4.6d+197)) then
tmp = t + (x * ((y - a) / z))
else if (z <= 8.5d+213) then
tmp = x + ((y - z) * ((x - t) / (z - a)))
else
tmp = t + (x * ((y - a) * (1.0d0 / 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 <= -4.6e+197) {
tmp = t + (x * ((y - a) / z));
} else if (z <= 8.5e+213) {
tmp = x + ((y - z) * ((x - t) / (z - a)));
} else {
tmp = t + (x * ((y - a) * (1.0 / z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4.6e+197: tmp = t + (x * ((y - a) / z)) elif z <= 8.5e+213: tmp = x + ((y - z) * ((x - t) / (z - a))) else: tmp = t + (x * ((y - a) * (1.0 / z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.6e+197) tmp = Float64(t + Float64(x * Float64(Float64(y - a) / z))); elseif (z <= 8.5e+213) tmp = Float64(x + Float64(Float64(y - z) * Float64(Float64(x - t) / Float64(z - a)))); else tmp = Float64(t + Float64(x * Float64(Float64(y - a) * Float64(1.0 / z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4.6e+197) tmp = t + (x * ((y - a) / z)); elseif (z <= 8.5e+213) tmp = x + ((y - z) * ((x - t) / (z - a))); else tmp = t + (x * ((y - a) * (1.0 / z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.6e+197], N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.5e+213], N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(x - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x * N[(N[(y - a), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.6 \cdot 10^{+197}:\\
\;\;\;\;t + x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 8.5 \cdot 10^{+213}:\\
\;\;\;\;x + \left(y - z\right) \cdot \frac{x - t}{z - a}\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \left(\left(y - a\right) \cdot \frac{1}{z}\right)\\
\end{array}
\end{array}
if z < -4.6000000000000001e197Initial program 23.2%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in z around inf 66.0%
associate--l+66.0%
associate-*r/66.0%
associate-*r/66.0%
mul-1-neg66.0%
div-sub66.0%
mul-1-neg66.0%
distribute-lft-out--66.0%
associate-*r/66.0%
mul-1-neg66.0%
unsub-neg66.0%
distribute-rgt-out--66.2%
Simplified66.2%
Taylor expanded in t around 0 72.2%
mul-1-neg72.2%
associate-/l*90.5%
distribute-rgt-neg-in90.5%
distribute-neg-frac290.5%
Simplified90.5%
if -4.6000000000000001e197 < z < 8.4999999999999995e213Initial program 78.8%
associate-/l*85.9%
Simplified85.9%
if 8.4999999999999995e213 < z Initial program 16.3%
associate-/l*53.7%
Simplified53.7%
Taylor expanded in z around inf 55.9%
associate--l+55.9%
associate-*r/55.9%
associate-*r/55.9%
mul-1-neg55.9%
div-sub55.9%
mul-1-neg55.9%
distribute-lft-out--55.9%
associate-*r/55.9%
mul-1-neg55.9%
unsub-neg55.9%
distribute-rgt-out--56.1%
Simplified56.1%
Taylor expanded in t around 0 68.4%
mul-1-neg68.4%
associate-/l*88.0%
distribute-rgt-neg-in88.0%
distribute-neg-frac288.0%
Simplified88.0%
frac-2neg88.0%
div-inv88.2%
remove-double-neg88.2%
Applied egg-rr88.2%
Final simplification86.5%
(FPCore (x y z t a)
:precision binary64
(if (<= z -9.5e-12)
(+ t (* y (/ x z)))
(if (<= z -2.8e-163)
(- x (* x (/ y a)))
(if (<= z 3.3e+98) (+ x (* y (/ t a))) (- t (* x (/ a z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9.5e-12) {
tmp = t + (y * (x / z));
} else if (z <= -2.8e-163) {
tmp = x - (x * (y / a));
} else if (z <= 3.3e+98) {
tmp = x + (y * (t / a));
} else {
tmp = t - (x * (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 <= (-9.5d-12)) then
tmp = t + (y * (x / z))
else if (z <= (-2.8d-163)) then
tmp = x - (x * (y / a))
else if (z <= 3.3d+98) then
tmp = x + (y * (t / a))
else
tmp = t - (x * (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 <= -9.5e-12) {
tmp = t + (y * (x / z));
} else if (z <= -2.8e-163) {
tmp = x - (x * (y / a));
} else if (z <= 3.3e+98) {
tmp = x + (y * (t / a));
} else {
tmp = t - (x * (a / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -9.5e-12: tmp = t + (y * (x / z)) elif z <= -2.8e-163: tmp = x - (x * (y / a)) elif z <= 3.3e+98: tmp = x + (y * (t / a)) else: tmp = t - (x * (a / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9.5e-12) tmp = Float64(t + Float64(y * Float64(x / z))); elseif (z <= -2.8e-163) tmp = Float64(x - Float64(x * Float64(y / a))); elseif (z <= 3.3e+98) tmp = Float64(x + Float64(y * Float64(t / a))); else tmp = Float64(t - Float64(x * Float64(a / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -9.5e-12) tmp = t + (y * (x / z)); elseif (z <= -2.8e-163) tmp = x - (x * (y / a)); elseif (z <= 3.3e+98) tmp = x + (y * (t / a)); else tmp = t - (x * (a / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9.5e-12], N[(t + N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.8e-163], N[(x - N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.3e+98], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9.5 \cdot 10^{-12}:\\
\;\;\;\;t + y \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq -2.8 \cdot 10^{-163}:\\
\;\;\;\;x - x \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 3.3 \cdot 10^{+98}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\end{array}
\end{array}
if z < -9.4999999999999995e-12Initial program 47.5%
associate-/l*69.9%
Simplified69.9%
Taylor expanded in z around inf 53.0%
associate--l+53.0%
associate-*r/53.0%
associate-*r/53.0%
mul-1-neg53.0%
div-sub53.0%
mul-1-neg53.0%
distribute-lft-out--53.0%
associate-*r/53.0%
mul-1-neg53.0%
unsub-neg53.0%
distribute-rgt-out--53.4%
Simplified53.4%
Taylor expanded in t around 0 56.1%
mul-1-neg56.1%
associate-/l*63.1%
distribute-rgt-neg-in63.1%
distribute-neg-frac263.1%
Simplified63.1%
Taylor expanded in y around inf 53.0%
associate-*r/53.0%
*-commutative53.0%
neg-mul-153.0%
distribute-rgt-neg-in53.0%
associate-*r/57.8%
Simplified57.8%
if -9.4999999999999995e-12 < z < -2.8e-163Initial program 91.0%
associate-/l*91.2%
Simplified91.2%
Taylor expanded in t around 0 74.8%
associate-*r/74.8%
mul-1-neg74.8%
distribute-lft-neg-out74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in z around 0 58.4%
mul-1-neg58.4%
unsub-neg58.4%
associate-/l*61.5%
Simplified61.5%
if -2.8e-163 < z < 3.30000000000000028e98Initial program 87.9%
associate-/l*88.7%
Simplified88.7%
clear-num88.6%
un-div-inv88.7%
Applied egg-rr88.7%
Taylor expanded in t around inf 74.9%
Taylor expanded in z around 0 63.5%
*-commutative63.5%
associate-/l*65.1%
Simplified65.1%
if 3.30000000000000028e98 < z Initial program 28.2%
associate-/l*59.3%
Simplified59.3%
Taylor expanded in z around inf 59.0%
associate--l+59.0%
associate-*r/59.0%
associate-*r/59.0%
mul-1-neg59.0%
div-sub59.0%
mul-1-neg59.0%
distribute-lft-out--59.0%
associate-*r/59.0%
mul-1-neg59.0%
unsub-neg59.0%
distribute-rgt-out--59.1%
Simplified59.1%
Taylor expanded in t around 0 65.2%
mul-1-neg65.2%
associate-/l*79.5%
distribute-rgt-neg-in79.5%
distribute-neg-frac279.5%
Simplified79.5%
Taylor expanded in y around 0 67.6%
Final simplification63.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -9e+119)
(- t (* t (/ y z)))
(if (<= z -1.75e-171)
(- x (* x (/ y a)))
(if (<= z 2.15e+95) (+ x (* y (/ t a))) (- t (* x (/ a z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9e+119) {
tmp = t - (t * (y / z));
} else if (z <= -1.75e-171) {
tmp = x - (x * (y / a));
} else if (z <= 2.15e+95) {
tmp = x + (y * (t / a));
} else {
tmp = t - (x * (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 <= (-9d+119)) then
tmp = t - (t * (y / z))
else if (z <= (-1.75d-171)) then
tmp = x - (x * (y / a))
else if (z <= 2.15d+95) then
tmp = x + (y * (t / a))
else
tmp = t - (x * (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 <= -9e+119) {
tmp = t - (t * (y / z));
} else if (z <= -1.75e-171) {
tmp = x - (x * (y / a));
} else if (z <= 2.15e+95) {
tmp = x + (y * (t / a));
} else {
tmp = t - (x * (a / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -9e+119: tmp = t - (t * (y / z)) elif z <= -1.75e-171: tmp = x - (x * (y / a)) elif z <= 2.15e+95: tmp = x + (y * (t / a)) else: tmp = t - (x * (a / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9e+119) tmp = Float64(t - Float64(t * Float64(y / z))); elseif (z <= -1.75e-171) tmp = Float64(x - Float64(x * Float64(y / a))); elseif (z <= 2.15e+95) tmp = Float64(x + Float64(y * Float64(t / a))); else tmp = Float64(t - Float64(x * Float64(a / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -9e+119) tmp = t - (t * (y / z)); elseif (z <= -1.75e-171) tmp = x - (x * (y / a)); elseif (z <= 2.15e+95) tmp = x + (y * (t / a)); else tmp = t - (x * (a / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9e+119], N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.75e-171], N[(x - N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.15e+95], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9 \cdot 10^{+119}:\\
\;\;\;\;t - t \cdot \frac{y}{z}\\
\mathbf{elif}\;z \leq -1.75 \cdot 10^{-171}:\\
\;\;\;\;x - x \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 2.15 \cdot 10^{+95}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\end{array}
\end{array}
if z < -9.00000000000000039e119Initial program 27.3%
associate-/l*56.6%
Simplified56.6%
Taylor expanded in x around 0 33.8%
Taylor expanded in a around 0 30.8%
associate-*r/30.8%
associate-*r*30.8%
neg-mul-130.8%
*-commutative30.8%
Simplified30.8%
Taylor expanded in y around 0 49.0%
mul-1-neg49.0%
unsub-neg49.0%
associate-/l*63.7%
Simplified63.7%
if -9.00000000000000039e119 < z < -1.74999999999999997e-171Initial program 78.9%
associate-/l*87.0%
Simplified87.0%
Taylor expanded in t around 0 58.2%
associate-*r/58.2%
mul-1-neg58.2%
distribute-lft-neg-out58.2%
*-commutative58.2%
Simplified58.2%
Taylor expanded in z around 0 43.0%
mul-1-neg43.0%
unsub-neg43.0%
associate-/l*46.1%
Simplified46.1%
if -1.74999999999999997e-171 < z < 2.15e95Initial program 87.9%
associate-/l*88.7%
Simplified88.7%
clear-num88.6%
un-div-inv88.7%
Applied egg-rr88.7%
Taylor expanded in t around inf 74.9%
Taylor expanded in z around 0 63.5%
*-commutative63.5%
associate-/l*65.1%
Simplified65.1%
if 2.15e95 < z Initial program 28.2%
associate-/l*59.3%
Simplified59.3%
Taylor expanded in z around inf 59.0%
associate--l+59.0%
associate-*r/59.0%
associate-*r/59.0%
mul-1-neg59.0%
div-sub59.0%
mul-1-neg59.0%
distribute-lft-out--59.0%
associate-*r/59.0%
mul-1-neg59.0%
unsub-neg59.0%
distribute-rgt-out--59.1%
Simplified59.1%
Taylor expanded in t around 0 65.2%
mul-1-neg65.2%
associate-/l*79.5%
distribute-rgt-neg-in79.5%
distribute-neg-frac279.5%
Simplified79.5%
Taylor expanded in y around 0 67.6%
(FPCore (x y z t a) :precision binary64 (if (<= y -8e+89) (* t (/ y (- a z))) (if (<= y 6.5e-300) x (if (<= y 4.5e-41) t (* t (/ (- y z) a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -8e+89) {
tmp = t * (y / (a - z));
} else if (y <= 6.5e-300) {
tmp = x;
} else if (y <= 4.5e-41) {
tmp = t;
} else {
tmp = t * ((y - z) / 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) :: tmp
if (y <= (-8d+89)) then
tmp = t * (y / (a - z))
else if (y <= 6.5d-300) then
tmp = x
else if (y <= 4.5d-41) then
tmp = t
else
tmp = t * ((y - z) / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -8e+89) {
tmp = t * (y / (a - z));
} else if (y <= 6.5e-300) {
tmp = x;
} else if (y <= 4.5e-41) {
tmp = t;
} else {
tmp = t * ((y - z) / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -8e+89: tmp = t * (y / (a - z)) elif y <= 6.5e-300: tmp = x elif y <= 4.5e-41: tmp = t else: tmp = t * ((y - z) / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -8e+89) tmp = Float64(t * Float64(y / Float64(a - z))); elseif (y <= 6.5e-300) tmp = x; elseif (y <= 4.5e-41) tmp = t; else tmp = Float64(t * Float64(Float64(y - z) / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -8e+89) tmp = t * (y / (a - z)); elseif (y <= 6.5e-300) tmp = x; elseif (y <= 4.5e-41) tmp = t; else tmp = t * ((y - z) / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -8e+89], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.5e-300], x, If[LessEqual[y, 4.5e-41], t, N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8 \cdot 10^{+89}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;y \leq 6.5 \cdot 10^{-300}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-41}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y - z}{a}\\
\end{array}
\end{array}
if y < -7.99999999999999996e89Initial program 67.4%
associate-/l*83.7%
Simplified83.7%
Taylor expanded in x around 0 44.7%
Taylor expanded in y around inf 35.3%
associate-/l*44.4%
Simplified44.4%
if -7.99999999999999996e89 < y < 6.4999999999999997e-300Initial program 77.7%
associate-/l*84.7%
Simplified84.7%
Taylor expanded in a around inf 44.3%
if 6.4999999999999997e-300 < y < 4.5e-41Initial program 49.7%
associate-/l*62.3%
Simplified62.3%
Taylor expanded in z around inf 39.7%
if 4.5e-41 < y Initial program 68.2%
associate-/l*81.1%
Simplified81.1%
Taylor expanded in x around 0 35.4%
Taylor expanded in a around inf 28.6%
associate-/l*35.6%
Simplified35.6%
(FPCore (x y z t a)
:precision binary64
(if (<= z -7.6e+123)
t
(if (<= z -1.45e-125)
x
(if (<= z -9.6e-297) (* t (/ y a)) (if (<= z 4e+89) x t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.6e+123) {
tmp = t;
} else if (z <= -1.45e-125) {
tmp = x;
} else if (z <= -9.6e-297) {
tmp = t * (y / a);
} else if (z <= 4e+89) {
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 <= (-7.6d+123)) then
tmp = t
else if (z <= (-1.45d-125)) then
tmp = x
else if (z <= (-9.6d-297)) then
tmp = t * (y / a)
else if (z <= 4d+89) 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 <= -7.6e+123) {
tmp = t;
} else if (z <= -1.45e-125) {
tmp = x;
} else if (z <= -9.6e-297) {
tmp = t * (y / a);
} else if (z <= 4e+89) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -7.6e+123: tmp = t elif z <= -1.45e-125: tmp = x elif z <= -9.6e-297: tmp = t * (y / a) elif z <= 4e+89: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -7.6e+123) tmp = t; elseif (z <= -1.45e-125) tmp = x; elseif (z <= -9.6e-297) tmp = Float64(t * Float64(y / a)); elseif (z <= 4e+89) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -7.6e+123) tmp = t; elseif (z <= -1.45e-125) tmp = x; elseif (z <= -9.6e-297) tmp = t * (y / a); elseif (z <= 4e+89) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -7.6e+123], t, If[LessEqual[z, -1.45e-125], x, If[LessEqual[z, -9.6e-297], N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e+89], x, t]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.6 \cdot 10^{+123}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.45 \cdot 10^{-125}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -9.6 \cdot 10^{-297}:\\
\;\;\;\;t \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+89}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -7.59999999999999989e123 or 3.99999999999999998e89 < z Initial program 28.5%
associate-/l*58.4%
Simplified58.4%
Taylor expanded in z around inf 52.1%
if -7.59999999999999989e123 < z < -1.4500000000000001e-125 or -9.5999999999999998e-297 < z < 3.99999999999999998e89Initial program 82.8%
associate-/l*85.9%
Simplified85.9%
Taylor expanded in a around inf 36.8%
if -1.4500000000000001e-125 < z < -9.5999999999999998e-297Initial program 91.9%
associate-/l*97.1%
Simplified97.1%
Taylor expanded in x around 0 47.3%
Taylor expanded in z around 0 44.7%
associate-/l*50.8%
Simplified50.8%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -9.4e+38) (not (<= z 2.7e+95))) (+ t (* x (/ (- y a) z))) (+ x (* (- x t) (/ (- z y) a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -9.4e+38) || !(z <= 2.7e+95)) {
tmp = t + (x * ((y - a) / z));
} else {
tmp = x + ((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) :: tmp
if ((z <= (-9.4d+38)) .or. (.not. (z <= 2.7d+95))) then
tmp = t + (x * ((y - a) / z))
else
tmp = x + ((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 tmp;
if ((z <= -9.4e+38) || !(z <= 2.7e+95)) {
tmp = t + (x * ((y - a) / z));
} else {
tmp = x + ((x - t) * ((z - y) / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -9.4e+38) or not (z <= 2.7e+95): tmp = t + (x * ((y - a) / z)) else: tmp = x + ((x - t) * ((z - y) / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -9.4e+38) || !(z <= 2.7e+95)) tmp = Float64(t + Float64(x * Float64(Float64(y - a) / z))); else tmp = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -9.4e+38) || ~((z <= 2.7e+95))) tmp = t + (x * ((y - a) / z)); else tmp = x + ((x - t) * ((z - y) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -9.4e+38], N[Not[LessEqual[z, 2.7e+95]], $MachinePrecision]], N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9.4 \cdot 10^{+38} \lor \neg \left(z \leq 2.7 \cdot 10^{+95}\right):\\
\;\;\;\;t + x \cdot \frac{y - a}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(x - t\right) \cdot \frac{z - y}{a}\\
\end{array}
\end{array}
if z < -9.3999999999999998e38 or 2.7e95 < z Initial program 32.9%
associate-/l*61.4%
Simplified61.4%
Taylor expanded in z around inf 56.1%
associate--l+56.1%
associate-*r/56.1%
associate-*r/56.1%
mul-1-neg56.1%
div-sub56.1%
mul-1-neg56.1%
distribute-lft-out--56.1%
associate-*r/56.1%
mul-1-neg56.1%
unsub-neg56.1%
distribute-rgt-out--56.4%
Simplified56.4%
Taylor expanded in t around 0 62.3%
mul-1-neg62.3%
associate-/l*73.4%
distribute-rgt-neg-in73.4%
distribute-neg-frac273.4%
Simplified73.4%
if -9.3999999999999998e38 < z < 2.7e95Initial program 88.9%
associate-/l*90.0%
Simplified90.0%
Taylor expanded in a around inf 72.9%
associate-/l*75.9%
Simplified75.9%
Final simplification75.0%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -1.15e-9) (not (<= z 1.12e+95))) (+ t (* x (/ (- y a) z))) (- x (* y (/ (- x t) a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.15e-9) || !(z <= 1.12e+95)) {
tmp = t + (x * ((y - a) / z));
} else {
tmp = x - (y * ((x - t) / 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) :: tmp
if ((z <= (-1.15d-9)) .or. (.not. (z <= 1.12d+95))) then
tmp = t + (x * ((y - a) / z))
else
tmp = x - (y * ((x - t) / a))
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.15e-9) || !(z <= 1.12e+95)) {
tmp = t + (x * ((y - a) / z));
} else {
tmp = x - (y * ((x - t) / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -1.15e-9) or not (z <= 1.12e+95): tmp = t + (x * ((y - a) / z)) else: tmp = x - (y * ((x - t) / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -1.15e-9) || !(z <= 1.12e+95)) tmp = Float64(t + Float64(x * Float64(Float64(y - a) / z))); else tmp = Float64(x - Float64(y * Float64(Float64(x - t) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -1.15e-9) || ~((z <= 1.12e+95))) tmp = t + (x * ((y - a) / z)); else tmp = x - (y * ((x - t) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.15e-9], N[Not[LessEqual[z, 1.12e+95]], $MachinePrecision]], N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y * N[(N[(x - t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.15 \cdot 10^{-9} \lor \neg \left(z \leq 1.12 \cdot 10^{+95}\right):\\
\;\;\;\;t + x \cdot \frac{y - a}{z}\\
\mathbf{else}:\\
\;\;\;\;x - y \cdot \frac{x - t}{a}\\
\end{array}
\end{array}
if z < -1.15e-9 or 1.11999999999999999e95 < z Initial program 40.3%
associate-/l*66.0%
Simplified66.0%
Taylor expanded in z around inf 55.2%
associate--l+55.2%
associate-*r/55.2%
associate-*r/55.2%
mul-1-neg55.2%
div-sub55.2%
mul-1-neg55.2%
distribute-lft-out--55.2%
associate-*r/55.2%
mul-1-neg55.2%
unsub-neg55.2%
distribute-rgt-out--55.6%
Simplified55.6%
Taylor expanded in t around 0 59.5%
mul-1-neg59.5%
associate-/l*69.2%
distribute-rgt-neg-in69.2%
distribute-neg-frac269.2%
Simplified69.2%
if -1.15e-9 < z < 1.11999999999999999e95Initial program 88.6%
associate-/l*89.3%
Simplified89.3%
add-cube-cbrt88.5%
fma-define88.5%
pow288.5%
*-commutative88.5%
associate-*l/87.8%
associate-*r/89.9%
Applied egg-rr89.9%
Taylor expanded in z around 0 70.2%
associate-/l*71.5%
Simplified71.5%
Final simplification70.6%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -2.5e+132) (not (<= z 8.2e+89))) (- t (* t (/ y z))) (+ x (* y (/ t a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.5e+132) || !(z <= 8.2e+89)) {
tmp = t - (t * (y / z));
} else {
tmp = x + (y * (t / 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) :: tmp
if ((z <= (-2.5d+132)) .or. (.not. (z <= 8.2d+89))) then
tmp = t - (t * (y / z))
else
tmp = x + (y * (t / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -2.5e+132) || !(z <= 8.2e+89)) {
tmp = t - (t * (y / z));
} else {
tmp = x + (y * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -2.5e+132) or not (z <= 8.2e+89): tmp = t - (t * (y / z)) else: tmp = x + (y * (t / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -2.5e+132) || !(z <= 8.2e+89)) tmp = Float64(t - Float64(t * Float64(y / z))); else tmp = Float64(x + Float64(y * Float64(t / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -2.5e+132) || ~((z <= 8.2e+89))) tmp = t - (t * (y / z)); else tmp = x + (y * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -2.5e+132], N[Not[LessEqual[z, 8.2e+89]], $MachinePrecision]], N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.5 \cdot 10^{+132} \lor \neg \left(z \leq 8.2 \cdot 10^{+89}\right):\\
\;\;\;\;t - t \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\end{array}
\end{array}
if z < -2.5000000000000001e132 or 8.1999999999999997e89 < z Initial program 28.5%
associate-/l*58.4%
Simplified58.4%
Taylor expanded in x around 0 33.3%
Taylor expanded in a around 0 30.6%
associate-*r/30.6%
associate-*r*30.6%
neg-mul-130.6%
*-commutative30.6%
Simplified30.6%
Taylor expanded in y around 0 47.6%
mul-1-neg47.6%
unsub-neg47.6%
associate-/l*59.4%
Simplified59.4%
if -2.5000000000000001e132 < z < 8.1999999999999997e89Initial program 84.6%
associate-/l*88.1%
Simplified88.1%
clear-num87.6%
un-div-inv87.7%
Applied egg-rr87.7%
Taylor expanded in t around inf 67.3%
Taylor expanded in z around 0 53.3%
*-commutative53.3%
associate-/l*55.3%
Simplified55.3%
Final simplification56.4%
(FPCore (x y z t a) :precision binary64 (if (<= z -7e+121) (- t (* t (/ y z))) (if (<= z 5.1e+95) (+ x (* y (/ t a))) (- t (* x (/ a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7e+121) {
tmp = t - (t * (y / z));
} else if (z <= 5.1e+95) {
tmp = x + (y * (t / a));
} else {
tmp = t - (x * (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 <= (-7d+121)) then
tmp = t - (t * (y / z))
else if (z <= 5.1d+95) then
tmp = x + (y * (t / a))
else
tmp = t - (x * (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 <= -7e+121) {
tmp = t - (t * (y / z));
} else if (z <= 5.1e+95) {
tmp = x + (y * (t / a));
} else {
tmp = t - (x * (a / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -7e+121: tmp = t - (t * (y / z)) elif z <= 5.1e+95: tmp = x + (y * (t / a)) else: tmp = t - (x * (a / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -7e+121) tmp = Float64(t - Float64(t * Float64(y / z))); elseif (z <= 5.1e+95) tmp = Float64(x + Float64(y * Float64(t / a))); else tmp = Float64(t - Float64(x * Float64(a / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -7e+121) tmp = t - (t * (y / z)); elseif (z <= 5.1e+95) tmp = x + (y * (t / a)); else tmp = t - (x * (a / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -7e+121], N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.1e+95], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t - N[(x * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7 \cdot 10^{+121}:\\
\;\;\;\;t - t \cdot \frac{y}{z}\\
\mathbf{elif}\;z \leq 5.1 \cdot 10^{+95}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t - x \cdot \frac{a}{z}\\
\end{array}
\end{array}
if z < -6.9999999999999999e121Initial program 27.5%
associate-/l*57.7%
Simplified57.7%
Taylor expanded in x around 0 34.8%
Taylor expanded in a around 0 31.6%
associate-*r/31.6%
associate-*r*31.6%
neg-mul-131.6%
*-commutative31.6%
Simplified31.6%
Taylor expanded in y around 0 50.4%
mul-1-neg50.4%
unsub-neg50.4%
associate-/l*65.6%
Simplified65.6%
if -6.9999999999999999e121 < z < 5.10000000000000003e95Initial program 84.2%
associate-/l*87.7%
Simplified87.7%
clear-num87.2%
un-div-inv87.3%
Applied egg-rr87.3%
Taylor expanded in t around inf 67.1%
Taylor expanded in z around 0 53.3%
*-commutative53.3%
associate-/l*55.2%
Simplified55.2%
if 5.10000000000000003e95 < z Initial program 28.2%
associate-/l*59.3%
Simplified59.3%
Taylor expanded in z around inf 59.0%
associate--l+59.0%
associate-*r/59.0%
associate-*r/59.0%
mul-1-neg59.0%
div-sub59.0%
mul-1-neg59.0%
distribute-lft-out--59.0%
associate-*r/59.0%
mul-1-neg59.0%
unsub-neg59.0%
distribute-rgt-out--59.1%
Simplified59.1%
Taylor expanded in t around 0 65.2%
mul-1-neg65.2%
associate-/l*79.5%
distribute-rgt-neg-in79.5%
distribute-neg-frac279.5%
Simplified79.5%
Taylor expanded in y around 0 67.6%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.4e+129) t (if (<= z 6.5e+96) (+ x (* y (/ t a))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.4e+129) {
tmp = t;
} else if (z <= 6.5e+96) {
tmp = x + (y * (t / 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 <= (-2.4d+129)) then
tmp = t
else if (z <= 6.5d+96) then
tmp = x + (y * (t / 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 <= -2.4e+129) {
tmp = t;
} else if (z <= 6.5e+96) {
tmp = x + (y * (t / a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.4e+129: tmp = t elif z <= 6.5e+96: tmp = x + (y * (t / a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.4e+129) tmp = t; elseif (z <= 6.5e+96) tmp = Float64(x + Float64(y * Float64(t / a))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.4e+129) tmp = t; elseif (z <= 6.5e+96) tmp = x + (y * (t / a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.4e+129], t, If[LessEqual[z, 6.5e+96], N[(x + N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.4 \cdot 10^{+129}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+96}:\\
\;\;\;\;x + y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.3999999999999999e129 or 6.5e96 < z Initial program 27.9%
associate-/l*58.6%
Simplified58.6%
Taylor expanded in z around inf 53.5%
if -2.3999999999999999e129 < z < 6.5e96Initial program 84.2%
associate-/l*87.7%
Simplified87.7%
clear-num87.2%
un-div-inv87.3%
Applied egg-rr87.3%
Taylor expanded in t around inf 67.1%
Taylor expanded in z around 0 53.3%
*-commutative53.3%
associate-/l*55.2%
Simplified55.2%
(FPCore (x y z t a) :precision binary64 (if (<= z -8.2e+123) t (if (<= z 1.06e+89) x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.2e+123) {
tmp = t;
} else if (z <= 1.06e+89) {
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+123)) then
tmp = t
else if (z <= 1.06d+89) 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+123) {
tmp = t;
} else if (z <= 1.06e+89) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -8.2e+123: tmp = t elif z <= 1.06e+89: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8.2e+123) tmp = t; elseif (z <= 1.06e+89) 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+123) tmp = t; elseif (z <= 1.06e+89) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8.2e+123], t, If[LessEqual[z, 1.06e+89], x, t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.2 \cdot 10^{+123}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.06 \cdot 10^{+89}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.19999999999999979e123 or 1.05999999999999997e89 < z Initial program 28.5%
associate-/l*58.4%
Simplified58.4%
Taylor expanded in z around inf 52.1%
if -8.19999999999999979e123 < z < 1.05999999999999997e89Initial program 84.6%
associate-/l*88.1%
Simplified88.1%
Taylor expanded in a around inf 34.9%
(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 68.4%
associate-/l*79.5%
Simplified79.5%
Taylor expanded in z around inf 21.6%
(FPCore (x y z t a) :precision binary64 0.0)
double code(double x, double y, double z, double t, double a) {
return 0.0;
}
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 = 0.0d0
end function
public static double code(double x, double y, double z, double t, double a) {
return 0.0;
}
def code(x, y, z, t, a): return 0.0
function code(x, y, z, t, a) return 0.0 end
function tmp = code(x, y, z, t, a) tmp = 0.0; end
code[x_, y_, z_, t_, a_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 68.4%
associate-/l*79.5%
Simplified79.5%
Taylor expanded in t around 0 40.5%
associate-*r/40.5%
mul-1-neg40.5%
distribute-lft-neg-out40.5%
*-commutative40.5%
Simplified40.5%
Taylor expanded in z around inf 2.8%
distribute-rgt1-in2.8%
metadata-eval2.8%
mul0-lft2.8%
Simplified2.8%
(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 2024101
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:invLinMap from Chart-1.5.3"
:precision binary64
:alt
(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))))