
(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 23 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 -1e-296)
(+ x (* (- x t) (/ (- z y) (- a z))))
(if (<= t_1 0.0)
(+ t (/ x (/ z (- y a))))
(fma (/ (- y z) (- a z)) (- t x) x)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if (t_1 <= -1e-296) {
tmp = x + ((x - t) * ((z - y) / (a - z)));
} else if (t_1 <= 0.0) {
tmp = t + (x / (z / (y - a)));
} else {
tmp = fma(((y - z) / (a - z)), (t - x), x);
}
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 <= -1e-296) tmp = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / Float64(a - z)))); elseif (t_1 <= 0.0) tmp = Float64(t + Float64(x / Float64(z / Float64(y - a)))); else tmp = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x); 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[LessEqual[t$95$1, -1e-296], N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(t + N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $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 -1 \cdot 10^{-296}:\\
\;\;\;\;x + \left(x - t\right) \cdot \frac{z - y}{a - z}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;t + \frac{x}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -1e-296Initial program 72.2%
associate-*l/93.2%
Simplified93.2%
if -1e-296 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
associate-*l/3.9%
Simplified3.9%
Taylor expanded in z around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
associate-*r/99.8%
div-sub99.8%
distribute-lft-out--99.8%
associate-*r/99.8%
distribute-rgt-out--99.8%
mul-1-neg99.8%
unsub-neg99.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in t around 0 99.8%
mul-1-neg99.8%
associate-/l*99.8%
distribute-neg-frac99.8%
Simplified99.8%
if 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 76.0%
+-commutative76.0%
associate-*l/85.5%
fma-def85.6%
Simplified85.6%
Final simplification90.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -1e-296) (not (<= t_1 0.0)))
(+ x (* (- x t) (/ (- z y) (- a z))))
(+ t (/ x (/ z (- y a)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -1e-296) || !(t_1 <= 0.0)) {
tmp = x + ((x - t) * ((z - y) / (a - z)));
} else {
tmp = t + (x / (z / (y - a)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (((y - z) * (t - x)) / (a - z))
if ((t_1 <= (-1d-296)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x + ((x - t) * ((z - y) / (a - z)))
else
tmp = t + (x / (z / (y - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -1e-296) || !(t_1 <= 0.0)) {
tmp = x + ((x - t) * ((z - y) / (a - z)));
} else {
tmp = t + (x / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - z) * (t - x)) / (a - z)) tmp = 0 if (t_1 <= -1e-296) or not (t_1 <= 0.0): tmp = x + ((x - t) * ((z - y) / (a - z))) else: tmp = t + (x / (z / (y - a))) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -1e-296) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(x - t) * Float64(Float64(z - y) / Float64(a - z)))); else tmp = Float64(t + Float64(x / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((y - z) * (t - x)) / (a - z)); tmp = 0.0; if ((t_1 <= -1e-296) || ~((t_1 <= 0.0))) tmp = x + ((x - t) * ((z - y) / (a - z))); else tmp = t + (x / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -1e-296], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(x - t), $MachinePrecision] * N[(N[(z - y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{-296} \lor \neg \left(t\_1 \leq 0\right):\\
\;\;\;\;x + \left(x - t\right) \cdot \frac{z - y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -1e-296 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 74.2%
associate-*l/89.2%
Simplified89.2%
if -1e-296 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 3.9%
associate-*l/3.9%
Simplified3.9%
Taylor expanded in z around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
associate-*r/99.8%
div-sub99.8%
distribute-lft-out--99.8%
associate-*r/99.8%
distribute-rgt-out--99.8%
mul-1-neg99.8%
unsub-neg99.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in t around 0 99.8%
mul-1-neg99.8%
associate-/l*99.8%
distribute-neg-frac99.8%
Simplified99.8%
Final simplification90.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (- 1.0 (/ y a)))) (t_2 (+ x (* t (/ y a)))))
(if (<= z -3e+14)
t
(if (<= z -1.1e-23)
t_2
(if (<= z -9.6e-80)
(+ x t)
(if (<= z -2.4e-143)
t_1
(if (<= z -3.9e-238)
t_2
(if (<= z 5e-305) t_1 (if (<= z 3.2e+80) t_2 t)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (1.0 - (y / a));
double t_2 = x + (t * (y / a));
double tmp;
if (z <= -3e+14) {
tmp = t;
} else if (z <= -1.1e-23) {
tmp = t_2;
} else if (z <= -9.6e-80) {
tmp = x + t;
} else if (z <= -2.4e-143) {
tmp = t_1;
} else if (z <= -3.9e-238) {
tmp = t_2;
} else if (z <= 5e-305) {
tmp = t_1;
} else if (z <= 3.2e+80) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = x * (1.0d0 - (y / a))
t_2 = x + (t * (y / a))
if (z <= (-3d+14)) then
tmp = t
else if (z <= (-1.1d-23)) then
tmp = t_2
else if (z <= (-9.6d-80)) then
tmp = x + t
else if (z <= (-2.4d-143)) then
tmp = t_1
else if (z <= (-3.9d-238)) then
tmp = t_2
else if (z <= 5d-305) then
tmp = t_1
else if (z <= 3.2d+80) then
tmp = t_2
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (1.0 - (y / a));
double t_2 = x + (t * (y / a));
double tmp;
if (z <= -3e+14) {
tmp = t;
} else if (z <= -1.1e-23) {
tmp = t_2;
} else if (z <= -9.6e-80) {
tmp = x + t;
} else if (z <= -2.4e-143) {
tmp = t_1;
} else if (z <= -3.9e-238) {
tmp = t_2;
} else if (z <= 5e-305) {
tmp = t_1;
} else if (z <= 3.2e+80) {
tmp = t_2;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (1.0 - (y / a)) t_2 = x + (t * (y / a)) tmp = 0 if z <= -3e+14: tmp = t elif z <= -1.1e-23: tmp = t_2 elif z <= -9.6e-80: tmp = x + t elif z <= -2.4e-143: tmp = t_1 elif z <= -3.9e-238: tmp = t_2 elif z <= 5e-305: tmp = t_1 elif z <= 3.2e+80: tmp = t_2 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(1.0 - Float64(y / a))) t_2 = Float64(x + Float64(t * Float64(y / a))) tmp = 0.0 if (z <= -3e+14) tmp = t; elseif (z <= -1.1e-23) tmp = t_2; elseif (z <= -9.6e-80) tmp = Float64(x + t); elseif (z <= -2.4e-143) tmp = t_1; elseif (z <= -3.9e-238) tmp = t_2; elseif (z <= 5e-305) tmp = t_1; elseif (z <= 3.2e+80) tmp = t_2; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (1.0 - (y / a)); t_2 = x + (t * (y / a)); tmp = 0.0; if (z <= -3e+14) tmp = t; elseif (z <= -1.1e-23) tmp = t_2; elseif (z <= -9.6e-80) tmp = x + t; elseif (z <= -2.4e-143) tmp = t_1; elseif (z <= -3.9e-238) tmp = t_2; elseif (z <= 5e-305) tmp = t_1; elseif (z <= 3.2e+80) tmp = t_2; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3e+14], t, If[LessEqual[z, -1.1e-23], t$95$2, If[LessEqual[z, -9.6e-80], N[(x + t), $MachinePrecision], If[LessEqual[z, -2.4e-143], t$95$1, If[LessEqual[z, -3.9e-238], t$95$2, If[LessEqual[z, 5e-305], t$95$1, If[LessEqual[z, 3.2e+80], t$95$2, t]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(1 - \frac{y}{a}\right)\\
t_2 := x + t \cdot \frac{y}{a}\\
\mathbf{if}\;z \leq -3 \cdot 10^{+14}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.1 \cdot 10^{-23}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -9.6 \cdot 10^{-80}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;z \leq -2.4 \cdot 10^{-143}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3.9 \cdot 10^{-238}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 5 \cdot 10^{-305}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+80}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3e14 or 3.1999999999999999e80 < z Initial program 37.9%
associate-*l/68.6%
Simplified68.6%
Taylor expanded in z around inf 53.6%
if -3e14 < z < -1.1e-23 or -2.3999999999999999e-143 < z < -3.8999999999999998e-238 or 4.99999999999999985e-305 < z < 3.1999999999999999e80Initial program 88.8%
associate-*l/92.2%
Simplified92.2%
Taylor expanded in t around inf 77.1%
associate-*r/80.0%
Simplified80.0%
Taylor expanded in z around 0 64.9%
associate-*r/67.2%
Simplified67.2%
if -1.1e-23 < z < -9.5999999999999996e-80Initial program 82.5%
associate-*l/82.5%
Simplified82.5%
Taylor expanded in t around inf 73.6%
associate-*r/73.6%
Simplified73.6%
Taylor expanded in z around inf 48.4%
if -9.5999999999999996e-80 < z < -2.3999999999999999e-143 or -3.8999999999999998e-238 < z < 4.99999999999999985e-305Initial program 85.8%
associate-*l/92.5%
Simplified92.5%
Taylor expanded in z around 0 88.8%
Taylor expanded in x around inf 79.8%
mul-1-neg79.8%
unsub-neg79.8%
Simplified79.8%
Final simplification62.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ t (/ a y)))) (t_2 (* x (- 1.0 (/ y a)))))
(if (<= z -2.8e+14)
t
(if (<= z -1.22e-21)
(+ x (* t (/ y a)))
(if (<= z -1.06e-79)
(+ x t)
(if (<= z -2.1e-143)
t_2
(if (<= z -2.75e-238)
t_1
(if (<= z 2.1e-305) t_2 (if (<= z 2e+87) t_1 t)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (z <= -2.8e+14) {
tmp = t;
} else if (z <= -1.22e-21) {
tmp = x + (t * (y / a));
} else if (z <= -1.06e-79) {
tmp = x + t;
} else if (z <= -2.1e-143) {
tmp = t_2;
} else if (z <= -2.75e-238) {
tmp = t_1;
} else if (z <= 2.1e-305) {
tmp = t_2;
} else if (z <= 2e+87) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t / (a / y))
t_2 = x * (1.0d0 - (y / a))
if (z <= (-2.8d+14)) then
tmp = t
else if (z <= (-1.22d-21)) then
tmp = x + (t * (y / a))
else if (z <= (-1.06d-79)) then
tmp = x + t
else if (z <= (-2.1d-143)) then
tmp = t_2
else if (z <= (-2.75d-238)) then
tmp = t_1
else if (z <= 2.1d-305) then
tmp = t_2
else if (z <= 2d+87) then
tmp = t_1
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (z <= -2.8e+14) {
tmp = t;
} else if (z <= -1.22e-21) {
tmp = x + (t * (y / a));
} else if (z <= -1.06e-79) {
tmp = x + t;
} else if (z <= -2.1e-143) {
tmp = t_2;
} else if (z <= -2.75e-238) {
tmp = t_1;
} else if (z <= 2.1e-305) {
tmp = t_2;
} else if (z <= 2e+87) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t / (a / y)) t_2 = x * (1.0 - (y / a)) tmp = 0 if z <= -2.8e+14: tmp = t elif z <= -1.22e-21: tmp = x + (t * (y / a)) elif z <= -1.06e-79: tmp = x + t elif z <= -2.1e-143: tmp = t_2 elif z <= -2.75e-238: tmp = t_1 elif z <= 2.1e-305: tmp = t_2 elif z <= 2e+87: tmp = t_1 else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t / Float64(a / y))) t_2 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (z <= -2.8e+14) tmp = t; elseif (z <= -1.22e-21) tmp = Float64(x + Float64(t * Float64(y / a))); elseif (z <= -1.06e-79) tmp = Float64(x + t); elseif (z <= -2.1e-143) tmp = t_2; elseif (z <= -2.75e-238) tmp = t_1; elseif (z <= 2.1e-305) tmp = t_2; elseif (z <= 2e+87) tmp = t_1; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t / (a / y)); t_2 = x * (1.0 - (y / a)); tmp = 0.0; if (z <= -2.8e+14) tmp = t; elseif (z <= -1.22e-21) tmp = x + (t * (y / a)); elseif (z <= -1.06e-79) tmp = x + t; elseif (z <= -2.1e-143) tmp = t_2; elseif (z <= -2.75e-238) tmp = t_1; elseif (z <= 2.1e-305) tmp = t_2; elseif (z <= 2e+87) tmp = t_1; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.8e+14], t, If[LessEqual[z, -1.22e-21], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.06e-79], N[(x + t), $MachinePrecision], If[LessEqual[z, -2.1e-143], t$95$2, If[LessEqual[z, -2.75e-238], t$95$1, If[LessEqual[z, 2.1e-305], t$95$2, If[LessEqual[z, 2e+87], t$95$1, t]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t}{\frac{a}{y}}\\
t_2 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;z \leq -2.8 \cdot 10^{+14}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.22 \cdot 10^{-21}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{elif}\;z \leq -1.06 \cdot 10^{-79}:\\
\;\;\;\;x + t\\
\mathbf{elif}\;z \leq -2.1 \cdot 10^{-143}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -2.75 \cdot 10^{-238}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2.1 \cdot 10^{-305}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 2 \cdot 10^{+87}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.8e14 or 1.9999999999999999e87 < z Initial program 37.9%
associate-*l/68.6%
Simplified68.6%
Taylor expanded in z around inf 53.6%
if -2.8e14 < z < -1.21999999999999991e-21Initial program 88.9%
associate-*l/99.8%
Simplified99.8%
Taylor expanded in t around inf 78.6%
associate-*r/78.6%
Simplified78.6%
Taylor expanded in z around 0 57.3%
associate-*r/57.3%
Simplified57.3%
if -1.21999999999999991e-21 < z < -1.06000000000000005e-79Initial program 82.5%
associate-*l/82.5%
Simplified82.5%
Taylor expanded in t around inf 73.6%
associate-*r/73.6%
Simplified73.6%
Taylor expanded in z around inf 48.4%
if -1.06000000000000005e-79 < z < -2.1000000000000001e-143 or -2.74999999999999997e-238 < z < 2.1e-305Initial program 85.8%
associate-*l/92.5%
Simplified92.5%
Taylor expanded in z around 0 88.8%
Taylor expanded in x around inf 79.8%
mul-1-neg79.8%
unsub-neg79.8%
Simplified79.8%
if -2.1000000000000001e-143 < z < -2.74999999999999997e-238 or 2.1e-305 < z < 1.9999999999999999e87Initial program 88.8%
associate-*l/91.6%
Simplified91.6%
Taylor expanded in t around inf 77.0%
associate-*r/80.1%
Simplified80.1%
Taylor expanded in a around inf 68.2%
associate-/l*70.7%
Simplified70.7%
Taylor expanded in y around inf 68.0%
Final simplification62.6%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.25e-71)
(+ t (* y (/ (- x t) z)))
(if (<= z 5.4e-242)
(+ x (/ y (/ a (- t x))))
(if (or (<= z 2.25e+69) (and (not (<= z 1.05e+161)) (<= z 8.6e+216)))
(- x (* t (/ (- z y) (- a z))))
(+ t (/ x (/ z (- y a))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.25e-71) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 5.4e-242) {
tmp = x + (y / (a / (t - x)));
} else if ((z <= 2.25e+69) || (!(z <= 1.05e+161) && (z <= 8.6e+216))) {
tmp = x - (t * ((z - y) / (a - z)));
} else {
tmp = t + (x / (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 <= (-1.25d-71)) then
tmp = t + (y * ((x - t) / z))
else if (z <= 5.4d-242) then
tmp = x + (y / (a / (t - x)))
else if ((z <= 2.25d+69) .or. (.not. (z <= 1.05d+161)) .and. (z <= 8.6d+216)) then
tmp = x - (t * ((z - y) / (a - z)))
else
tmp = t + (x / (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 <= -1.25e-71) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 5.4e-242) {
tmp = x + (y / (a / (t - x)));
} else if ((z <= 2.25e+69) || (!(z <= 1.05e+161) && (z <= 8.6e+216))) {
tmp = x - (t * ((z - y) / (a - z)));
} else {
tmp = t + (x / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.25e-71: tmp = t + (y * ((x - t) / z)) elif z <= 5.4e-242: tmp = x + (y / (a / (t - x))) elif (z <= 2.25e+69) or (not (z <= 1.05e+161) and (z <= 8.6e+216)): tmp = x - (t * ((z - y) / (a - z))) else: tmp = t + (x / (z / (y - a))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.25e-71) tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z))); elseif (z <= 5.4e-242) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); elseif ((z <= 2.25e+69) || (!(z <= 1.05e+161) && (z <= 8.6e+216))) tmp = Float64(x - Float64(t * Float64(Float64(z - y) / Float64(a - z)))); else tmp = Float64(t + Float64(x / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.25e-71) tmp = t + (y * ((x - t) / z)); elseif (z <= 5.4e-242) tmp = x + (y / (a / (t - x))); elseif ((z <= 2.25e+69) || (~((z <= 1.05e+161)) && (z <= 8.6e+216))) tmp = x - (t * ((z - y) / (a - z))); else tmp = t + (x / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.25e-71], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.4e-242], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 2.25e+69], And[N[Not[LessEqual[z, 1.05e+161]], $MachinePrecision], LessEqual[z, 8.6e+216]]], N[(x - N[(t * N[(N[(z - y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.25 \cdot 10^{-71}:\\
\;\;\;\;t + y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;z \leq 5.4 \cdot 10^{-242}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{+69} \lor \neg \left(z \leq 1.05 \cdot 10^{+161}\right) \land z \leq 8.6 \cdot 10^{+216}:\\
\;\;\;\;x - t \cdot \frac{z - y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if z < -1.24999999999999999e-71Initial program 55.8%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in z around inf 63.4%
associate--l+63.4%
associate-*r/63.4%
associate-*r/63.4%
div-sub63.4%
distribute-lft-out--63.4%
associate-*r/63.4%
distribute-rgt-out--63.6%
mul-1-neg63.6%
unsub-neg63.6%
associate-/l*72.3%
Simplified72.3%
Taylor expanded in y around inf 61.3%
associate-*r/66.6%
Simplified66.6%
if -1.24999999999999999e-71 < z < 5.4e-242Initial program 87.7%
associate-*l/95.6%
Simplified95.6%
Taylor expanded in z around 0 80.9%
associate-/l*90.2%
Simplified90.2%
if 5.4e-242 < z < 2.25e69 or 1.05e161 < z < 8.59999999999999939e216Initial program 86.3%
associate-*l/89.8%
Simplified89.8%
Taylor expanded in t around inf 74.9%
associate-*r/80.8%
Simplified80.8%
if 2.25e69 < z < 1.05e161 or 8.59999999999999939e216 < z Initial program 26.1%
associate-*l/59.0%
Simplified59.0%
Taylor expanded in z around inf 76.5%
associate--l+76.5%
associate-*r/76.5%
associate-*r/76.5%
div-sub76.5%
distribute-lft-out--76.5%
associate-*r/76.5%
distribute-rgt-out--76.6%
mul-1-neg76.6%
unsub-neg76.6%
associate-/l*95.0%
Simplified95.0%
Taylor expanded in t around 0 83.4%
mul-1-neg83.4%
associate-/l*92.4%
distribute-neg-frac92.4%
Simplified92.4%
Final simplification81.5%
(FPCore (x y z t a)
:precision binary64
(if (<= z -3e+14)
(+ t (* y (/ (- x t) z)))
(if (<= z 2.25e+67)
(- x (/ (* y (- x t)) (- a z)))
(if (or (<= z 1.55e+161) (not (<= z 7.6e+216)))
(+ t (/ x (/ z (- y a))))
(- x (* t (/ (- z y) (- a z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3e+14) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 2.25e+67) {
tmp = x - ((y * (x - t)) / (a - z));
} else if ((z <= 1.55e+161) || !(z <= 7.6e+216)) {
tmp = t + (x / (z / (y - a)));
} else {
tmp = x - (t * ((z - y) / (a - z)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-3d+14)) then
tmp = t + (y * ((x - t) / z))
else if (z <= 2.25d+67) then
tmp = x - ((y * (x - t)) / (a - z))
else if ((z <= 1.55d+161) .or. (.not. (z <= 7.6d+216))) then
tmp = t + (x / (z / (y - a)))
else
tmp = x - (t * ((z - y) / (a - z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3e+14) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 2.25e+67) {
tmp = x - ((y * (x - t)) / (a - z));
} else if ((z <= 1.55e+161) || !(z <= 7.6e+216)) {
tmp = t + (x / (z / (y - a)));
} else {
tmp = x - (t * ((z - y) / (a - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -3e+14: tmp = t + (y * ((x - t) / z)) elif z <= 2.25e+67: tmp = x - ((y * (x - t)) / (a - z)) elif (z <= 1.55e+161) or not (z <= 7.6e+216): tmp = t + (x / (z / (y - a))) else: tmp = x - (t * ((z - y) / (a - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3e+14) tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z))); elseif (z <= 2.25e+67) tmp = Float64(x - Float64(Float64(y * Float64(x - t)) / Float64(a - z))); elseif ((z <= 1.55e+161) || !(z <= 7.6e+216)) tmp = Float64(t + Float64(x / Float64(z / Float64(y - a)))); else tmp = Float64(x - Float64(t * Float64(Float64(z - y) / Float64(a - z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -3e+14) tmp = t + (y * ((x - t) / z)); elseif (z <= 2.25e+67) tmp = x - ((y * (x - t)) / (a - z)); elseif ((z <= 1.55e+161) || ~((z <= 7.6e+216))) tmp = t + (x / (z / (y - a))); else tmp = x - (t * ((z - y) / (a - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3e+14], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.25e+67], N[(x - N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 1.55e+161], N[Not[LessEqual[z, 7.6e+216]], $MachinePrecision]], N[(t + N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(t * N[(N[(z - y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3 \cdot 10^{+14}:\\
\;\;\;\;t + y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{+67}:\\
\;\;\;\;x - \frac{y \cdot \left(x - t\right)}{a - z}\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{+161} \lor \neg \left(z \leq 7.6 \cdot 10^{+216}\right):\\
\;\;\;\;t + \frac{x}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;x - t \cdot \frac{z - y}{a - z}\\
\end{array}
\end{array}
if z < -3e14Initial program 45.7%
associate-*l/71.6%
Simplified71.6%
Taylor expanded in z around inf 63.7%
associate--l+63.7%
associate-*r/63.7%
associate-*r/63.7%
div-sub63.7%
distribute-lft-out--63.7%
associate-*r/63.7%
distribute-rgt-out--63.9%
mul-1-neg63.9%
unsub-neg63.9%
associate-/l*75.7%
Simplified75.7%
Taylor expanded in y around inf 62.7%
associate-*r/70.0%
Simplified70.0%
if -3e14 < z < 2.2499999999999999e67Initial program 89.4%
Taylor expanded in y around inf 81.9%
*-commutative81.9%
Simplified81.9%
if 2.2499999999999999e67 < z < 1.55000000000000003e161 or 7.60000000000000029e216 < z Initial program 26.1%
associate-*l/59.0%
Simplified59.0%
Taylor expanded in z around inf 76.5%
associate--l+76.5%
associate-*r/76.5%
associate-*r/76.5%
div-sub76.5%
distribute-lft-out--76.5%
associate-*r/76.5%
distribute-rgt-out--76.6%
mul-1-neg76.6%
unsub-neg76.6%
associate-/l*95.0%
Simplified95.0%
Taylor expanded in t around 0 83.4%
mul-1-neg83.4%
associate-/l*92.4%
distribute-neg-frac92.4%
Simplified92.4%
if 1.55000000000000003e161 < z < 7.60000000000000029e216Initial program 48.3%
associate-*l/82.4%
Simplified82.4%
Taylor expanded in t around inf 55.2%
associate-*r/80.8%
Simplified80.8%
Final simplification81.2%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.15e+14)
(+ t (* y (/ (- x t) z)))
(if (<= z 3.7e+64)
(- x (/ (* y (- x t)) (- a z)))
(if (or (<= z 1.1e+161) (not (<= z 7.6e+216)))
(+ t (/ x (/ z (- y a))))
(+ x (/ (- y z) (/ (- a z) t)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.15e+14) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 3.7e+64) {
tmp = x - ((y * (x - t)) / (a - z));
} else if ((z <= 1.1e+161) || !(z <= 7.6e+216)) {
tmp = t + (x / (z / (y - a)));
} else {
tmp = x + ((y - z) / ((a - z) / 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.15d+14)) then
tmp = t + (y * ((x - t) / z))
else if (z <= 3.7d+64) then
tmp = x - ((y * (x - t)) / (a - z))
else if ((z <= 1.1d+161) .or. (.not. (z <= 7.6d+216))) then
tmp = t + (x / (z / (y - a)))
else
tmp = x + ((y - z) / ((a - z) / 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.15e+14) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 3.7e+64) {
tmp = x - ((y * (x - t)) / (a - z));
} else if ((z <= 1.1e+161) || !(z <= 7.6e+216)) {
tmp = t + (x / (z / (y - a)));
} else {
tmp = x + ((y - z) / ((a - z) / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.15e+14: tmp = t + (y * ((x - t) / z)) elif z <= 3.7e+64: tmp = x - ((y * (x - t)) / (a - z)) elif (z <= 1.1e+161) or not (z <= 7.6e+216): tmp = t + (x / (z / (y - a))) else: tmp = x + ((y - z) / ((a - z) / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.15e+14) tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z))); elseif (z <= 3.7e+64) tmp = Float64(x - Float64(Float64(y * Float64(x - t)) / Float64(a - z))); elseif ((z <= 1.1e+161) || !(z <= 7.6e+216)) tmp = Float64(t + Float64(x / Float64(z / Float64(y - a)))); else tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.15e+14) tmp = t + (y * ((x - t) / z)); elseif (z <= 3.7e+64) tmp = x - ((y * (x - t)) / (a - z)); elseif ((z <= 1.1e+161) || ~((z <= 7.6e+216))) tmp = t + (x / (z / (y - a))); else tmp = x + ((y - z) / ((a - z) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.15e+14], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.7e+64], N[(x - N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 1.1e+161], N[Not[LessEqual[z, 7.6e+216]], $MachinePrecision]], N[(t + N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.15 \cdot 10^{+14}:\\
\;\;\;\;t + y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;z \leq 3.7 \cdot 10^{+64}:\\
\;\;\;\;x - \frac{y \cdot \left(x - t\right)}{a - z}\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+161} \lor \neg \left(z \leq 7.6 \cdot 10^{+216}\right):\\
\;\;\;\;t + \frac{x}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t}}\\
\end{array}
\end{array}
if z < -2.15e14Initial program 45.7%
associate-*l/71.6%
Simplified71.6%
Taylor expanded in z around inf 63.7%
associate--l+63.7%
associate-*r/63.7%
associate-*r/63.7%
div-sub63.7%
distribute-lft-out--63.7%
associate-*r/63.7%
distribute-rgt-out--63.9%
mul-1-neg63.9%
unsub-neg63.9%
associate-/l*75.7%
Simplified75.7%
Taylor expanded in y around inf 62.7%
associate-*r/70.0%
Simplified70.0%
if -2.15e14 < z < 3.69999999999999983e64Initial program 89.4%
Taylor expanded in y around inf 81.9%
*-commutative81.9%
Simplified81.9%
if 3.69999999999999983e64 < z < 1.1e161 or 7.60000000000000029e216 < z Initial program 26.1%
associate-*l/59.0%
Simplified59.0%
Taylor expanded in z around inf 76.5%
associate--l+76.5%
associate-*r/76.5%
associate-*r/76.5%
div-sub76.5%
distribute-lft-out--76.5%
associate-*r/76.5%
distribute-rgt-out--76.6%
mul-1-neg76.6%
unsub-neg76.6%
associate-/l*95.0%
Simplified95.0%
Taylor expanded in t around 0 83.4%
mul-1-neg83.4%
associate-/l*92.4%
distribute-neg-frac92.4%
Simplified92.4%
if 1.1e161 < z < 7.60000000000000029e216Initial program 48.3%
associate-/l*82.6%
Simplified82.6%
Taylor expanded in t around inf 80.9%
Final simplification81.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* y (/ (- x t) z)))))
(if (<= z -1e-71)
t_1
(if (<= z 1.5e-75)
(- x (/ (- x t) (/ a y)))
(if (or (<= z 2.3e-29) (not (<= z 2.5e+39)))
t_1
(- x (* t (/ (- z y) a))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -1e-71) {
tmp = t_1;
} else if (z <= 1.5e-75) {
tmp = x - ((x - t) / (a / y));
} else if ((z <= 2.3e-29) || !(z <= 2.5e+39)) {
tmp = t_1;
} else {
tmp = x - (t * ((z - y) / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t + (y * ((x - t) / z))
if (z <= (-1d-71)) then
tmp = t_1
else if (z <= 1.5d-75) then
tmp = x - ((x - t) / (a / y))
else if ((z <= 2.3d-29) .or. (.not. (z <= 2.5d+39))) then
tmp = t_1
else
tmp = x - (t * ((z - y) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -1e-71) {
tmp = t_1;
} else if (z <= 1.5e-75) {
tmp = x - ((x - t) / (a / y));
} else if ((z <= 2.3e-29) || !(z <= 2.5e+39)) {
tmp = t_1;
} else {
tmp = x - (t * ((z - y) / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (y * ((x - t) / z)) tmp = 0 if z <= -1e-71: tmp = t_1 elif z <= 1.5e-75: tmp = x - ((x - t) / (a / y)) elif (z <= 2.3e-29) or not (z <= 2.5e+39): tmp = t_1 else: tmp = x - (t * ((z - y) / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(y * Float64(Float64(x - t) / z))) tmp = 0.0 if (z <= -1e-71) tmp = t_1; elseif (z <= 1.5e-75) tmp = Float64(x - Float64(Float64(x - t) / Float64(a / y))); elseif ((z <= 2.3e-29) || !(z <= 2.5e+39)) tmp = t_1; else tmp = Float64(x - Float64(t * Float64(Float64(z - y) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (y * ((x - t) / z)); tmp = 0.0; if (z <= -1e-71) tmp = t_1; elseif (z <= 1.5e-75) tmp = x - ((x - t) / (a / y)); elseif ((z <= 2.3e-29) || ~((z <= 2.5e+39))) tmp = t_1; else tmp = x - (t * ((z - y) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1e-71], t$95$1, If[LessEqual[z, 1.5e-75], N[(x - N[(N[(x - t), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 2.3e-29], N[Not[LessEqual[z, 2.5e+39]], $MachinePrecision]], t$95$1, N[(x - N[(t * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot \frac{x - t}{z}\\
\mathbf{if}\;z \leq -1 \cdot 10^{-71}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.5 \cdot 10^{-75}:\\
\;\;\;\;x - \frac{x - t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 2.3 \cdot 10^{-29} \lor \neg \left(z \leq 2.5 \cdot 10^{+39}\right):\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x - t \cdot \frac{z - y}{a}\\
\end{array}
\end{array}
if z < -9.9999999999999992e-72 or 1.4999999999999999e-75 < z < 2.29999999999999991e-29 or 2.50000000000000008e39 < z Initial program 50.4%
associate-*l/72.8%
Simplified72.8%
Taylor expanded in z around inf 67.3%
associate--l+67.3%
associate-*r/67.3%
associate-*r/67.3%
div-sub67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
distribute-rgt-out--67.4%
mul-1-neg67.4%
unsub-neg67.4%
associate-/l*76.4%
Simplified76.4%
Taylor expanded in y around inf 63.9%
associate-*r/69.6%
Simplified69.6%
if -9.9999999999999992e-72 < z < 1.4999999999999999e-75Initial program 90.4%
associate-*l/95.3%
Simplified95.3%
Taylor expanded in z around 0 85.6%
*-commutative85.6%
clear-num85.6%
un-div-inv85.7%
Applied egg-rr85.7%
if 2.29999999999999991e-29 < z < 2.50000000000000008e39Initial program 82.4%
associate-*l/82.4%
Simplified82.4%
Taylor expanded in t around inf 70.9%
associate-*r/70.9%
Simplified70.9%
Taylor expanded in a around inf 79.5%
Final simplification76.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ y (- a z))))))
(if (<= z -2.4e+14)
(- t (/ y (/ z (- x))))
(if (<= z -5.3e-238)
t_1
(if (<= z 2.5e-300)
(* x (- 1.0 (/ y a)))
(if (<= z 3.2e+69) t_1 (+ t (* x (/ y z)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / (a - z)));
double tmp;
if (z <= -2.4e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -5.3e-238) {
tmp = t_1;
} else if (z <= 2.5e-300) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.2e+69) {
tmp = t_1;
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (t * (y / (a - z)))
if (z <= (-2.4d+14)) then
tmp = t - (y / (z / -x))
else if (z <= (-5.3d-238)) then
tmp = t_1
else if (z <= 2.5d-300) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.2d+69) then
tmp = t_1
else
tmp = t + (x * (y / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * (y / (a - z)));
double tmp;
if (z <= -2.4e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -5.3e-238) {
tmp = t_1;
} else if (z <= 2.5e-300) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.2e+69) {
tmp = t_1;
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * (y / (a - z))) tmp = 0 if z <= -2.4e+14: tmp = t - (y / (z / -x)) elif z <= -5.3e-238: tmp = t_1 elif z <= 2.5e-300: tmp = x * (1.0 - (y / a)) elif z <= 3.2e+69: tmp = t_1 else: tmp = t + (x * (y / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(y / Float64(a - z)))) tmp = 0.0 if (z <= -2.4e+14) tmp = Float64(t - Float64(y / Float64(z / Float64(-x)))); elseif (z <= -5.3e-238) tmp = t_1; elseif (z <= 2.5e-300) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.2e+69) tmp = t_1; else tmp = Float64(t + Float64(x * Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t * (y / (a - z))); tmp = 0.0; if (z <= -2.4e+14) tmp = t - (y / (z / -x)); elseif (z <= -5.3e-238) tmp = t_1; elseif (z <= 2.5e-300) tmp = x * (1.0 - (y / a)); elseif (z <= 3.2e+69) tmp = t_1; else tmp = t + (x * (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.4e+14], N[(t - N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -5.3e-238], t$95$1, If[LessEqual[z, 2.5e-300], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e+69], t$95$1, N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + t \cdot \frac{y}{a - z}\\
\mathbf{if}\;z \leq -2.4 \cdot 10^{+14}:\\
\;\;\;\;t - \frac{y}{\frac{z}{-x}}\\
\mathbf{elif}\;z \leq -5.3 \cdot 10^{-238}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{-300}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+69}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if z < -2.4e14Initial program 45.7%
associate-*l/71.6%
Simplified71.6%
Taylor expanded in z around inf 63.7%
associate--l+63.7%
associate-*r/63.7%
associate-*r/63.7%
div-sub63.7%
distribute-lft-out--63.7%
associate-*r/63.7%
distribute-rgt-out--63.9%
mul-1-neg63.9%
unsub-neg63.9%
associate-/l*75.7%
Simplified75.7%
Taylor expanded in y around inf 62.7%
Taylor expanded in t around 0 59.6%
associate-*r/59.6%
mul-1-neg59.6%
distribute-lft-neg-out59.6%
*-commutative59.6%
associate-/l*63.6%
Simplified63.6%
if -2.4e14 < z < -5.29999999999999968e-238 or 2.49999999999999998e-300 < z < 3.19999999999999985e69Initial program 89.0%
associate-*l/92.2%
Simplified92.2%
Taylor expanded in t around inf 76.3%
associate-*r/78.8%
Simplified78.8%
Taylor expanded in y around inf 70.7%
if -5.29999999999999968e-238 < z < 2.49999999999999998e-300Initial program 86.6%
associate-*l/93.0%
Simplified93.0%
Taylor expanded in z around 0 93.0%
Taylor expanded in x around inf 93.0%
mul-1-neg93.0%
unsub-neg93.0%
Simplified93.0%
if 3.19999999999999985e69 < z Initial program 31.4%
associate-*l/65.2%
Simplified65.2%
Taylor expanded in z around inf 71.3%
associate--l+71.3%
associate-*r/71.3%
associate-*r/71.3%
div-sub71.3%
distribute-lft-out--71.3%
associate-*r/71.3%
distribute-rgt-out--71.4%
mul-1-neg71.4%
unsub-neg71.4%
associate-/l*84.4%
Simplified84.4%
Taylor expanded in y around inf 65.4%
Taylor expanded in t around 0 67.7%
mul-1-neg67.7%
associate-/l*71.1%
Simplified71.1%
clear-num71.2%
associate-/r/71.1%
clear-num71.2%
Applied egg-rr71.2%
Final simplification70.6%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.8e+14)
(- t (/ y (/ z (- x))))
(if (<= z -3.7e-31)
(+ x (* t (/ y (- a z))))
(if (<= z -2e-38)
t
(if (<= z 6.2e+38) (+ x (* (- t x) (/ y a))) (+ t (* x (/ y z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.8e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -3.7e-31) {
tmp = x + (t * (y / (a - z)));
} else if (z <= -2e-38) {
tmp = t;
} else if (z <= 6.2e+38) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.8d+14)) then
tmp = t - (y / (z / -x))
else if (z <= (-3.7d-31)) then
tmp = x + (t * (y / (a - z)))
else if (z <= (-2d-38)) then
tmp = t
else if (z <= 6.2d+38) then
tmp = x + ((t - x) * (y / a))
else
tmp = t + (x * (y / 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.8e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -3.7e-31) {
tmp = x + (t * (y / (a - z)));
} else if (z <= -2e-38) {
tmp = t;
} else if (z <= 6.2e+38) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.8e+14: tmp = t - (y / (z / -x)) elif z <= -3.7e-31: tmp = x + (t * (y / (a - z))) elif z <= -2e-38: tmp = t elif z <= 6.2e+38: tmp = x + ((t - x) * (y / a)) else: tmp = t + (x * (y / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.8e+14) tmp = Float64(t - Float64(y / Float64(z / Float64(-x)))); elseif (z <= -3.7e-31) tmp = Float64(x + Float64(t * Float64(y / Float64(a - z)))); elseif (z <= -2e-38) tmp = t; elseif (z <= 6.2e+38) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); else tmp = Float64(t + Float64(x * Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.8e+14) tmp = t - (y / (z / -x)); elseif (z <= -3.7e-31) tmp = x + (t * (y / (a - z))); elseif (z <= -2e-38) tmp = t; elseif (z <= 6.2e+38) tmp = x + ((t - x) * (y / a)); else tmp = t + (x * (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.8e+14], N[(t - N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.7e-31], N[(x + N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2e-38], t, If[LessEqual[z, 6.2e+38], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.8 \cdot 10^{+14}:\\
\;\;\;\;t - \frac{y}{\frac{z}{-x}}\\
\mathbf{elif}\;z \leq -3.7 \cdot 10^{-31}:\\
\;\;\;\;x + t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;z \leq -2 \cdot 10^{-38}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 6.2 \cdot 10^{+38}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if z < -2.8e14Initial program 45.7%
associate-*l/71.6%
Simplified71.6%
Taylor expanded in z around inf 63.7%
associate--l+63.7%
associate-*r/63.7%
associate-*r/63.7%
div-sub63.7%
distribute-lft-out--63.7%
associate-*r/63.7%
distribute-rgt-out--63.9%
mul-1-neg63.9%
unsub-neg63.9%
associate-/l*75.7%
Simplified75.7%
Taylor expanded in y around inf 62.7%
Taylor expanded in t around 0 59.6%
associate-*r/59.6%
mul-1-neg59.6%
distribute-lft-neg-out59.6%
*-commutative59.6%
associate-/l*63.6%
Simplified63.6%
if -2.8e14 < z < -3.6999999999999998e-31Initial program 80.6%
associate-*l/90.4%
Simplified90.4%
Taylor expanded in t around inf 71.4%
associate-*r/71.4%
Simplified71.4%
Taylor expanded in y around inf 71.4%
if -3.6999999999999998e-31 < z < -1.9999999999999999e-38Initial program 67.6%
associate-*l/67.6%
Simplified67.6%
Taylor expanded in z around inf 100.0%
if -1.9999999999999999e-38 < z < 6.20000000000000035e38Initial program 90.8%
associate-*l/93.4%
Simplified93.4%
Taylor expanded in z around 0 79.0%
if 6.20000000000000035e38 < z Initial program 35.4%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 69.8%
associate--l+69.8%
associate-*r/69.8%
associate-*r/69.8%
div-sub69.8%
distribute-lft-out--69.8%
associate-*r/69.8%
distribute-rgt-out--69.9%
mul-1-neg69.9%
unsub-neg69.9%
associate-/l*83.2%
Simplified83.2%
Taylor expanded in y around inf 64.3%
Taylor expanded in t around 0 63.0%
mul-1-neg63.0%
associate-/l*66.1%
Simplified66.1%
clear-num66.1%
associate-/r/66.1%
clear-num66.1%
Applied egg-rr66.1%
Final simplification73.0%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.3e+14)
(- t (/ y (/ z (- x))))
(if (<= z -3.7e-31)
(+ x (* t (/ y (- a z))))
(if (<= z -2e-38)
t
(if (<= z 6.5e+38) (- x (/ (- x t) (/ a y))) (+ t (* x (/ y z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.3e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -3.7e-31) {
tmp = x + (t * (y / (a - z)));
} else if (z <= -2e-38) {
tmp = t;
} else if (z <= 6.5e+38) {
tmp = x - ((x - t) / (a / y));
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.3d+14)) then
tmp = t - (y / (z / -x))
else if (z <= (-3.7d-31)) then
tmp = x + (t * (y / (a - z)))
else if (z <= (-2d-38)) then
tmp = t
else if (z <= 6.5d+38) then
tmp = x - ((x - t) / (a / y))
else
tmp = t + (x * (y / 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.3e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -3.7e-31) {
tmp = x + (t * (y / (a - z)));
} else if (z <= -2e-38) {
tmp = t;
} else if (z <= 6.5e+38) {
tmp = x - ((x - t) / (a / y));
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.3e+14: tmp = t - (y / (z / -x)) elif z <= -3.7e-31: tmp = x + (t * (y / (a - z))) elif z <= -2e-38: tmp = t elif z <= 6.5e+38: tmp = x - ((x - t) / (a / y)) else: tmp = t + (x * (y / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.3e+14) tmp = Float64(t - Float64(y / Float64(z / Float64(-x)))); elseif (z <= -3.7e-31) tmp = Float64(x + Float64(t * Float64(y / Float64(a - z)))); elseif (z <= -2e-38) tmp = t; elseif (z <= 6.5e+38) tmp = Float64(x - Float64(Float64(x - t) / Float64(a / y))); else tmp = Float64(t + Float64(x * Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.3e+14) tmp = t - (y / (z / -x)); elseif (z <= -3.7e-31) tmp = x + (t * (y / (a - z))); elseif (z <= -2e-38) tmp = t; elseif (z <= 6.5e+38) tmp = x - ((x - t) / (a / y)); else tmp = t + (x * (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.3e+14], N[(t - N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.7e-31], N[(x + N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2e-38], t, If[LessEqual[z, 6.5e+38], N[(x - N[(N[(x - t), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.3 \cdot 10^{+14}:\\
\;\;\;\;t - \frac{y}{\frac{z}{-x}}\\
\mathbf{elif}\;z \leq -3.7 \cdot 10^{-31}:\\
\;\;\;\;x + t \cdot \frac{y}{a - z}\\
\mathbf{elif}\;z \leq -2 \cdot 10^{-38}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+38}:\\
\;\;\;\;x - \frac{x - t}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if z < -2.3e14Initial program 45.7%
associate-*l/71.6%
Simplified71.6%
Taylor expanded in z around inf 63.7%
associate--l+63.7%
associate-*r/63.7%
associate-*r/63.7%
div-sub63.7%
distribute-lft-out--63.7%
associate-*r/63.7%
distribute-rgt-out--63.9%
mul-1-neg63.9%
unsub-neg63.9%
associate-/l*75.7%
Simplified75.7%
Taylor expanded in y around inf 62.7%
Taylor expanded in t around 0 59.6%
associate-*r/59.6%
mul-1-neg59.6%
distribute-lft-neg-out59.6%
*-commutative59.6%
associate-/l*63.6%
Simplified63.6%
if -2.3e14 < z < -3.6999999999999998e-31Initial program 80.6%
associate-*l/90.4%
Simplified90.4%
Taylor expanded in t around inf 71.4%
associate-*r/71.4%
Simplified71.4%
Taylor expanded in y around inf 71.4%
if -3.6999999999999998e-31 < z < -1.9999999999999999e-38Initial program 67.6%
associate-*l/67.6%
Simplified67.6%
Taylor expanded in z around inf 100.0%
if -1.9999999999999999e-38 < z < 6.5e38Initial program 90.8%
associate-*l/93.4%
Simplified93.4%
Taylor expanded in z around 0 79.0%
*-commutative79.0%
clear-num78.9%
un-div-inv79.0%
Applied egg-rr79.0%
if 6.5e38 < z Initial program 35.4%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 69.8%
associate--l+69.8%
associate-*r/69.8%
associate-*r/69.8%
div-sub69.8%
distribute-lft-out--69.8%
associate-*r/69.8%
distribute-rgt-out--69.9%
mul-1-neg69.9%
unsub-neg69.9%
associate-/l*83.2%
Simplified83.2%
Taylor expanded in y around inf 64.3%
Taylor expanded in t around 0 63.0%
mul-1-neg63.0%
associate-/l*66.1%
Simplified66.1%
clear-num66.1%
associate-/r/66.1%
clear-num66.1%
Applied egg-rr66.1%
Final simplification73.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* y (/ (- x t) z)))))
(if (<= z -1.25e-71)
t_1
(if (<= z 4.6e-87)
(- x (/ (- x t) (/ a y)))
(if (<= z 1.4e-29)
(+ t (/ (* y (- x t)) z))
(if (<= z 1.4e+39) (- x (* t (/ (- z y) a))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (y * ((x - t) / z));
double tmp;
if (z <= -1.25e-71) {
tmp = t_1;
} else if (z <= 4.6e-87) {
tmp = x - ((x - t) / (a / y));
} else if (z <= 1.4e-29) {
tmp = t + ((y * (x - t)) / z);
} else if (z <= 1.4e+39) {
tmp = 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 + (y * ((x - t) / z))
if (z <= (-1.25d-71)) then
tmp = t_1
else if (z <= 4.6d-87) then
tmp = x - ((x - t) / (a / y))
else if (z <= 1.4d-29) then
tmp = t + ((y * (x - t)) / z)
else if (z <= 1.4d+39) then
tmp = 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 + (y * ((x - t) / z));
double tmp;
if (z <= -1.25e-71) {
tmp = t_1;
} else if (z <= 4.6e-87) {
tmp = x - ((x - t) / (a / y));
} else if (z <= 1.4e-29) {
tmp = t + ((y * (x - t)) / z);
} else if (z <= 1.4e+39) {
tmp = x - (t * ((z - y) / a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (y * ((x - t) / z)) tmp = 0 if z <= -1.25e-71: tmp = t_1 elif z <= 4.6e-87: tmp = x - ((x - t) / (a / y)) elif z <= 1.4e-29: tmp = t + ((y * (x - t)) / z) elif z <= 1.4e+39: tmp = x - (t * ((z - y) / a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(y * Float64(Float64(x - t) / z))) tmp = 0.0 if (z <= -1.25e-71) tmp = t_1; elseif (z <= 4.6e-87) tmp = Float64(x - Float64(Float64(x - t) / Float64(a / y))); elseif (z <= 1.4e-29) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (z <= 1.4e+39) tmp = Float64(x - Float64(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 + (y * ((x - t) / z)); tmp = 0.0; if (z <= -1.25e-71) tmp = t_1; elseif (z <= 4.6e-87) tmp = x - ((x - t) / (a / y)); elseif (z <= 1.4e-29) tmp = t + ((y * (x - t)) / z); elseif (z <= 1.4e+39) tmp = 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[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.25e-71], t$95$1, If[LessEqual[z, 4.6e-87], N[(x - N[(N[(x - t), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.4e-29], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.4e+39], N[(x - N[(t * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot \frac{x - t}{z}\\
\mathbf{if}\;z \leq -1.25 \cdot 10^{-71}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 4.6 \cdot 10^{-87}:\\
\;\;\;\;x - \frac{x - t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 1.4 \cdot 10^{-29}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;z \leq 1.4 \cdot 10^{+39}:\\
\;\;\;\;x - t \cdot \frac{z - y}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.24999999999999999e-71 or 1.40000000000000001e39 < z Initial program 46.5%
associate-*l/72.1%
Simplified72.1%
Taylor expanded in z around inf 66.3%
associate--l+66.3%
associate-*r/66.3%
associate-*r/66.3%
div-sub66.3%
distribute-lft-out--66.3%
associate-*r/66.3%
distribute-rgt-out--66.4%
mul-1-neg66.4%
unsub-neg66.4%
associate-/l*77.2%
Simplified77.2%
Taylor expanded in y around inf 62.6%
associate-*r/68.8%
Simplified68.8%
if -1.24999999999999999e-71 < z < 4.6000000000000003e-87Initial program 90.9%
associate-*l/96.0%
Simplified96.0%
Taylor expanded in z around 0 87.9%
*-commutative87.9%
clear-num87.9%
un-div-inv88.0%
Applied egg-rr88.0%
if 4.6000000000000003e-87 < z < 1.4000000000000001e-29Initial program 92.8%
associate-*l/79.5%
Simplified79.5%
Taylor expanded in z around inf 78.0%
associate--l+78.0%
associate-*r/78.0%
associate-*r/78.0%
div-sub78.0%
distribute-lft-out--78.0%
associate-*r/78.0%
distribute-rgt-out--78.0%
mul-1-neg78.0%
unsub-neg78.0%
associate-/l*68.1%
Simplified68.1%
Taylor expanded in y around inf 71.8%
if 1.4000000000000001e-29 < z < 1.40000000000000001e39Initial program 82.4%
associate-*l/82.4%
Simplified82.4%
Taylor expanded in t around inf 70.9%
associate-*r/70.9%
Simplified70.9%
Taylor expanded in a around inf 79.5%
Final simplification77.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.2e-71)
(+ t (* y (/ (- x t) z)))
(if (<= z 4.4e-87)
(- x (/ (- x t) (/ a y)))
(if (<= z 2.6e-30)
(+ t (/ (* y (- x t)) z))
(if (<= z 1.1e+37)
(- x (* t (/ (- z y) a)))
(+ t (* (- y a) (/ x z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.2e-71) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 4.4e-87) {
tmp = x - ((x - t) / (a / y));
} else if (z <= 2.6e-30) {
tmp = t + ((y * (x - t)) / z);
} else if (z <= 1.1e+37) {
tmp = x - (t * ((z - y) / a));
} else {
tmp = t + ((y - a) * (x / 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.2d-71)) then
tmp = t + (y * ((x - t) / z))
else if (z <= 4.4d-87) then
tmp = x - ((x - t) / (a / y))
else if (z <= 2.6d-30) then
tmp = t + ((y * (x - t)) / z)
else if (z <= 1.1d+37) then
tmp = x - (t * ((z - y) / a))
else
tmp = t + ((y - a) * (x / 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.2e-71) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 4.4e-87) {
tmp = x - ((x - t) / (a / y));
} else if (z <= 2.6e-30) {
tmp = t + ((y * (x - t)) / z);
} else if (z <= 1.1e+37) {
tmp = x - (t * ((z - y) / a));
} else {
tmp = t + ((y - a) * (x / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.2e-71: tmp = t + (y * ((x - t) / z)) elif z <= 4.4e-87: tmp = x - ((x - t) / (a / y)) elif z <= 2.6e-30: tmp = t + ((y * (x - t)) / z) elif z <= 1.1e+37: tmp = x - (t * ((z - y) / a)) else: tmp = t + ((y - a) * (x / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.2e-71) tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z))); elseif (z <= 4.4e-87) tmp = Float64(x - Float64(Float64(x - t) / Float64(a / y))); elseif (z <= 2.6e-30) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (z <= 1.1e+37) tmp = Float64(x - Float64(t * Float64(Float64(z - y) / a))); else tmp = Float64(t + Float64(Float64(y - a) * Float64(x / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.2e-71) tmp = t + (y * ((x - t) / z)); elseif (z <= 4.4e-87) tmp = x - ((x - t) / (a / y)); elseif (z <= 2.6e-30) tmp = t + ((y * (x - t)) / z); elseif (z <= 1.1e+37) tmp = x - (t * ((z - y) / a)); else tmp = t + ((y - a) * (x / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.2e-71], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.4e-87], N[(x - N[(N[(x - t), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.6e-30], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e+37], N[(x - N[(t * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(y - a), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.2 \cdot 10^{-71}:\\
\;\;\;\;t + y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;z \leq 4.4 \cdot 10^{-87}:\\
\;\;\;\;x - \frac{x - t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 2.6 \cdot 10^{-30}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+37}:\\
\;\;\;\;x - t \cdot \frac{z - y}{a}\\
\mathbf{else}:\\
\;\;\;\;t + \left(y - a\right) \cdot \frac{x}{z}\\
\end{array}
\end{array}
if z < -1.2e-71Initial program 55.8%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in z around inf 63.4%
associate--l+63.4%
associate-*r/63.4%
associate-*r/63.4%
div-sub63.4%
distribute-lft-out--63.4%
associate-*r/63.4%
distribute-rgt-out--63.6%
mul-1-neg63.6%
unsub-neg63.6%
associate-/l*72.3%
Simplified72.3%
Taylor expanded in y around inf 61.3%
associate-*r/66.6%
Simplified66.6%
if -1.2e-71 < z < 4.39999999999999976e-87Initial program 90.9%
associate-*l/96.0%
Simplified96.0%
Taylor expanded in z around 0 87.9%
*-commutative87.9%
clear-num87.9%
un-div-inv88.0%
Applied egg-rr88.0%
if 4.39999999999999976e-87 < z < 2.59999999999999987e-30Initial program 92.8%
associate-*l/79.5%
Simplified79.5%
Taylor expanded in z around inf 78.0%
associate--l+78.0%
associate-*r/78.0%
associate-*r/78.0%
div-sub78.0%
distribute-lft-out--78.0%
associate-*r/78.0%
distribute-rgt-out--78.0%
mul-1-neg78.0%
unsub-neg78.0%
associate-/l*68.1%
Simplified68.1%
Taylor expanded in y around inf 71.8%
if 2.59999999999999987e-30 < z < 1.1e37Initial program 82.4%
associate-*l/82.4%
Simplified82.4%
Taylor expanded in t around inf 70.9%
associate-*r/70.9%
Simplified70.9%
Taylor expanded in a around inf 79.5%
if 1.1e37 < z Initial program 35.4%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 69.8%
associate--l+69.8%
associate-*r/69.8%
associate-*r/69.8%
div-sub69.8%
distribute-lft-out--69.8%
associate-*r/69.8%
distribute-rgt-out--69.9%
mul-1-neg69.9%
unsub-neg69.9%
associate-/l*83.2%
Simplified83.2%
Taylor expanded in t around 0 71.5%
mul-1-neg71.5%
associate-*l/74.9%
distribute-rgt-neg-in74.9%
Simplified74.9%
Final simplification78.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.25e-71)
(+ t (* y (/ (- x t) z)))
(if (<= z 4.8e-87)
(- x (/ (- x t) (/ a y)))
(if (<= z 1.8e-31)
(+ t (/ (* y (- x t)) z))
(if (<= z 1.65e+37)
(- x (* t (/ (- z y) a)))
(+ t (/ x (/ z (- y a)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.25e-71) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 4.8e-87) {
tmp = x - ((x - t) / (a / y));
} else if (z <= 1.8e-31) {
tmp = t + ((y * (x - t)) / z);
} else if (z <= 1.65e+37) {
tmp = x - (t * ((z - y) / a));
} else {
tmp = t + (x / (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 <= (-1.25d-71)) then
tmp = t + (y * ((x - t) / z))
else if (z <= 4.8d-87) then
tmp = x - ((x - t) / (a / y))
else if (z <= 1.8d-31) then
tmp = t + ((y * (x - t)) / z)
else if (z <= 1.65d+37) then
tmp = x - (t * ((z - y) / a))
else
tmp = t + (x / (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 <= -1.25e-71) {
tmp = t + (y * ((x - t) / z));
} else if (z <= 4.8e-87) {
tmp = x - ((x - t) / (a / y));
} else if (z <= 1.8e-31) {
tmp = t + ((y * (x - t)) / z);
} else if (z <= 1.65e+37) {
tmp = x - (t * ((z - y) / a));
} else {
tmp = t + (x / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.25e-71: tmp = t + (y * ((x - t) / z)) elif z <= 4.8e-87: tmp = x - ((x - t) / (a / y)) elif z <= 1.8e-31: tmp = t + ((y * (x - t)) / z) elif z <= 1.65e+37: tmp = x - (t * ((z - y) / a)) else: tmp = t + (x / (z / (y - a))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.25e-71) tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z))); elseif (z <= 4.8e-87) tmp = Float64(x - Float64(Float64(x - t) / Float64(a / y))); elseif (z <= 1.8e-31) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (z <= 1.65e+37) tmp = Float64(x - Float64(t * Float64(Float64(z - y) / a))); else tmp = Float64(t + Float64(x / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.25e-71) tmp = t + (y * ((x - t) / z)); elseif (z <= 4.8e-87) tmp = x - ((x - t) / (a / y)); elseif (z <= 1.8e-31) tmp = t + ((y * (x - t)) / z); elseif (z <= 1.65e+37) tmp = x - (t * ((z - y) / a)); else tmp = t + (x / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.25e-71], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.8e-87], N[(x - N[(N[(x - t), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.8e-31], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.65e+37], N[(x - N[(t * N[(N[(z - y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.25 \cdot 10^{-71}:\\
\;\;\;\;t + y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;z \leq 4.8 \cdot 10^{-87}:\\
\;\;\;\;x - \frac{x - t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 1.8 \cdot 10^{-31}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;z \leq 1.65 \cdot 10^{+37}:\\
\;\;\;\;x - t \cdot \frac{z - y}{a}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if z < -1.24999999999999999e-71Initial program 55.8%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in z around inf 63.4%
associate--l+63.4%
associate-*r/63.4%
associate-*r/63.4%
div-sub63.4%
distribute-lft-out--63.4%
associate-*r/63.4%
distribute-rgt-out--63.6%
mul-1-neg63.6%
unsub-neg63.6%
associate-/l*72.3%
Simplified72.3%
Taylor expanded in y around inf 61.3%
associate-*r/66.6%
Simplified66.6%
if -1.24999999999999999e-71 < z < 4.7999999999999999e-87Initial program 90.9%
associate-*l/96.0%
Simplified96.0%
Taylor expanded in z around 0 87.9%
*-commutative87.9%
clear-num87.9%
un-div-inv88.0%
Applied egg-rr88.0%
if 4.7999999999999999e-87 < z < 1.80000000000000002e-31Initial program 92.8%
associate-*l/79.5%
Simplified79.5%
Taylor expanded in z around inf 78.0%
associate--l+78.0%
associate-*r/78.0%
associate-*r/78.0%
div-sub78.0%
distribute-lft-out--78.0%
associate-*r/78.0%
distribute-rgt-out--78.0%
mul-1-neg78.0%
unsub-neg78.0%
associate-/l*68.1%
Simplified68.1%
Taylor expanded in y around inf 71.8%
if 1.80000000000000002e-31 < z < 1.65e37Initial program 82.4%
associate-*l/82.4%
Simplified82.4%
Taylor expanded in t around inf 70.9%
associate-*r/70.9%
Simplified70.9%
Taylor expanded in a around inf 79.5%
if 1.65e37 < z Initial program 35.4%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 69.8%
associate--l+69.8%
associate-*r/69.8%
associate-*r/69.8%
div-sub69.8%
distribute-lft-out--69.8%
associate-*r/69.8%
distribute-rgt-out--69.9%
mul-1-neg69.9%
unsub-neg69.9%
associate-/l*83.2%
Simplified83.2%
Taylor expanded in t around 0 71.5%
mul-1-neg71.5%
associate-/l*76.2%
distribute-neg-frac76.2%
Simplified76.2%
Final simplification78.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ t (/ a y)))) (t_2 (- t (* t (/ y z)))))
(if (<= z -5800000.0)
t_2
(if (<= z -2.25e-238)
t_1
(if (<= z 1.35e-304)
(* x (- 1.0 (/ y a)))
(if (<= z 3.1e+38) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double t_2 = t - (t * (y / z));
double tmp;
if (z <= -5800000.0) {
tmp = t_2;
} else if (z <= -2.25e-238) {
tmp = t_1;
} else if (z <= 1.35e-304) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.1e+38) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t / (a / y))
t_2 = t - (t * (y / z))
if (z <= (-5800000.0d0)) then
tmp = t_2
else if (z <= (-2.25d-238)) then
tmp = t_1
else if (z <= 1.35d-304) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.1d+38) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double t_2 = t - (t * (y / z));
double tmp;
if (z <= -5800000.0) {
tmp = t_2;
} else if (z <= -2.25e-238) {
tmp = t_1;
} else if (z <= 1.35e-304) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.1e+38) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t / (a / y)) t_2 = t - (t * (y / z)) tmp = 0 if z <= -5800000.0: tmp = t_2 elif z <= -2.25e-238: tmp = t_1 elif z <= 1.35e-304: tmp = x * (1.0 - (y / a)) elif z <= 3.1e+38: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t / Float64(a / y))) t_2 = Float64(t - Float64(t * Float64(y / z))) tmp = 0.0 if (z <= -5800000.0) tmp = t_2; elseif (z <= -2.25e-238) tmp = t_1; elseif (z <= 1.35e-304) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.1e+38) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t / (a / y)); t_2 = t - (t * (y / z)); tmp = 0.0; if (z <= -5800000.0) tmp = t_2; elseif (z <= -2.25e-238) tmp = t_1; elseif (z <= 1.35e-304) tmp = x * (1.0 - (y / a)); elseif (z <= 3.1e+38) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t - N[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5800000.0], t$95$2, If[LessEqual[z, -2.25e-238], t$95$1, If[LessEqual[z, 1.35e-304], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.1e+38], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t}{\frac{a}{y}}\\
t_2 := t - t \cdot \frac{y}{z}\\
\mathbf{if}\;z \leq -5800000:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -2.25 \cdot 10^{-238}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.35 \cdot 10^{-304}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{+38}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -5.8e6 or 3.10000000000000018e38 < z Initial program 41.5%
associate-*l/70.3%
Simplified70.3%
Taylor expanded in z around inf 67.3%
associate--l+67.3%
associate-*r/67.3%
associate-*r/67.3%
div-sub67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
distribute-rgt-out--67.4%
mul-1-neg67.4%
unsub-neg67.4%
associate-/l*79.6%
Simplified79.6%
Taylor expanded in y around inf 64.0%
Taylor expanded in t around inf 52.5%
associate-/l*56.1%
Simplified56.1%
clear-num56.0%
associate-/r/56.1%
clear-num56.1%
Applied egg-rr56.1%
if -5.8e6 < z < -2.24999999999999998e-238 or 1.35000000000000005e-304 < z < 3.10000000000000018e38Initial program 90.4%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in t around inf 76.6%
associate-*r/78.6%
Simplified78.6%
Taylor expanded in a around inf 67.7%
associate-/l*69.8%
Simplified69.8%
Taylor expanded in y around inf 66.8%
if -2.24999999999999998e-238 < z < 1.35000000000000005e-304Initial program 86.6%
associate-*l/93.0%
Simplified93.0%
Taylor expanded in z around 0 93.0%
Taylor expanded in x around inf 93.0%
mul-1-neg93.0%
unsub-neg93.0%
Simplified93.0%
Final simplification63.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ t (/ a y)))) (t_2 (+ t (* y (/ x z)))))
(if (<= z -2.2e+14)
t_2
(if (<= z -2.7e-238)
t_1
(if (<= z 7.5e-293)
(* x (- 1.0 (/ y a)))
(if (<= z 3.15e+38) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double t_2 = t + (y * (x / z));
double tmp;
if (z <= -2.2e+14) {
tmp = t_2;
} else if (z <= -2.7e-238) {
tmp = t_1;
} else if (z <= 7.5e-293) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.15e+38) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x + (t / (a / y))
t_2 = t + (y * (x / z))
if (z <= (-2.2d+14)) then
tmp = t_2
else if (z <= (-2.7d-238)) then
tmp = t_1
else if (z <= 7.5d-293) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 3.15d+38) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double t_2 = t + (y * (x / z));
double tmp;
if (z <= -2.2e+14) {
tmp = t_2;
} else if (z <= -2.7e-238) {
tmp = t_1;
} else if (z <= 7.5e-293) {
tmp = x * (1.0 - (y / a));
} else if (z <= 3.15e+38) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t / (a / y)) t_2 = t + (y * (x / z)) tmp = 0 if z <= -2.2e+14: tmp = t_2 elif z <= -2.7e-238: tmp = t_1 elif z <= 7.5e-293: tmp = x * (1.0 - (y / a)) elif z <= 3.15e+38: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t / Float64(a / y))) t_2 = Float64(t + Float64(y * Float64(x / z))) tmp = 0.0 if (z <= -2.2e+14) tmp = t_2; elseif (z <= -2.7e-238) tmp = t_1; elseif (z <= 7.5e-293) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 3.15e+38) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t / (a / y)); t_2 = t + (y * (x / z)); tmp = 0.0; if (z <= -2.2e+14) tmp = t_2; elseif (z <= -2.7e-238) tmp = t_1; elseif (z <= 7.5e-293) tmp = x * (1.0 - (y / a)); elseif (z <= 3.15e+38) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.2e+14], t$95$2, If[LessEqual[z, -2.7e-238], t$95$1, If[LessEqual[z, 7.5e-293], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.15e+38], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t}{\frac{a}{y}}\\
t_2 := t + y \cdot \frac{x}{z}\\
\mathbf{if}\;z \leq -2.2 \cdot 10^{+14}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{-238}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 7.5 \cdot 10^{-293}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 3.15 \cdot 10^{+38}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -2.2e14 or 3.15000000000000001e38 < z Initial program 40.2%
associate-*l/69.2%
Simplified69.2%
Taylor expanded in z around inf 67.0%
associate--l+67.0%
associate-*r/67.0%
associate-*r/67.0%
div-sub67.0%
distribute-lft-out--67.0%
associate-*r/67.0%
distribute-rgt-out--67.1%
mul-1-neg67.1%
unsub-neg67.1%
associate-/l*79.7%
Simplified79.7%
Taylor expanded in y around inf 63.5%
Taylor expanded in t around 0 61.4%
mul-1-neg61.4%
associate-/l*64.9%
Simplified64.9%
associate-/r/64.2%
Applied egg-rr64.2%
if -2.2e14 < z < -2.69999999999999991e-238 or 7.50000000000000038e-293 < z < 3.15000000000000001e38Initial program 89.9%
associate-*l/92.6%
Simplified92.6%
Taylor expanded in t around inf 76.6%
associate-*r/78.5%
Simplified78.5%
Taylor expanded in a around inf 66.5%
associate-/l*68.6%
Simplified68.6%
Taylor expanded in y around inf 65.6%
if -2.69999999999999991e-238 < z < 7.50000000000000038e-293Initial program 86.6%
associate-*l/93.0%
Simplified93.0%
Taylor expanded in z around 0 93.0%
Taylor expanded in x around inf 93.0%
mul-1-neg93.0%
unsub-neg93.0%
Simplified93.0%
Final simplification66.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ t (/ a y)))))
(if (<= z -2.9e+14)
(+ t (* y (/ x z)))
(if (<= z -3.75e-238)
t_1
(if (<= z 1.02e-306)
(* x (- 1.0 (/ y a)))
(if (<= z 1.65e+37) t_1 (+ t (* x (/ y z)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double tmp;
if (z <= -2.9e+14) {
tmp = t + (y * (x / z));
} else if (z <= -3.75e-238) {
tmp = t_1;
} else if (z <= 1.02e-306) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.65e+37) {
tmp = t_1;
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (t / (a / y))
if (z <= (-2.9d+14)) then
tmp = t + (y * (x / z))
else if (z <= (-3.75d-238)) then
tmp = t_1
else if (z <= 1.02d-306) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 1.65d+37) then
tmp = t_1
else
tmp = t + (x * (y / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double tmp;
if (z <= -2.9e+14) {
tmp = t + (y * (x / z));
} else if (z <= -3.75e-238) {
tmp = t_1;
} else if (z <= 1.02e-306) {
tmp = x * (1.0 - (y / a));
} else if (z <= 1.65e+37) {
tmp = t_1;
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t / (a / y)) tmp = 0 if z <= -2.9e+14: tmp = t + (y * (x / z)) elif z <= -3.75e-238: tmp = t_1 elif z <= 1.02e-306: tmp = x * (1.0 - (y / a)) elif z <= 1.65e+37: tmp = t_1 else: tmp = t + (x * (y / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t / Float64(a / y))) tmp = 0.0 if (z <= -2.9e+14) tmp = Float64(t + Float64(y * Float64(x / z))); elseif (z <= -3.75e-238) tmp = t_1; elseif (z <= 1.02e-306) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 1.65e+37) tmp = t_1; else tmp = Float64(t + Float64(x * Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t / (a / y)); tmp = 0.0; if (z <= -2.9e+14) tmp = t + (y * (x / z)); elseif (z <= -3.75e-238) tmp = t_1; elseif (z <= 1.02e-306) tmp = x * (1.0 - (y / a)); elseif (z <= 1.65e+37) tmp = t_1; else tmp = t + (x * (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.9e+14], N[(t + N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.75e-238], t$95$1, If[LessEqual[z, 1.02e-306], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.65e+37], t$95$1, N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t}{\frac{a}{y}}\\
\mathbf{if}\;z \leq -2.9 \cdot 10^{+14}:\\
\;\;\;\;t + y \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq -3.75 \cdot 10^{-238}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.02 \cdot 10^{-306}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 1.65 \cdot 10^{+37}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if z < -2.9e14Initial program 45.7%
associate-*l/71.6%
Simplified71.6%
Taylor expanded in z around inf 63.7%
associate--l+63.7%
associate-*r/63.7%
associate-*r/63.7%
div-sub63.7%
distribute-lft-out--63.7%
associate-*r/63.7%
distribute-rgt-out--63.9%
mul-1-neg63.9%
unsub-neg63.9%
associate-/l*75.7%
Simplified75.7%
Taylor expanded in y around inf 62.7%
Taylor expanded in t around 0 59.6%
mul-1-neg59.6%
associate-/l*63.5%
Simplified63.5%
associate-/r/63.5%
Applied egg-rr63.5%
if -2.9e14 < z < -3.75000000000000031e-238 or 1.02e-306 < z < 1.65e37Initial program 89.9%
associate-*l/92.6%
Simplified92.6%
Taylor expanded in t around inf 76.6%
associate-*r/78.5%
Simplified78.5%
Taylor expanded in a around inf 66.5%
associate-/l*68.6%
Simplified68.6%
Taylor expanded in y around inf 65.6%
if -3.75000000000000031e-238 < z < 1.02e-306Initial program 86.6%
associate-*l/93.0%
Simplified93.0%
Taylor expanded in z around 0 93.0%
Taylor expanded in x around inf 93.0%
mul-1-neg93.0%
unsub-neg93.0%
Simplified93.0%
if 1.65e37 < z Initial program 35.4%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 69.8%
associate--l+69.8%
associate-*r/69.8%
associate-*r/69.8%
div-sub69.8%
distribute-lft-out--69.8%
associate-*r/69.8%
distribute-rgt-out--69.9%
mul-1-neg69.9%
unsub-neg69.9%
associate-/l*83.2%
Simplified83.2%
Taylor expanded in y around inf 64.3%
Taylor expanded in t around 0 63.0%
mul-1-neg63.0%
associate-/l*66.1%
Simplified66.1%
clear-num66.1%
associate-/r/66.1%
clear-num66.1%
Applied egg-rr66.1%
Final simplification66.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ t (/ a y)))))
(if (<= z -2.3e+14)
(- t (/ y (/ z (- x))))
(if (<= z -6.2e-238)
t_1
(if (<= z 1.1e-306)
(* x (- 1.0 (/ y a)))
(if (<= z 7.8e+38) t_1 (+ t (* x (/ y z)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double tmp;
if (z <= -2.3e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -6.2e-238) {
tmp = t_1;
} else if (z <= 1.1e-306) {
tmp = x * (1.0 - (y / a));
} else if (z <= 7.8e+38) {
tmp = t_1;
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (t / (a / y))
if (z <= (-2.3d+14)) then
tmp = t - (y / (z / -x))
else if (z <= (-6.2d-238)) then
tmp = t_1
else if (z <= 1.1d-306) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 7.8d+38) then
tmp = t_1
else
tmp = t + (x * (y / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double tmp;
if (z <= -2.3e+14) {
tmp = t - (y / (z / -x));
} else if (z <= -6.2e-238) {
tmp = t_1;
} else if (z <= 1.1e-306) {
tmp = x * (1.0 - (y / a));
} else if (z <= 7.8e+38) {
tmp = t_1;
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t / (a / y)) tmp = 0 if z <= -2.3e+14: tmp = t - (y / (z / -x)) elif z <= -6.2e-238: tmp = t_1 elif z <= 1.1e-306: tmp = x * (1.0 - (y / a)) elif z <= 7.8e+38: tmp = t_1 else: tmp = t + (x * (y / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t / Float64(a / y))) tmp = 0.0 if (z <= -2.3e+14) tmp = Float64(t - Float64(y / Float64(z / Float64(-x)))); elseif (z <= -6.2e-238) tmp = t_1; elseif (z <= 1.1e-306) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 7.8e+38) tmp = t_1; else tmp = Float64(t + Float64(x * Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t / (a / y)); tmp = 0.0; if (z <= -2.3e+14) tmp = t - (y / (z / -x)); elseif (z <= -6.2e-238) tmp = t_1; elseif (z <= 1.1e-306) tmp = x * (1.0 - (y / a)); elseif (z <= 7.8e+38) tmp = t_1; else tmp = t + (x * (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.3e+14], N[(t - N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -6.2e-238], t$95$1, If[LessEqual[z, 1.1e-306], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.8e+38], t$95$1, N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t}{\frac{a}{y}}\\
\mathbf{if}\;z \leq -2.3 \cdot 10^{+14}:\\
\;\;\;\;t - \frac{y}{\frac{z}{-x}}\\
\mathbf{elif}\;z \leq -6.2 \cdot 10^{-238}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-306}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 7.8 \cdot 10^{+38}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if z < -2.3e14Initial program 45.7%
associate-*l/71.6%
Simplified71.6%
Taylor expanded in z around inf 63.7%
associate--l+63.7%
associate-*r/63.7%
associate-*r/63.7%
div-sub63.7%
distribute-lft-out--63.7%
associate-*r/63.7%
distribute-rgt-out--63.9%
mul-1-neg63.9%
unsub-neg63.9%
associate-/l*75.7%
Simplified75.7%
Taylor expanded in y around inf 62.7%
Taylor expanded in t around 0 59.6%
associate-*r/59.6%
mul-1-neg59.6%
distribute-lft-neg-out59.6%
*-commutative59.6%
associate-/l*63.6%
Simplified63.6%
if -2.3e14 < z < -6.2000000000000002e-238 or 1.10000000000000008e-306 < z < 7.80000000000000047e38Initial program 89.9%
associate-*l/92.6%
Simplified92.6%
Taylor expanded in t around inf 76.6%
associate-*r/78.5%
Simplified78.5%
Taylor expanded in a around inf 66.5%
associate-/l*68.6%
Simplified68.6%
Taylor expanded in y around inf 65.6%
if -6.2000000000000002e-238 < z < 1.10000000000000008e-306Initial program 86.6%
associate-*l/93.0%
Simplified93.0%
Taylor expanded in z around 0 93.0%
Taylor expanded in x around inf 93.0%
mul-1-neg93.0%
unsub-neg93.0%
Simplified93.0%
if 7.80000000000000047e38 < z Initial program 35.4%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 69.8%
associate--l+69.8%
associate-*r/69.8%
associate-*r/69.8%
div-sub69.8%
distribute-lft-out--69.8%
associate-*r/69.8%
distribute-rgt-out--69.9%
mul-1-neg69.9%
unsub-neg69.9%
associate-/l*83.2%
Simplified83.2%
Taylor expanded in y around inf 64.3%
Taylor expanded in t around 0 63.0%
mul-1-neg63.0%
associate-/l*66.1%
Simplified66.1%
clear-num66.1%
associate-/r/66.1%
clear-num66.1%
Applied egg-rr66.1%
Final simplification66.8%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -3.7e-39) (not (<= z 2.8e+37))) (- t (/ (- t x) (/ z (- y a)))) (- x (/ (* y (- x t)) (- a z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -3.7e-39) || !(z <= 2.8e+37)) {
tmp = t - ((t - x) / (z / (y - a)));
} else {
tmp = x - ((y * (x - t)) / (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 <= (-3.7d-39)) .or. (.not. (z <= 2.8d+37))) then
tmp = t - ((t - x) / (z / (y - a)))
else
tmp = x - ((y * (x - t)) / (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 <= -3.7e-39) || !(z <= 2.8e+37)) {
tmp = t - ((t - x) / (z / (y - a)));
} else {
tmp = x - ((y * (x - t)) / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -3.7e-39) or not (z <= 2.8e+37): tmp = t - ((t - x) / (z / (y - a))) else: tmp = x - ((y * (x - t)) / (a - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -3.7e-39) || !(z <= 2.8e+37)) tmp = Float64(t - Float64(Float64(t - x) / Float64(z / Float64(y - a)))); else tmp = Float64(x - Float64(Float64(y * Float64(x - t)) / Float64(a - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -3.7e-39) || ~((z <= 2.8e+37))) tmp = t - ((t - x) / (z / (y - a))); else tmp = x - ((y * (x - t)) / (a - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -3.7e-39], N[Not[LessEqual[z, 2.8e+37]], $MachinePrecision]], N[(t - N[(N[(t - x), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.7 \cdot 10^{-39} \lor \neg \left(z \leq 2.8 \cdot 10^{+37}\right):\\
\;\;\;\;t - \frac{t - x}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y \cdot \left(x - t\right)}{a - z}\\
\end{array}
\end{array}
if z < -3.70000000000000015e-39 or 2.7999999999999998e37 < z Initial program 44.3%
associate-*l/70.9%
Simplified70.9%
Taylor expanded in z around inf 67.3%
associate--l+67.3%
associate-*r/67.3%
associate-*r/67.3%
div-sub67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
distribute-rgt-out--67.4%
mul-1-neg67.4%
unsub-neg67.4%
associate-/l*78.6%
Simplified78.6%
if -3.70000000000000015e-39 < z < 2.7999999999999998e37Initial program 90.8%
Taylor expanded in y around inf 84.4%
*-commutative84.4%
Simplified84.4%
Final simplification81.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.8e+14) t (if (<= z 2.25e+80) (* x (- 1.0 (/ y a))) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.8e+14) {
tmp = t;
} else if (z <= 2.25e+80) {
tmp = x * (1.0 - (y / a));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.8d+14)) then
tmp = t
else if (z <= 2.25d+80) then
tmp = x * (1.0d0 - (y / a))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.8e+14) {
tmp = t;
} else if (z <= 2.25e+80) {
tmp = x * (1.0 - (y / a));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.8e+14: tmp = t elif z <= 2.25e+80: tmp = x * (1.0 - (y / a)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.8e+14) tmp = t; elseif (z <= 2.25e+80) tmp = Float64(x * Float64(1.0 - Float64(y / a))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.8e+14) tmp = t; elseif (z <= 2.25e+80) tmp = x * (1.0 - (y / a)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.8e+14], t, If[LessEqual[z, 2.25e+80], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.8 \cdot 10^{+14}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{+80}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -2.8e14 or 2.25000000000000003e80 < z Initial program 37.9%
associate-*l/68.6%
Simplified68.6%
Taylor expanded in z around inf 53.6%
if -2.8e14 < z < 2.25000000000000003e80Initial program 87.9%
associate-*l/91.6%
Simplified91.6%
Taylor expanded in z around 0 71.7%
Taylor expanded in x around inf 51.0%
mul-1-neg51.0%
unsub-neg51.0%
Simplified51.0%
Final simplification52.0%
(FPCore (x y z t a) :precision binary64 (if (<= a -3.25e+28) x (if (<= a 1e-172) t (+ x t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.25e+28) {
tmp = x;
} else if (a <= 1e-172) {
tmp = t;
} else {
tmp = x + 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 (a <= (-3.25d+28)) then
tmp = x
else if (a <= 1d-172) then
tmp = t
else
tmp = x + t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.25e+28) {
tmp = x;
} else if (a <= 1e-172) {
tmp = t;
} else {
tmp = x + t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.25e+28: tmp = x elif a <= 1e-172: tmp = t else: tmp = x + t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.25e+28) tmp = x; elseif (a <= 1e-172) tmp = t; else tmp = Float64(x + t); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.25e+28) tmp = x; elseif (a <= 1e-172) tmp = t; else tmp = x + t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.25e+28], x, If[LessEqual[a, 1e-172], t, N[(x + t), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.25 \cdot 10^{+28}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 10^{-172}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x + t\\
\end{array}
\end{array}
if a < -3.25e28Initial program 73.1%
associate-*l/90.0%
Simplified90.0%
Taylor expanded in a around inf 51.1%
if -3.25e28 < a < 1e-172Initial program 64.6%
associate-*l/71.8%
Simplified71.8%
Taylor expanded in z around inf 42.1%
if 1e-172 < a Initial program 71.0%
associate-*l/89.4%
Simplified89.4%
Taylor expanded in t around inf 60.1%
associate-*r/72.8%
Simplified72.8%
Taylor expanded in z around inf 39.0%
Final simplification42.6%
(FPCore (x y z t a) :precision binary64 (if (<= a -7.2e+28) x (if (<= a 1.7e-46) t x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -7.2e+28) {
tmp = x;
} else if (a <= 1.7e-46) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-7.2d+28)) then
tmp = x
else if (a <= 1.7d-46) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -7.2e+28) {
tmp = x;
} else if (a <= 1.7e-46) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -7.2e+28: tmp = x elif a <= 1.7e-46: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -7.2e+28) tmp = x; elseif (a <= 1.7e-46) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -7.2e+28) tmp = x; elseif (a <= 1.7e-46) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -7.2e+28], x, If[LessEqual[a, 1.7e-46], t, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -7.2 \cdot 10^{+28}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.7 \cdot 10^{-46}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -7.1999999999999999e28 or 1.69999999999999998e-46 < a Initial program 73.3%
associate-*l/92.1%
Simplified92.1%
Taylor expanded in a around inf 46.1%
if -7.1999999999999999e28 < a < 1.69999999999999998e-46Initial program 64.5%
associate-*l/73.3%
Simplified73.3%
Taylor expanded in z around inf 38.5%
Final simplification42.4%
(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 69.0%
associate-*l/82.9%
Simplified82.9%
Taylor expanded in z around inf 25.5%
Final simplification25.5%
(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 2024031
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:invLinMap from Chart-1.5.3"
:precision binary64
:herbie-target
(if (< z -1.2536131056095036e+188) (- t (* (/ y z) (- t x))) (if (< z 4.446702369113811e+64) (+ x (/ (- y z) (/ (- a z) (- t x)))) (- t (* (/ y z) (- t x)))))
(+ x (/ (* (- y z) (- t x)) (- a z))))