
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 31 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- x t) (/ z (- y a)))))
(if (<= z -7.2e+177)
(+ (+ t (* (/ a (/ z (- t x))) (/ (- a y) z))) t_1)
(if (<= z 7.4e+243) (fma (/ (- y z) (- a z)) (- t x) x) (+ t t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (x - t) / (z / (y - a));
double tmp;
if (z <= -7.2e+177) {
tmp = (t + ((a / (z / (t - x))) * ((a - y) / z))) + t_1;
} else if (z <= 7.4e+243) {
tmp = fma(((y - z) / (a - z)), (t - x), x);
} else {
tmp = t + t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(x - t) / Float64(z / Float64(y - a))) tmp = 0.0 if (z <= -7.2e+177) tmp = Float64(Float64(t + Float64(Float64(a / Float64(z / Float64(t - x))) * Float64(Float64(a - y) / z))) + t_1); elseif (z <= 7.4e+243) tmp = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x); else tmp = Float64(t + t_1); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7.2e+177], N[(N[(t + N[(N[(a / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[z, 7.4e+243], N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], N[(t + t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{if}\;z \leq -7.2 \cdot 10^{+177}:\\
\;\;\;\;\left(t + \frac{a}{\frac{z}{t - x}} \cdot \frac{a - y}{z}\right) + t_1\\
\mathbf{elif}\;z \leq 7.4 \cdot 10^{+243}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t + t_1\\
\end{array}
\end{array}
if z < -7.20000000000000005e177Initial program 21.6%
associate-*l/57.9%
Simplified57.9%
Taylor expanded in z around -inf 55.6%
associate-+r+55.6%
mul-1-neg55.6%
distribute-rgt-out--55.5%
unsub-neg55.5%
Simplified96.4%
if -7.20000000000000005e177 < z < 7.4000000000000004e243Initial program 72.6%
+-commutative72.6%
associate-*l/87.8%
fma-def87.8%
Simplified87.8%
if 7.4000000000000004e243 < z Initial program 32.2%
associate-*l/55.8%
Simplified55.8%
Taylor expanded in z around inf 76.1%
associate--l+76.1%
associate-*r/76.1%
associate-*r/76.1%
div-sub76.1%
distribute-lft-out--76.1%
mul-1-neg76.1%
distribute-neg-frac76.1%
distribute-rgt-out--76.1%
unsub-neg76.1%
associate-/l*99.9%
Simplified99.9%
Final simplification89.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- x t) (/ z (- y a)))))
(if (<= z -8e+177)
(+ (+ t (* (/ a (/ z (- t x))) (/ (- a y) z))) t_1)
(if (<= z 8.5e+235) (+ x (/ (- t x) (/ (- a z) (- y z)))) (+ t t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (x - t) / (z / (y - a));
double tmp;
if (z <= -8e+177) {
tmp = (t + ((a / (z / (t - x))) * ((a - y) / z))) + t_1;
} else if (z <= 8.5e+235) {
tmp = x + ((t - x) / ((a - z) / (y - z)));
} else {
tmp = t + t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (x - t) / (z / (y - a))
if (z <= (-8d+177)) then
tmp = (t + ((a / (z / (t - x))) * ((a - y) / z))) + t_1
else if (z <= 8.5d+235) then
tmp = x + ((t - x) / ((a - z) / (y - z)))
else
tmp = t + t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (x - t) / (z / (y - a));
double tmp;
if (z <= -8e+177) {
tmp = (t + ((a / (z / (t - x))) * ((a - y) / z))) + t_1;
} else if (z <= 8.5e+235) {
tmp = x + ((t - x) / ((a - z) / (y - z)));
} else {
tmp = t + t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (x - t) / (z / (y - a)) tmp = 0 if z <= -8e+177: tmp = (t + ((a / (z / (t - x))) * ((a - y) / z))) + t_1 elif z <= 8.5e+235: tmp = x + ((t - x) / ((a - z) / (y - z))) else: tmp = t + t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(x - t) / Float64(z / Float64(y - a))) tmp = 0.0 if (z <= -8e+177) tmp = Float64(Float64(t + Float64(Float64(a / Float64(z / Float64(t - x))) * Float64(Float64(a - y) / z))) + t_1); elseif (z <= 8.5e+235) tmp = Float64(x + Float64(Float64(t - x) / Float64(Float64(a - z) / Float64(y - z)))); else tmp = Float64(t + t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (x - t) / (z / (y - a)); tmp = 0.0; if (z <= -8e+177) tmp = (t + ((a / (z / (t - x))) * ((a - y) / z))) + t_1; elseif (z <= 8.5e+235) tmp = x + ((t - x) / ((a - z) / (y - z))); else tmp = t + t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8e+177], N[(N[(t + N[(N[(a / N[(z / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[z, 8.5e+235], N[(x + N[(N[(t - x), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{if}\;z \leq -8 \cdot 10^{+177}:\\
\;\;\;\;\left(t + \frac{a}{\frac{z}{t - x}} \cdot \frac{a - y}{z}\right) + t_1\\
\mathbf{elif}\;z \leq 8.5 \cdot 10^{+235}:\\
\;\;\;\;x + \frac{t - x}{\frac{a - z}{y - z}}\\
\mathbf{else}:\\
\;\;\;\;t + t_1\\
\end{array}
\end{array}
if z < -8.0000000000000001e177Initial program 21.6%
associate-*l/57.9%
Simplified57.9%
Taylor expanded in z around -inf 55.6%
associate-+r+55.6%
mul-1-neg55.6%
distribute-rgt-out--55.5%
unsub-neg55.5%
Simplified96.4%
if -8.0000000000000001e177 < z < 8.50000000000000017e235Initial program 72.4%
+-commutative72.4%
associate-*l/87.6%
fma-def87.7%
Simplified87.7%
fma-udef87.6%
*-commutative87.6%
clear-num87.6%
un-div-inv87.6%
Applied egg-rr87.6%
if 8.50000000000000017e235 < z Initial program 41.9%
associate-*l/62.1%
Simplified62.1%
Taylor expanded in z around inf 79.5%
associate--l+79.5%
associate-*r/79.5%
associate-*r/79.5%
div-sub79.5%
distribute-lft-out--79.5%
mul-1-neg79.5%
distribute-neg-frac79.5%
distribute-rgt-out--79.5%
unsub-neg79.5%
associate-/l*99.8%
Simplified99.8%
Final simplification89.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t) (/ z (- y z))))
(t_2 (+ x (/ t (/ a y))))
(t_3 (* y (/ (- x) (- a z)))))
(if (<= a -6800000.0)
t_2
(if (<= a -2.4e-46)
t_1
(if (<= a -1.65e-155)
t_3
(if (<= a 5.8e-219)
t_1
(if (<= a 5.5e-148) t_3 (if (<= a 1.05e-41) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double t_2 = x + (t / (a / y));
double t_3 = y * (-x / (a - z));
double tmp;
if (a <= -6800000.0) {
tmp = t_2;
} else if (a <= -2.4e-46) {
tmp = t_1;
} else if (a <= -1.65e-155) {
tmp = t_3;
} else if (a <= 5.8e-219) {
tmp = t_1;
} else if (a <= 5.5e-148) {
tmp = t_3;
} else if (a <= 1.05e-41) {
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) :: t_3
real(8) :: tmp
t_1 = -t / (z / (y - z))
t_2 = x + (t / (a / y))
t_3 = y * (-x / (a - z))
if (a <= (-6800000.0d0)) then
tmp = t_2
else if (a <= (-2.4d-46)) then
tmp = t_1
else if (a <= (-1.65d-155)) then
tmp = t_3
else if (a <= 5.8d-219) then
tmp = t_1
else if (a <= 5.5d-148) then
tmp = t_3
else if (a <= 1.05d-41) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double t_2 = x + (t / (a / y));
double t_3 = y * (-x / (a - z));
double tmp;
if (a <= -6800000.0) {
tmp = t_2;
} else if (a <= -2.4e-46) {
tmp = t_1;
} else if (a <= -1.65e-155) {
tmp = t_3;
} else if (a <= 5.8e-219) {
tmp = t_1;
} else if (a <= 5.5e-148) {
tmp = t_3;
} else if (a <= 1.05e-41) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = -t / (z / (y - z)) t_2 = x + (t / (a / y)) t_3 = y * (-x / (a - z)) tmp = 0 if a <= -6800000.0: tmp = t_2 elif a <= -2.4e-46: tmp = t_1 elif a <= -1.65e-155: tmp = t_3 elif a <= 5.8e-219: tmp = t_1 elif a <= 5.5e-148: tmp = t_3 elif a <= 1.05e-41: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(-t) / Float64(z / Float64(y - z))) t_2 = Float64(x + Float64(t / Float64(a / y))) t_3 = Float64(y * Float64(Float64(-x) / Float64(a - z))) tmp = 0.0 if (a <= -6800000.0) tmp = t_2; elseif (a <= -2.4e-46) tmp = t_1; elseif (a <= -1.65e-155) tmp = t_3; elseif (a <= 5.8e-219) tmp = t_1; elseif (a <= 5.5e-148) tmp = t_3; elseif (a <= 1.05e-41) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = -t / (z / (y - z)); t_2 = x + (t / (a / y)); t_3 = y * (-x / (a - z)); tmp = 0.0; if (a <= -6800000.0) tmp = t_2; elseif (a <= -2.4e-46) tmp = t_1; elseif (a <= -1.65e-155) tmp = t_3; elseif (a <= 5.8e-219) tmp = t_1; elseif (a <= 5.5e-148) tmp = t_3; elseif (a <= 1.05e-41) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[((-t) / N[(z / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[((-x) / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6800000.0], t$95$2, If[LessEqual[a, -2.4e-46], t$95$1, If[LessEqual[a, -1.65e-155], t$95$3, If[LessEqual[a, 5.8e-219], t$95$1, If[LessEqual[a, 5.5e-148], t$95$3, If[LessEqual[a, 1.05e-41], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{-t}{\frac{z}{y - z}}\\
t_2 := x + \frac{t}{\frac{a}{y}}\\
t_3 := y \cdot \frac{-x}{a - z}\\
\mathbf{if}\;a \leq -6800000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -2.4 \cdot 10^{-46}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -1.65 \cdot 10^{-155}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 5.8 \cdot 10^{-219}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 5.5 \cdot 10^{-148}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 1.05 \cdot 10^{-41}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -6.8e6 or 1.05000000000000006e-41 < a Initial program 64.5%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in z around 0 54.6%
associate-/l*69.9%
Simplified69.9%
Taylor expanded in t around inf 53.0%
associate-/l*59.9%
Simplified59.9%
if -6.8e6 < a < -2.40000000000000013e-46 or -1.64999999999999993e-155 < a < 5.79999999999999968e-219 or 5.5000000000000003e-148 < a < 1.05000000000000006e-41Initial program 64.5%
+-commutative64.5%
associate-*l/75.8%
fma-def75.8%
Simplified75.8%
fma-udef75.8%
*-commutative75.8%
clear-num75.8%
un-div-inv75.8%
Applied egg-rr75.8%
Taylor expanded in t around -inf 57.5%
associate-/l*72.9%
Simplified72.9%
Taylor expanded in a around 0 52.2%
mul-1-neg52.2%
associate-/l*67.6%
distribute-neg-frac67.6%
Simplified67.6%
if -2.40000000000000013e-46 < a < -1.64999999999999993e-155 or 5.79999999999999968e-219 < a < 5.5000000000000003e-148Initial program 69.7%
associate-*l/71.7%
Simplified71.7%
Taylor expanded in y around inf 67.2%
div-sub67.2%
Simplified67.2%
Taylor expanded in t around 0 56.2%
associate-*r/56.2%
neg-mul-156.2%
Simplified56.2%
Final simplification62.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t) (/ z (- y z))))
(t_2 (+ x (/ t (/ a y))))
(t_3 (/ (- x) (/ (- a z) y))))
(if (<= a -2500000000.0)
t_2
(if (<= a -1.4e-45)
t_1
(if (<= a -2.3e-156)
t_3
(if (<= a 5.6e-219)
t_1
(if (<= a 5.5e-148) t_3 (if (<= a 9.2e-42) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double t_2 = x + (t / (a / y));
double t_3 = -x / ((a - z) / y);
double tmp;
if (a <= -2500000000.0) {
tmp = t_2;
} else if (a <= -1.4e-45) {
tmp = t_1;
} else if (a <= -2.3e-156) {
tmp = t_3;
} else if (a <= 5.6e-219) {
tmp = t_1;
} else if (a <= 5.5e-148) {
tmp = t_3;
} else if (a <= 9.2e-42) {
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) :: t_3
real(8) :: tmp
t_1 = -t / (z / (y - z))
t_2 = x + (t / (a / y))
t_3 = -x / ((a - z) / y)
if (a <= (-2500000000.0d0)) then
tmp = t_2
else if (a <= (-1.4d-45)) then
tmp = t_1
else if (a <= (-2.3d-156)) then
tmp = t_3
else if (a <= 5.6d-219) then
tmp = t_1
else if (a <= 5.5d-148) then
tmp = t_3
else if (a <= 9.2d-42) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = -t / (z / (y - z));
double t_2 = x + (t / (a / y));
double t_3 = -x / ((a - z) / y);
double tmp;
if (a <= -2500000000.0) {
tmp = t_2;
} else if (a <= -1.4e-45) {
tmp = t_1;
} else if (a <= -2.3e-156) {
tmp = t_3;
} else if (a <= 5.6e-219) {
tmp = t_1;
} else if (a <= 5.5e-148) {
tmp = t_3;
} else if (a <= 9.2e-42) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = -t / (z / (y - z)) t_2 = x + (t / (a / y)) t_3 = -x / ((a - z) / y) tmp = 0 if a <= -2500000000.0: tmp = t_2 elif a <= -1.4e-45: tmp = t_1 elif a <= -2.3e-156: tmp = t_3 elif a <= 5.6e-219: tmp = t_1 elif a <= 5.5e-148: tmp = t_3 elif a <= 9.2e-42: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(-t) / Float64(z / Float64(y - z))) t_2 = Float64(x + Float64(t / Float64(a / y))) t_3 = Float64(Float64(-x) / Float64(Float64(a - z) / y)) tmp = 0.0 if (a <= -2500000000.0) tmp = t_2; elseif (a <= -1.4e-45) tmp = t_1; elseif (a <= -2.3e-156) tmp = t_3; elseif (a <= 5.6e-219) tmp = t_1; elseif (a <= 5.5e-148) tmp = t_3; elseif (a <= 9.2e-42) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = -t / (z / (y - z)); t_2 = x + (t / (a / y)); t_3 = -x / ((a - z) / y); tmp = 0.0; if (a <= -2500000000.0) tmp = t_2; elseif (a <= -1.4e-45) tmp = t_1; elseif (a <= -2.3e-156) tmp = t_3; elseif (a <= 5.6e-219) tmp = t_1; elseif (a <= 5.5e-148) tmp = t_3; elseif (a <= 9.2e-42) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[((-t) / N[(z / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[((-x) / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2500000000.0], t$95$2, If[LessEqual[a, -1.4e-45], t$95$1, If[LessEqual[a, -2.3e-156], t$95$3, If[LessEqual[a, 5.6e-219], t$95$1, If[LessEqual[a, 5.5e-148], t$95$3, If[LessEqual[a, 9.2e-42], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{-t}{\frac{z}{y - z}}\\
t_2 := x + \frac{t}{\frac{a}{y}}\\
t_3 := \frac{-x}{\frac{a - z}{y}}\\
\mathbf{if}\;a \leq -2500000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -1.4 \cdot 10^{-45}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -2.3 \cdot 10^{-156}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-219}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 5.5 \cdot 10^{-148}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 9.2 \cdot 10^{-42}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -2.5e9 or 9.20000000000000015e-42 < a Initial program 64.5%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in z around 0 54.6%
associate-/l*69.9%
Simplified69.9%
Taylor expanded in t around inf 53.0%
associate-/l*59.9%
Simplified59.9%
if -2.5e9 < a < -1.4000000000000001e-45 or -2.3e-156 < a < 5.5999999999999998e-219 or 5.5000000000000003e-148 < a < 9.20000000000000015e-42Initial program 64.5%
+-commutative64.5%
associate-*l/75.8%
fma-def75.8%
Simplified75.8%
fma-udef75.8%
*-commutative75.8%
clear-num75.8%
un-div-inv75.8%
Applied egg-rr75.8%
Taylor expanded in t around -inf 57.5%
associate-/l*72.9%
Simplified72.9%
Taylor expanded in a around 0 52.2%
mul-1-neg52.2%
associate-/l*67.6%
distribute-neg-frac67.6%
Simplified67.6%
if -1.4000000000000001e-45 < a < -2.3e-156 or 5.5999999999999998e-219 < a < 5.5000000000000003e-148Initial program 69.7%
associate-*l/71.7%
Simplified71.7%
Taylor expanded in y around inf 67.2%
div-sub67.2%
Simplified67.2%
Taylor expanded in t around 0 51.5%
mul-1-neg51.5%
associate-/l*57.7%
distribute-neg-frac57.7%
Simplified57.7%
Final simplification62.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (- t x) (/ a (- y z))))))
(if (<= a -52000000.0)
t_1
(if (<= a 1.7e-220)
(* t (/ (- y z) (- a z)))
(if (<= a 1.3e-147)
(* y (/ (- t x) (- a z)))
(if (<= a 7.5e-49) (/ t (/ (- a z) (- y z))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) / (a / (y - z)));
double tmp;
if (a <= -52000000.0) {
tmp = t_1;
} else if (a <= 1.7e-220) {
tmp = t * ((y - z) / (a - z));
} else if (a <= 1.3e-147) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 7.5e-49) {
tmp = t / ((a - z) / (y - z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + ((t - x) / (a / (y - z)))
if (a <= (-52000000.0d0)) then
tmp = t_1
else if (a <= 1.7d-220) then
tmp = t * ((y - z) / (a - z))
else if (a <= 1.3d-147) then
tmp = y * ((t - x) / (a - z))
else if (a <= 7.5d-49) then
tmp = t / ((a - z) / (y - z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) / (a / (y - z)));
double tmp;
if (a <= -52000000.0) {
tmp = t_1;
} else if (a <= 1.7e-220) {
tmp = t * ((y - z) / (a - z));
} else if (a <= 1.3e-147) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 7.5e-49) {
tmp = t / ((a - z) / (y - z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((t - x) / (a / (y - z))) tmp = 0 if a <= -52000000.0: tmp = t_1 elif a <= 1.7e-220: tmp = t * ((y - z) / (a - z)) elif a <= 1.3e-147: tmp = y * ((t - x) / (a - z)) elif a <= 7.5e-49: tmp = t / ((a - z) / (y - z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(t - x) / Float64(a / Float64(y - z)))) tmp = 0.0 if (a <= -52000000.0) tmp = t_1; elseif (a <= 1.7e-220) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); elseif (a <= 1.3e-147) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= 7.5e-49) tmp = Float64(t / Float64(Float64(a - z) / Float64(y - z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((t - x) / (a / (y - z))); tmp = 0.0; if (a <= -52000000.0) tmp = t_1; elseif (a <= 1.7e-220) tmp = t * ((y - z) / (a - z)); elseif (a <= 1.3e-147) tmp = y * ((t - x) / (a - z)); elseif (a <= 7.5e-49) tmp = t / ((a - z) / (y - z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -52000000.0], t$95$1, If[LessEqual[a, 1.7e-220], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.3e-147], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.5e-49], N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t - x}{\frac{a}{y - z}}\\
\mathbf{if}\;a \leq -52000000:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.7 \cdot 10^{-220}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{elif}\;a \leq 1.3 \cdot 10^{-147}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 7.5 \cdot 10^{-49}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y - z}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -5.2e7 or 7.4999999999999998e-49 < a Initial program 65.0%
associate-*l/92.5%
Simplified92.5%
Taylor expanded in a around inf 58.8%
associate-/l*78.3%
Simplified78.3%
if -5.2e7 < a < 1.69999999999999997e-220Initial program 63.6%
associate-*l/71.9%
Simplified71.9%
Taylor expanded in x around 0 51.4%
associate-*r/64.0%
Simplified64.0%
if 1.69999999999999997e-220 < a < 1.2999999999999999e-147Initial program 75.2%
associate-*l/80.1%
Simplified80.1%
Taylor expanded in y around inf 77.1%
div-sub77.1%
Simplified77.1%
if 1.2999999999999999e-147 < a < 7.4999999999999998e-49Initial program 66.2%
+-commutative66.2%
associate-*l/78.0%
fma-def78.0%
Simplified78.0%
fma-udef78.0%
*-commutative78.0%
clear-num78.0%
un-div-inv78.0%
Applied egg-rr78.0%
Taylor expanded in t around -inf 58.4%
associate-/l*73.6%
Simplified73.6%
Final simplification72.8%
(FPCore (x y z t a)
:precision binary64
(if (<= y -6.8e+115)
(/ x (/ z y))
(if (<= y -1.95e-94)
t
(if (<= y -4.8e-163)
x
(if (<= y 1.7e-165)
t
(if (<= y 1.9e+215) (* x (/ (- y a) z)) (/ t (/ a y))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -6.8e+115) {
tmp = x / (z / y);
} else if (y <= -1.95e-94) {
tmp = t;
} else if (y <= -4.8e-163) {
tmp = x;
} else if (y <= 1.7e-165) {
tmp = t;
} else if (y <= 1.9e+215) {
tmp = x * ((y - a) / z);
} else {
tmp = t / (a / y);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (y <= (-6.8d+115)) then
tmp = x / (z / y)
else if (y <= (-1.95d-94)) then
tmp = t
else if (y <= (-4.8d-163)) then
tmp = x
else if (y <= 1.7d-165) then
tmp = t
else if (y <= 1.9d+215) then
tmp = x * ((y - a) / z)
else
tmp = t / (a / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -6.8e+115) {
tmp = x / (z / y);
} else if (y <= -1.95e-94) {
tmp = t;
} else if (y <= -4.8e-163) {
tmp = x;
} else if (y <= 1.7e-165) {
tmp = t;
} else if (y <= 1.9e+215) {
tmp = x * ((y - a) / z);
} else {
tmp = t / (a / y);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -6.8e+115: tmp = x / (z / y) elif y <= -1.95e-94: tmp = t elif y <= -4.8e-163: tmp = x elif y <= 1.7e-165: tmp = t elif y <= 1.9e+215: tmp = x * ((y - a) / z) else: tmp = t / (a / y) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -6.8e+115) tmp = Float64(x / Float64(z / y)); elseif (y <= -1.95e-94) tmp = t; elseif (y <= -4.8e-163) tmp = x; elseif (y <= 1.7e-165) tmp = t; elseif (y <= 1.9e+215) tmp = Float64(x * Float64(Float64(y - a) / z)); else tmp = Float64(t / Float64(a / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -6.8e+115) tmp = x / (z / y); elseif (y <= -1.95e-94) tmp = t; elseif (y <= -4.8e-163) tmp = x; elseif (y <= 1.7e-165) tmp = t; elseif (y <= 1.9e+215) tmp = x * ((y - a) / z); else tmp = t / (a / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -6.8e+115], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.95e-94], t, If[LessEqual[y, -4.8e-163], x, If[LessEqual[y, 1.7e-165], t, If[LessEqual[y, 1.9e+215], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.8 \cdot 10^{+115}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq -1.95 \cdot 10^{-94}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq -4.8 \cdot 10^{-163}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.7 \cdot 10^{-165}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{+215}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\end{array}
\end{array}
if y < -6.8000000000000001e115Initial program 61.0%
associate-*l/92.3%
Simplified92.3%
Taylor expanded in z around inf 44.3%
associate--l+44.3%
associate-*r/44.3%
associate-*r/44.3%
div-sub44.3%
distribute-lft-out--44.3%
mul-1-neg44.3%
distribute-neg-frac44.3%
distribute-rgt-out--44.7%
unsub-neg44.7%
associate-/l*62.8%
Simplified62.8%
Taylor expanded in t around 0 28.4%
associate-/l*41.9%
associate-/r/41.9%
Simplified41.9%
Taylor expanded in y around inf 28.5%
associate-/l*42.0%
Simplified42.0%
if -6.8000000000000001e115 < y < -1.9500000000000001e-94 or -4.8000000000000001e-163 < y < 1.7e-165Initial program 60.5%
associate-*l/78.3%
Simplified78.3%
Taylor expanded in z around inf 44.5%
if -1.9500000000000001e-94 < y < -4.8000000000000001e-163Initial program 87.1%
associate-*l/87.1%
Simplified87.1%
Taylor expanded in a around inf 80.5%
if 1.7e-165 < y < 1.89999999999999984e215Initial program 69.4%
associate-*l/82.3%
Simplified82.3%
Taylor expanded in z around inf 44.8%
associate--l+44.8%
associate-*r/44.8%
associate-*r/44.8%
div-sub44.9%
distribute-lft-out--44.9%
mul-1-neg44.9%
distribute-neg-frac44.9%
distribute-rgt-out--46.4%
unsub-neg46.4%
associate-/l*56.0%
Simplified56.0%
Taylor expanded in t around 0 29.4%
associate-/l*34.6%
associate-/r/34.6%
Simplified34.6%
Taylor expanded in x around 0 29.4%
associate-*r/34.6%
Simplified34.6%
if 1.89999999999999984e215 < y Initial program 67.3%
+-commutative67.3%
associate-*l/87.6%
fma-def87.6%
Simplified87.6%
fma-udef87.6%
*-commutative87.6%
clear-num87.3%
un-div-inv87.4%
Applied egg-rr87.4%
Taylor expanded in t around -inf 46.0%
associate-/l*58.0%
Simplified58.0%
Taylor expanded in z around 0 49.7%
Final simplification43.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t x) a))))
(if (<= z -3.05e-15)
(* (- y a) (/ x z))
(if (<= z -6.5e-173)
t_1
(if (<= z -2.75e-288)
x
(if (<= z 0.00019) t_1 (if (<= z 7e+75) x (+ t (/ a (/ z t))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / a);
double tmp;
if (z <= -3.05e-15) {
tmp = (y - a) * (x / z);
} else if (z <= -6.5e-173) {
tmp = t_1;
} else if (z <= -2.75e-288) {
tmp = x;
} else if (z <= 0.00019) {
tmp = t_1;
} else if (z <= 7e+75) {
tmp = x;
} else {
tmp = t + (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) :: t_1
real(8) :: tmp
t_1 = y * ((t - x) / a)
if (z <= (-3.05d-15)) then
tmp = (y - a) * (x / z)
else if (z <= (-6.5d-173)) then
tmp = t_1
else if (z <= (-2.75d-288)) then
tmp = x
else if (z <= 0.00019d0) then
tmp = t_1
else if (z <= 7d+75) then
tmp = x
else
tmp = t + (a / (z / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / a);
double tmp;
if (z <= -3.05e-15) {
tmp = (y - a) * (x / z);
} else if (z <= -6.5e-173) {
tmp = t_1;
} else if (z <= -2.75e-288) {
tmp = x;
} else if (z <= 0.00019) {
tmp = t_1;
} else if (z <= 7e+75) {
tmp = x;
} else {
tmp = t + (a / (z / t));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - x) / a) tmp = 0 if z <= -3.05e-15: tmp = (y - a) * (x / z) elif z <= -6.5e-173: tmp = t_1 elif z <= -2.75e-288: tmp = x elif z <= 0.00019: tmp = t_1 elif z <= 7e+75: tmp = x else: tmp = t + (a / (z / t)) return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - x) / a)) tmp = 0.0 if (z <= -3.05e-15) tmp = Float64(Float64(y - a) * Float64(x / z)); elseif (z <= -6.5e-173) tmp = t_1; elseif (z <= -2.75e-288) tmp = x; elseif (z <= 0.00019) tmp = t_1; elseif (z <= 7e+75) tmp = x; else tmp = Float64(t + Float64(a / Float64(z / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - x) / a); tmp = 0.0; if (z <= -3.05e-15) tmp = (y - a) * (x / z); elseif (z <= -6.5e-173) tmp = t_1; elseif (z <= -2.75e-288) tmp = x; elseif (z <= 0.00019) tmp = t_1; elseif (z <= 7e+75) tmp = x; else tmp = t + (a / (z / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.05e-15], N[(N[(y - a), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -6.5e-173], t$95$1, If[LessEqual[z, -2.75e-288], x, If[LessEqual[z, 0.00019], t$95$1, If[LessEqual[z, 7e+75], x, N[(t + N[(a / N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - x}{a}\\
\mathbf{if}\;z \leq -3.05 \cdot 10^{-15}:\\
\;\;\;\;\left(y - a\right) \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq -6.5 \cdot 10^{-173}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -2.75 \cdot 10^{-288}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 0.00019:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 7 \cdot 10^{+75}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t + \frac{a}{\frac{z}{t}}\\
\end{array}
\end{array}
if z < -3.04999999999999986e-15Initial program 42.3%
associate-*l/72.3%
Simplified72.3%
Taylor expanded in z around inf 57.5%
associate--l+57.5%
associate-*r/57.5%
associate-*r/57.5%
div-sub57.5%
distribute-lft-out--57.5%
mul-1-neg57.5%
distribute-neg-frac57.5%
distribute-rgt-out--57.6%
unsub-neg57.6%
associate-/l*71.5%
Simplified71.5%
Taylor expanded in t around 0 27.0%
associate-/l*37.2%
associate-/r/38.4%
Simplified38.4%
if -3.04999999999999986e-15 < z < -6.4999999999999995e-173 or -2.75e-288 < z < 1.9000000000000001e-4Initial program 84.8%
associate-*l/93.5%
Simplified93.5%
Taylor expanded in y around inf 66.4%
div-sub66.4%
Simplified66.4%
Taylor expanded in a around inf 52.4%
if -6.4999999999999995e-173 < z < -2.75e-288 or 1.9000000000000001e-4 < z < 6.9999999999999997e75Initial program 78.0%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in a around inf 45.5%
if 6.9999999999999997e75 < z Initial program 53.6%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 65.2%
associate--l+65.2%
associate-*r/65.2%
associate-*r/65.2%
div-sub65.2%
distribute-lft-out--65.2%
mul-1-neg65.2%
distribute-neg-frac65.2%
distribute-rgt-out--65.2%
unsub-neg65.2%
associate-/l*80.4%
Simplified80.4%
Taylor expanded in y around 0 57.2%
associate-*r/57.2%
neg-mul-157.2%
Simplified57.2%
Taylor expanded in x around 0 51.5%
sub-neg51.5%
mul-1-neg51.5%
remove-double-neg51.5%
associate-/l*53.5%
Simplified53.5%
Final simplification47.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (/ a (/ z x)))) (t_2 (+ x (/ t (/ a y)))))
(if (<= z -4e+151)
t_1
(if (<= z -33000000000000.0)
(* (/ x z) (- y a))
(if (<= z 6.5e-89)
t_2
(if (<= z 2.5e+60)
(- x (* y (/ x a)))
(if (<= z 4.6e+76) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double t_2 = x + (t / (a / y));
double tmp;
if (z <= -4e+151) {
tmp = t_1;
} else if (z <= -33000000000000.0) {
tmp = (x / z) * (y - a);
} else if (z <= 6.5e-89) {
tmp = t_2;
} else if (z <= 2.5e+60) {
tmp = x - (y * (x / a));
} else if (z <= 4.6e+76) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t - (a / (z / x))
t_2 = x + (t / (a / y))
if (z <= (-4d+151)) then
tmp = t_1
else if (z <= (-33000000000000.0d0)) then
tmp = (x / z) * (y - a)
else if (z <= 6.5d-89) then
tmp = t_2
else if (z <= 2.5d+60) then
tmp = x - (y * (x / a))
else if (z <= 4.6d+76) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double t_2 = x + (t / (a / y));
double tmp;
if (z <= -4e+151) {
tmp = t_1;
} else if (z <= -33000000000000.0) {
tmp = (x / z) * (y - a);
} else if (z <= 6.5e-89) {
tmp = t_2;
} else if (z <= 2.5e+60) {
tmp = x - (y * (x / a));
} else if (z <= 4.6e+76) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a / (z / x)) t_2 = x + (t / (a / y)) tmp = 0 if z <= -4e+151: tmp = t_1 elif z <= -33000000000000.0: tmp = (x / z) * (y - a) elif z <= 6.5e-89: tmp = t_2 elif z <= 2.5e+60: tmp = x - (y * (x / a)) elif z <= 4.6e+76: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a / Float64(z / x))) t_2 = Float64(x + Float64(t / Float64(a / y))) tmp = 0.0 if (z <= -4e+151) tmp = t_1; elseif (z <= -33000000000000.0) tmp = Float64(Float64(x / z) * Float64(y - a)); elseif (z <= 6.5e-89) tmp = t_2; elseif (z <= 2.5e+60) tmp = Float64(x - Float64(y * Float64(x / a))); elseif (z <= 4.6e+76) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a / (z / x)); t_2 = x + (t / (a / y)); tmp = 0.0; if (z <= -4e+151) tmp = t_1; elseif (z <= -33000000000000.0) tmp = (x / z) * (y - a); elseif (z <= 6.5e-89) tmp = t_2; elseif (z <= 2.5e+60) tmp = x - (y * (x / a)); elseif (z <= 4.6e+76) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4e+151], t$95$1, If[LessEqual[z, -33000000000000.0], N[(N[(x / z), $MachinePrecision] * N[(y - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.5e-89], t$95$2, If[LessEqual[z, 2.5e+60], N[(x - N[(y * N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.6e+76], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{a}{\frac{z}{x}}\\
t_2 := x + \frac{t}{\frac{a}{y}}\\
\mathbf{if}\;z \leq -4 \cdot 10^{+151}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -33000000000000:\\
\;\;\;\;\frac{x}{z} \cdot \left(y - a\right)\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{-89}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{+60}:\\
\;\;\;\;x - y \cdot \frac{x}{a}\\
\mathbf{elif}\;z \leq 4.6 \cdot 10^{+76}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -4.00000000000000007e151 or 4.60000000000000002e76 < z Initial program 42.0%
associate-*l/69.6%
Simplified69.6%
Taylor expanded in z around inf 65.6%
associate--l+65.6%
associate-*r/65.6%
associate-*r/65.6%
div-sub65.6%
distribute-lft-out--65.6%
mul-1-neg65.6%
distribute-neg-frac65.6%
distribute-rgt-out--65.6%
unsub-neg65.6%
associate-/l*83.3%
Simplified83.3%
Taylor expanded in y around 0 59.2%
associate-*r/59.2%
neg-mul-159.2%
Simplified59.2%
Taylor expanded in t around 0 57.3%
associate-/l*59.1%
Simplified59.1%
if -4.00000000000000007e151 < z < -3.3e13Initial program 49.4%
associate-*l/78.3%
Simplified78.3%
Taylor expanded in z around inf 53.1%
associate--l+53.1%
associate-*r/53.1%
associate-*r/53.1%
div-sub53.1%
distribute-lft-out--53.1%
mul-1-neg53.1%
distribute-neg-frac53.1%
distribute-rgt-out--53.1%
unsub-neg53.1%
associate-/l*63.0%
Simplified63.0%
Taylor expanded in t around 0 36.8%
associate-/l*40.4%
associate-/r/40.4%
Simplified40.4%
if -3.3e13 < z < 6.50000000000000034e-89 or 2.49999999999999987e60 < z < 4.60000000000000002e76Initial program 86.4%
associate-*l/95.0%
Simplified95.0%
Taylor expanded in z around 0 67.1%
associate-/l*75.6%
Simplified75.6%
Taylor expanded in t around inf 55.2%
associate-/l*62.7%
Simplified62.7%
if 6.50000000000000034e-89 < z < 2.49999999999999987e60Initial program 68.3%
associate-*l/82.1%
Simplified82.1%
Taylor expanded in z around 0 39.1%
associate-/l*50.3%
Simplified50.3%
Taylor expanded in t around 0 39.0%
mul-1-neg39.0%
associate-/l*49.7%
distribute-neg-frac49.7%
Simplified49.7%
add-sqr-sqrt28.1%
fma-def28.1%
distribute-frac-neg28.1%
add-sqr-sqrt28.1%
sqrt-unprod19.4%
sqr-neg19.4%
sqrt-unprod0.0%
add-sqr-sqrt15.8%
fma-neg15.8%
add-sqr-sqrt34.6%
associate-/r/32.1%
add-sqr-sqrt16.2%
sqrt-unprod32.7%
sqr-neg32.7%
sqrt-unprod28.0%
add-sqr-sqrt49.7%
Applied egg-rr49.7%
Final simplification57.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (/ a (/ z x)))))
(if (<= z -1e+151)
t_1
(if (<= z -60000000000000.0)
(* (/ x z) (- y a))
(if (<= z 8e-92)
(+ x (/ t (/ a y)))
(if (<= z 9.6e+47)
(- x (* y (/ x a)))
(if (<= z 2.2e+73) (/ t (/ (- a z) y)) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -1e+151) {
tmp = t_1;
} else if (z <= -60000000000000.0) {
tmp = (x / z) * (y - a);
} else if (z <= 8e-92) {
tmp = x + (t / (a / y));
} else if (z <= 9.6e+47) {
tmp = x - (y * (x / a));
} else if (z <= 2.2e+73) {
tmp = t / ((a - z) / y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t - (a / (z / x))
if (z <= (-1d+151)) then
tmp = t_1
else if (z <= (-60000000000000.0d0)) then
tmp = (x / z) * (y - a)
else if (z <= 8d-92) then
tmp = x + (t / (a / y))
else if (z <= 9.6d+47) then
tmp = x - (y * (x / a))
else if (z <= 2.2d+73) then
tmp = t / ((a - z) / y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -1e+151) {
tmp = t_1;
} else if (z <= -60000000000000.0) {
tmp = (x / z) * (y - a);
} else if (z <= 8e-92) {
tmp = x + (t / (a / y));
} else if (z <= 9.6e+47) {
tmp = x - (y * (x / a));
} else if (z <= 2.2e+73) {
tmp = t / ((a - z) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a / (z / x)) tmp = 0 if z <= -1e+151: tmp = t_1 elif z <= -60000000000000.0: tmp = (x / z) * (y - a) elif z <= 8e-92: tmp = x + (t / (a / y)) elif z <= 9.6e+47: tmp = x - (y * (x / a)) elif z <= 2.2e+73: tmp = t / ((a - z) / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a / Float64(z / x))) tmp = 0.0 if (z <= -1e+151) tmp = t_1; elseif (z <= -60000000000000.0) tmp = Float64(Float64(x / z) * Float64(y - a)); elseif (z <= 8e-92) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 9.6e+47) tmp = Float64(x - Float64(y * Float64(x / a))); elseif (z <= 2.2e+73) tmp = Float64(t / Float64(Float64(a - z) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a / (z / x)); tmp = 0.0; if (z <= -1e+151) tmp = t_1; elseif (z <= -60000000000000.0) tmp = (x / z) * (y - a); elseif (z <= 8e-92) tmp = x + (t / (a / y)); elseif (z <= 9.6e+47) tmp = x - (y * (x / a)); elseif (z <= 2.2e+73) tmp = t / ((a - z) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1e+151], t$95$1, If[LessEqual[z, -60000000000000.0], N[(N[(x / z), $MachinePrecision] * N[(y - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8e-92], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9.6e+47], N[(x - N[(y * N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.2e+73], N[(t / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{a}{\frac{z}{x}}\\
\mathbf{if}\;z \leq -1 \cdot 10^{+151}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -60000000000000:\\
\;\;\;\;\frac{x}{z} \cdot \left(y - a\right)\\
\mathbf{elif}\;z \leq 8 \cdot 10^{-92}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 9.6 \cdot 10^{+47}:\\
\;\;\;\;x - y \cdot \frac{x}{a}\\
\mathbf{elif}\;z \leq 2.2 \cdot 10^{+73}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.00000000000000002e151 or 2.2e73 < z Initial program 42.0%
associate-*l/69.6%
Simplified69.6%
Taylor expanded in z around inf 65.6%
associate--l+65.6%
associate-*r/65.6%
associate-*r/65.6%
div-sub65.6%
distribute-lft-out--65.6%
mul-1-neg65.6%
distribute-neg-frac65.6%
distribute-rgt-out--65.6%
unsub-neg65.6%
associate-/l*83.3%
Simplified83.3%
Taylor expanded in y around 0 59.2%
associate-*r/59.2%
neg-mul-159.2%
Simplified59.2%
Taylor expanded in t around 0 57.3%
associate-/l*59.1%
Simplified59.1%
if -1.00000000000000002e151 < z < -6e13Initial program 49.4%
associate-*l/78.3%
Simplified78.3%
Taylor expanded in z around inf 53.1%
associate--l+53.1%
associate-*r/53.1%
associate-*r/53.1%
div-sub53.1%
distribute-lft-out--53.1%
mul-1-neg53.1%
distribute-neg-frac53.1%
distribute-rgt-out--53.1%
unsub-neg53.1%
associate-/l*63.0%
Simplified63.0%
Taylor expanded in t around 0 36.8%
associate-/l*40.4%
associate-/r/40.4%
Simplified40.4%
if -6e13 < z < 7.9999999999999999e-92Initial program 86.6%
associate-*l/94.8%
Simplified94.8%
Taylor expanded in z around 0 66.5%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in t around inf 54.0%
associate-/l*61.9%
Simplified61.9%
if 7.9999999999999999e-92 < z < 9.60000000000000075e47Initial program 71.3%
associate-*l/83.5%
Simplified83.5%
Taylor expanded in z around 0 42.9%
associate-/l*55.3%
Simplified55.3%
Taylor expanded in t around 0 42.5%
mul-1-neg42.5%
associate-/l*54.3%
distribute-neg-frac54.3%
Simplified54.3%
add-sqr-sqrt30.9%
fma-def30.9%
distribute-frac-neg30.9%
add-sqr-sqrt30.9%
sqrt-unprod21.4%
sqr-neg21.4%
sqrt-unprod0.0%
add-sqr-sqrt17.4%
fma-neg17.4%
add-sqr-sqrt34.7%
associate-/r/34.6%
add-sqr-sqrt17.2%
sqrt-unprod35.3%
sqr-neg35.3%
sqrt-unprod30.8%
add-sqr-sqrt54.3%
Applied egg-rr54.3%
if 9.60000000000000075e47 < z < 2.2e73Initial program 65.3%
associate-*l/87.9%
Simplified87.9%
Taylor expanded in y around inf 52.4%
div-sub52.4%
Simplified52.4%
Taylor expanded in t around inf 40.4%
associate-/l*51.8%
Simplified51.8%
Final simplification57.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (/ a (/ z x)))))
(if (<= z -1.8e+150)
t_1
(if (<= z -58000000000000.0)
(* (/ x z) (- y a))
(if (<= z 8.2e-88)
(+ x (/ t (/ a y)))
(if (<= z 3.2e+49)
(* x (- 1.0 (/ y a)))
(if (<= z 4.8e+72) (/ t (/ (- a z) y)) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -1.8e+150) {
tmp = t_1;
} else if (z <= -58000000000000.0) {
tmp = (x / z) * (y - a);
} else if (z <= 8.2e-88) {
tmp = x + (t / (a / y));
} else if (z <= 3.2e+49) {
tmp = x * (1.0 - (y / a));
} else if (z <= 4.8e+72) {
tmp = t / ((a - z) / y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t - (a / (z / x))
if (z <= (-1.8d+150)) then
tmp = t_1
else if (z <= (-58000000000000.0d0)) then
tmp = (x / z) * (y - a)
else if (z <= 8.2d-88) then
tmp = x + (t / (a / y))
else if (z <= 3.2d+49) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 4.8d+72) then
tmp = t / ((a - z) / y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -1.8e+150) {
tmp = t_1;
} else if (z <= -58000000000000.0) {
tmp = (x / z) * (y - a);
} else if (z <= 8.2e-88) {
tmp = x + (t / (a / y));
} else if (z <= 3.2e+49) {
tmp = x * (1.0 - (y / a));
} else if (z <= 4.8e+72) {
tmp = t / ((a - z) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a / (z / x)) tmp = 0 if z <= -1.8e+150: tmp = t_1 elif z <= -58000000000000.0: tmp = (x / z) * (y - a) elif z <= 8.2e-88: tmp = x + (t / (a / y)) elif z <= 3.2e+49: tmp = x * (1.0 - (y / a)) elif z <= 4.8e+72: tmp = t / ((a - z) / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a / Float64(z / x))) tmp = 0.0 if (z <= -1.8e+150) tmp = t_1; elseif (z <= -58000000000000.0) tmp = Float64(Float64(x / z) * Float64(y - a)); elseif (z <= 8.2e-88) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 3.2e+49) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 4.8e+72) tmp = Float64(t / Float64(Float64(a - z) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a / (z / x)); tmp = 0.0; if (z <= -1.8e+150) tmp = t_1; elseif (z <= -58000000000000.0) tmp = (x / z) * (y - a); elseif (z <= 8.2e-88) tmp = x + (t / (a / y)); elseif (z <= 3.2e+49) tmp = x * (1.0 - (y / a)); elseif (z <= 4.8e+72) tmp = t / ((a - z) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.8e+150], t$95$1, If[LessEqual[z, -58000000000000.0], N[(N[(x / z), $MachinePrecision] * N[(y - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.2e-88], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e+49], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.8e+72], N[(t / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{a}{\frac{z}{x}}\\
\mathbf{if}\;z \leq -1.8 \cdot 10^{+150}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -58000000000000:\\
\;\;\;\;\frac{x}{z} \cdot \left(y - a\right)\\
\mathbf{elif}\;z \leq 8.2 \cdot 10^{-88}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+49}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 4.8 \cdot 10^{+72}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.79999999999999993e150 or 4.8000000000000002e72 < z Initial program 42.0%
associate-*l/69.6%
Simplified69.6%
Taylor expanded in z around inf 65.6%
associate--l+65.6%
associate-*r/65.6%
associate-*r/65.6%
div-sub65.6%
distribute-lft-out--65.6%
mul-1-neg65.6%
distribute-neg-frac65.6%
distribute-rgt-out--65.6%
unsub-neg65.6%
associate-/l*83.3%
Simplified83.3%
Taylor expanded in y around 0 59.2%
associate-*r/59.2%
neg-mul-159.2%
Simplified59.2%
Taylor expanded in t around 0 57.3%
associate-/l*59.1%
Simplified59.1%
if -1.79999999999999993e150 < z < -5.8e13Initial program 49.4%
associate-*l/78.3%
Simplified78.3%
Taylor expanded in z around inf 53.1%
associate--l+53.1%
associate-*r/53.1%
associate-*r/53.1%
div-sub53.1%
distribute-lft-out--53.1%
mul-1-neg53.1%
distribute-neg-frac53.1%
distribute-rgt-out--53.1%
unsub-neg53.1%
associate-/l*63.0%
Simplified63.0%
Taylor expanded in t around 0 36.8%
associate-/l*40.4%
associate-/r/40.4%
Simplified40.4%
if -5.8e13 < z < 8.2000000000000002e-88Initial program 86.6%
associate-*l/94.8%
Simplified94.8%
Taylor expanded in z around 0 66.5%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in t around inf 54.0%
associate-/l*61.9%
Simplified61.9%
if 8.2000000000000002e-88 < z < 3.20000000000000014e49Initial program 71.3%
associate-*l/83.5%
Simplified83.5%
Taylor expanded in z around 0 42.9%
associate-/l*55.3%
Simplified55.3%
Taylor expanded in t around 0 42.5%
mul-1-neg42.5%
associate-/l*54.3%
distribute-neg-frac54.3%
Simplified54.3%
Taylor expanded in x around 0 54.3%
associate-*r/54.3%
neg-mul-154.3%
Simplified54.3%
if 3.20000000000000014e49 < z < 4.8000000000000002e72Initial program 65.3%
associate-*l/87.9%
Simplified87.9%
Taylor expanded in y around inf 52.4%
div-sub52.4%
Simplified52.4%
Taylor expanded in t around inf 40.4%
associate-/l*51.8%
Simplified51.8%
Final simplification57.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (/ a (/ z x)))))
(if (<= z -5.5e+123)
t_1
(if (<= z -13000000000000.0)
(* y (/ (- x) (- a z)))
(if (<= z 1.7e-88)
(+ x (/ t (/ a y)))
(if (<= z 1.95e+48)
(* x (- 1.0 (/ y a)))
(if (<= z 6.4e+72) (/ t (/ (- a z) y)) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -5.5e+123) {
tmp = t_1;
} else if (z <= -13000000000000.0) {
tmp = y * (-x / (a - z));
} else if (z <= 1.7e-88) {
tmp = x + (t / (a / y));
} else if (z <= 1.95e+48) {
tmp = x * (1.0 - (y / a));
} else if (z <= 6.4e+72) {
tmp = t / ((a - z) / y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t - (a / (z / x))
if (z <= (-5.5d+123)) then
tmp = t_1
else if (z <= (-13000000000000.0d0)) then
tmp = y * (-x / (a - z))
else if (z <= 1.7d-88) then
tmp = x + (t / (a / y))
else if (z <= 1.95d+48) then
tmp = x * (1.0d0 - (y / a))
else if (z <= 6.4d+72) then
tmp = t / ((a - z) / y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -5.5e+123) {
tmp = t_1;
} else if (z <= -13000000000000.0) {
tmp = y * (-x / (a - z));
} else if (z <= 1.7e-88) {
tmp = x + (t / (a / y));
} else if (z <= 1.95e+48) {
tmp = x * (1.0 - (y / a));
} else if (z <= 6.4e+72) {
tmp = t / ((a - z) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a / (z / x)) tmp = 0 if z <= -5.5e+123: tmp = t_1 elif z <= -13000000000000.0: tmp = y * (-x / (a - z)) elif z <= 1.7e-88: tmp = x + (t / (a / y)) elif z <= 1.95e+48: tmp = x * (1.0 - (y / a)) elif z <= 6.4e+72: tmp = t / ((a - z) / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a / Float64(z / x))) tmp = 0.0 if (z <= -5.5e+123) tmp = t_1; elseif (z <= -13000000000000.0) tmp = Float64(y * Float64(Float64(-x) / Float64(a - z))); elseif (z <= 1.7e-88) tmp = Float64(x + Float64(t / Float64(a / y))); elseif (z <= 1.95e+48) tmp = Float64(x * Float64(1.0 - Float64(y / a))); elseif (z <= 6.4e+72) tmp = Float64(t / Float64(Float64(a - z) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a / (z / x)); tmp = 0.0; if (z <= -5.5e+123) tmp = t_1; elseif (z <= -13000000000000.0) tmp = y * (-x / (a - z)); elseif (z <= 1.7e-88) tmp = x + (t / (a / y)); elseif (z <= 1.95e+48) tmp = x * (1.0 - (y / a)); elseif (z <= 6.4e+72) tmp = t / ((a - z) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.5e+123], t$95$1, If[LessEqual[z, -13000000000000.0], N[(y * N[((-x) / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.7e-88], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.95e+48], N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.4e+72], N[(t / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{a}{\frac{z}{x}}\\
\mathbf{if}\;z \leq -5.5 \cdot 10^{+123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -13000000000000:\\
\;\;\;\;y \cdot \frac{-x}{a - z}\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{-88}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;z \leq 1.95 \cdot 10^{+48}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{elif}\;z \leq 6.4 \cdot 10^{+72}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -5.5000000000000002e123 or 6.4000000000000003e72 < z Initial program 41.9%
associate-*l/70.1%
Simplified70.1%
Taylor expanded in z around inf 64.4%
associate--l+64.4%
associate-*r/64.4%
associate-*r/64.4%
div-sub64.4%
distribute-lft-out--64.4%
mul-1-neg64.4%
distribute-neg-frac64.4%
distribute-rgt-out--64.4%
unsub-neg64.4%
associate-/l*81.6%
Simplified81.6%
Taylor expanded in y around 0 56.5%
associate-*r/56.5%
neg-mul-156.5%
Simplified56.5%
Taylor expanded in t around 0 54.9%
associate-/l*56.5%
Simplified56.5%
if -5.5000000000000002e123 < z < -1.3e13Initial program 52.9%
associate-*l/79.4%
Simplified79.4%
Taylor expanded in y around inf 58.5%
div-sub58.5%
Simplified58.5%
Taylor expanded in t around 0 44.7%
associate-*r/44.7%
neg-mul-144.7%
Simplified44.7%
if -1.3e13 < z < 1.69999999999999987e-88Initial program 86.6%
associate-*l/94.8%
Simplified94.8%
Taylor expanded in z around 0 66.5%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in t around inf 54.0%
associate-/l*61.9%
Simplified61.9%
if 1.69999999999999987e-88 < z < 1.95e48Initial program 71.3%
associate-*l/83.5%
Simplified83.5%
Taylor expanded in z around 0 42.9%
associate-/l*55.3%
Simplified55.3%
Taylor expanded in t around 0 42.5%
mul-1-neg42.5%
associate-/l*54.3%
distribute-neg-frac54.3%
Simplified54.3%
Taylor expanded in x around 0 54.3%
associate-*r/54.3%
neg-mul-154.3%
Simplified54.3%
if 1.95e48 < z < 6.4000000000000003e72Initial program 65.3%
associate-*l/87.9%
Simplified87.9%
Taylor expanded in y around inf 52.4%
div-sub52.4%
Simplified52.4%
Taylor expanded in t around inf 40.4%
associate-/l*51.8%
Simplified51.8%
Final simplification57.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ t (/ a y)))))
(if (<= a -0.076)
t_1
(if (<= a -6.8e-102)
(- t (/ a (/ z x)))
(if (<= a -2.6e-122)
t_1
(if (<= a 4.4e-167)
(* y (/ (- x t) z))
(if (<= a 1.12e-41) (+ t (/ a (/ z t))) t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double tmp;
if (a <= -0.076) {
tmp = t_1;
} else if (a <= -6.8e-102) {
tmp = t - (a / (z / x));
} else if (a <= -2.6e-122) {
tmp = t_1;
} else if (a <= 4.4e-167) {
tmp = y * ((x - t) / z);
} else if (a <= 1.12e-41) {
tmp = t + (a / (z / t));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (t / (a / y))
if (a <= (-0.076d0)) then
tmp = t_1
else if (a <= (-6.8d-102)) then
tmp = t - (a / (z / x))
else if (a <= (-2.6d-122)) then
tmp = t_1
else if (a <= 4.4d-167) then
tmp = y * ((x - t) / z)
else if (a <= 1.12d-41) then
tmp = t + (a / (z / t))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t / (a / y));
double tmp;
if (a <= -0.076) {
tmp = t_1;
} else if (a <= -6.8e-102) {
tmp = t - (a / (z / x));
} else if (a <= -2.6e-122) {
tmp = t_1;
} else if (a <= 4.4e-167) {
tmp = y * ((x - t) / z);
} else if (a <= 1.12e-41) {
tmp = t + (a / (z / t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t / (a / y)) tmp = 0 if a <= -0.076: tmp = t_1 elif a <= -6.8e-102: tmp = t - (a / (z / x)) elif a <= -2.6e-122: tmp = t_1 elif a <= 4.4e-167: tmp = y * ((x - t) / z) elif a <= 1.12e-41: tmp = t + (a / (z / t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t / Float64(a / y))) tmp = 0.0 if (a <= -0.076) tmp = t_1; elseif (a <= -6.8e-102) tmp = Float64(t - Float64(a / Float64(z / x))); elseif (a <= -2.6e-122) tmp = t_1; elseif (a <= 4.4e-167) tmp = Float64(y * Float64(Float64(x - t) / z)); elseif (a <= 1.12e-41) tmp = Float64(t + Float64(a / Float64(z / t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (t / (a / y)); tmp = 0.0; if (a <= -0.076) tmp = t_1; elseif (a <= -6.8e-102) tmp = t - (a / (z / x)); elseif (a <= -2.6e-122) tmp = t_1; elseif (a <= 4.4e-167) tmp = y * ((x - t) / z); elseif (a <= 1.12e-41) tmp = t + (a / (z / t)); else tmp = t_1; 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[a, -0.076], t$95$1, If[LessEqual[a, -6.8e-102], N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.6e-122], t$95$1, If[LessEqual[a, 4.4e-167], N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.12e-41], N[(t + N[(a / N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{t}{\frac{a}{y}}\\
\mathbf{if}\;a \leq -0.076:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -6.8 \cdot 10^{-102}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\mathbf{elif}\;a \leq -2.6 \cdot 10^{-122}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 4.4 \cdot 10^{-167}:\\
\;\;\;\;y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;a \leq 1.12 \cdot 10^{-41}:\\
\;\;\;\;t + \frac{a}{\frac{z}{t}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -0.0759999999999999981 or -6.80000000000000026e-102 < a < -2.59999999999999975e-122 or 1.11999999999999999e-41 < a Initial program 65.6%
associate-*l/92.0%
Simplified92.0%
Taylor expanded in z around 0 54.7%
associate-/l*69.2%
Simplified69.2%
Taylor expanded in t around inf 53.4%
associate-/l*60.6%
Simplified60.6%
if -0.0759999999999999981 < a < -6.80000000000000026e-102Initial program 73.6%
associate-*l/73.5%
Simplified73.5%
Taylor expanded in z around inf 78.9%
associate--l+78.9%
associate-*r/78.9%
associate-*r/78.9%
div-sub78.9%
distribute-lft-out--78.9%
mul-1-neg78.9%
distribute-neg-frac78.9%
distribute-rgt-out--78.9%
unsub-neg78.9%
associate-/l*78.8%
Simplified78.8%
Taylor expanded in y around 0 52.6%
associate-*r/52.6%
neg-mul-152.6%
Simplified52.6%
Taylor expanded in t around 0 47.1%
associate-/l*47.1%
Simplified47.1%
if -2.59999999999999975e-122 < a < 4.3999999999999999e-167Initial program 62.4%
associate-*l/71.9%
Simplified71.9%
Taylor expanded in y around inf 62.2%
div-sub62.2%
Simplified62.2%
Taylor expanded in a around 0 56.8%
mul-1-neg56.8%
distribute-neg-frac56.8%
Simplified56.8%
if 4.3999999999999999e-167 < a < 1.11999999999999999e-41Initial program 66.7%
associate-*l/79.0%
Simplified79.0%
Taylor expanded in z around inf 64.8%
associate--l+64.8%
associate-*r/64.8%
associate-*r/64.8%
div-sub64.8%
distribute-lft-out--64.8%
mul-1-neg64.8%
distribute-neg-frac64.8%
distribute-rgt-out--64.8%
unsub-neg64.8%
associate-/l*73.8%
Simplified73.8%
Taylor expanded in y around 0 53.1%
associate-*r/53.1%
neg-mul-153.1%
Simplified53.1%
Taylor expanded in x around 0 49.9%
sub-neg49.9%
mul-1-neg49.9%
remove-double-neg49.9%
associate-/l*50.0%
Simplified50.0%
Final simplification57.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (+ x (/ t (/ a y)))))
(if (<= a -1.25e+184)
t_2
(if (<= a 2e-219)
t_1
(if (<= a 8.4e-148)
(/ (- x) (/ (- a z) y))
(if (<= a 2.9e+103)
t_1
(if (<= a 9e+230) (- x (/ x (/ a y))) t_2)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t / (a / y));
double tmp;
if (a <= -1.25e+184) {
tmp = t_2;
} else if (a <= 2e-219) {
tmp = t_1;
} else if (a <= 8.4e-148) {
tmp = -x / ((a - z) / y);
} else if (a <= 2.9e+103) {
tmp = t_1;
} else if (a <= 9e+230) {
tmp = x - (x / (a / y));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = x + (t / (a / y))
if (a <= (-1.25d+184)) then
tmp = t_2
else if (a <= 2d-219) then
tmp = t_1
else if (a <= 8.4d-148) then
tmp = -x / ((a - z) / y)
else if (a <= 2.9d+103) then
tmp = t_1
else if (a <= 9d+230) then
tmp = x - (x / (a / y))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t / (a / y));
double tmp;
if (a <= -1.25e+184) {
tmp = t_2;
} else if (a <= 2e-219) {
tmp = t_1;
} else if (a <= 8.4e-148) {
tmp = -x / ((a - z) / y);
} else if (a <= 2.9e+103) {
tmp = t_1;
} else if (a <= 9e+230) {
tmp = x - (x / (a / y));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + (t / (a / y)) tmp = 0 if a <= -1.25e+184: tmp = t_2 elif a <= 2e-219: tmp = t_1 elif a <= 8.4e-148: tmp = -x / ((a - z) / y) elif a <= 2.9e+103: tmp = t_1 elif a <= 9e+230: tmp = x - (x / (a / y)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(x + Float64(t / Float64(a / y))) tmp = 0.0 if (a <= -1.25e+184) tmp = t_2; elseif (a <= 2e-219) tmp = t_1; elseif (a <= 8.4e-148) tmp = Float64(Float64(-x) / Float64(Float64(a - z) / y)); elseif (a <= 2.9e+103) tmp = t_1; elseif (a <= 9e+230) tmp = Float64(x - Float64(x / Float64(a / y))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = x + (t / (a / y)); tmp = 0.0; if (a <= -1.25e+184) tmp = t_2; elseif (a <= 2e-219) tmp = t_1; elseif (a <= 8.4e-148) tmp = -x / ((a - z) / y); elseif (a <= 2.9e+103) tmp = t_1; elseif (a <= 9e+230) tmp = x - (x / (a / y)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.25e+184], t$95$2, If[LessEqual[a, 2e-219], t$95$1, If[LessEqual[a, 8.4e-148], N[((-x) / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e+103], t$95$1, If[LessEqual[a, 9e+230], N[(x - N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + \frac{t}{\frac{a}{y}}\\
\mathbf{if}\;a \leq -1.25 \cdot 10^{+184}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 2 \cdot 10^{-219}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 8.4 \cdot 10^{-148}:\\
\;\;\;\;\frac{-x}{\frac{a - z}{y}}\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{+103}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 9 \cdot 10^{+230}:\\
\;\;\;\;x - \frac{x}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -1.25e184 or 8.9999999999999998e230 < a Initial program 66.7%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in z around 0 60.8%
associate-/l*85.6%
Simplified85.6%
Taylor expanded in t around inf 69.5%
associate-/l*83.9%
Simplified83.9%
if -1.25e184 < a < 2.0000000000000001e-219 or 8.4000000000000001e-148 < a < 2.8999999999999998e103Initial program 64.7%
associate-*l/79.0%
Simplified79.0%
Taylor expanded in x around 0 47.7%
associate-*r/60.9%
Simplified60.9%
if 2.0000000000000001e-219 < a < 8.4000000000000001e-148Initial program 75.2%
associate-*l/80.1%
Simplified80.1%
Taylor expanded in y around inf 77.1%
div-sub77.1%
Simplified77.1%
Taylor expanded in t around 0 60.7%
mul-1-neg60.7%
associate-/l*66.5%
distribute-neg-frac66.5%
Simplified66.5%
if 2.8999999999999998e103 < a < 8.9999999999999998e230Initial program 60.3%
associate-*l/87.6%
Simplified87.6%
Taylor expanded in z around 0 56.6%
associate-/l*64.2%
Simplified64.2%
Taylor expanded in t around 0 56.6%
mul-1-neg56.6%
associate-/l*63.9%
distribute-neg-frac63.9%
Simplified63.9%
Final simplification65.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (* y (/ (- t x) (- a z)))))
(if (<= y -3.6e+118)
t_2
(if (<= y -1.06e-94)
t_1
(if (<= y -3e-168) (- x (* y (/ x a))) (if (<= y 1e+117) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = y * ((t - x) / (a - z));
double tmp;
if (y <= -3.6e+118) {
tmp = t_2;
} else if (y <= -1.06e-94) {
tmp = t_1;
} else if (y <= -3e-168) {
tmp = x - (y * (x / a));
} else if (y <= 1e+117) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = y * ((t - x) / (a - z))
if (y <= (-3.6d+118)) then
tmp = t_2
else if (y <= (-1.06d-94)) then
tmp = t_1
else if (y <= (-3d-168)) then
tmp = x - (y * (x / a))
else if (y <= 1d+117) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = y * ((t - x) / (a - z));
double tmp;
if (y <= -3.6e+118) {
tmp = t_2;
} else if (y <= -1.06e-94) {
tmp = t_1;
} else if (y <= -3e-168) {
tmp = x - (y * (x / a));
} else if (y <= 1e+117) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = y * ((t - x) / (a - z)) tmp = 0 if y <= -3.6e+118: tmp = t_2 elif y <= -1.06e-94: tmp = t_1 elif y <= -3e-168: tmp = x - (y * (x / a)) elif y <= 1e+117: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(y * Float64(Float64(t - x) / Float64(a - z))) tmp = 0.0 if (y <= -3.6e+118) tmp = t_2; elseif (y <= -1.06e-94) tmp = t_1; elseif (y <= -3e-168) tmp = Float64(x - Float64(y * Float64(x / a))); elseif (y <= 1e+117) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = y * ((t - x) / (a - z)); tmp = 0.0; if (y <= -3.6e+118) tmp = t_2; elseif (y <= -1.06e-94) tmp = t_1; elseif (y <= -3e-168) tmp = x - (y * (x / a)); elseif (y <= 1e+117) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.6e+118], t$95$2, If[LessEqual[y, -1.06e-94], t$95$1, If[LessEqual[y, -3e-168], N[(x - N[(y * N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1e+117], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := y \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;y \leq -3.6 \cdot 10^{+118}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -1.06 \cdot 10^{-94}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -3 \cdot 10^{-168}:\\
\;\;\;\;x - y \cdot \frac{x}{a}\\
\mathbf{elif}\;y \leq 10^{+117}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -3.6e118 or 1.00000000000000005e117 < y Initial program 65.7%
associate-*l/90.9%
Simplified90.9%
Taylor expanded in y around inf 86.1%
div-sub86.1%
Simplified86.1%
if -3.6e118 < y < -1.06e-94 or -2.99999999999999991e-168 < y < 1.00000000000000005e117Initial program 63.0%
associate-*l/78.1%
Simplified78.1%
Taylor expanded in x around 0 45.0%
associate-*r/57.9%
Simplified57.9%
if -1.06e-94 < y < -2.99999999999999991e-168Initial program 87.1%
associate-*l/87.1%
Simplified87.1%
Taylor expanded in z around 0 80.8%
associate-/l*80.8%
Simplified80.8%
Taylor expanded in t around 0 80.8%
mul-1-neg80.8%
associate-/l*80.8%
distribute-neg-frac80.8%
Simplified80.8%
add-sqr-sqrt39.8%
fma-def39.8%
distribute-frac-neg39.8%
add-sqr-sqrt39.8%
sqrt-unprod39.8%
sqr-neg39.8%
sqrt-unprod0.0%
add-sqr-sqrt39.8%
fma-neg39.8%
add-sqr-sqrt80.5%
associate-/r/80.5%
add-sqr-sqrt40.5%
sqrt-unprod80.5%
sqr-neg80.5%
sqrt-unprod40.0%
add-sqr-sqrt80.8%
Applied egg-rr80.8%
Final simplification69.1%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -5.1e-129) (not (<= a 5e-195))) (+ x (* (- t x) (/ (- y z) (- a z)))) (+ t (/ (- x t) (/ z (- y a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -5.1e-129) || !(a <= 5e-195)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((a <= (-5.1d-129)) .or. (.not. (a <= 5d-195))) then
tmp = x + ((t - x) * ((y - z) / (a - z)))
else
tmp = t + ((x - t) / (z / (y - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -5.1e-129) || !(a <= 5e-195)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -5.1e-129) or not (a <= 5e-195): tmp = x + ((t - x) * ((y - z) / (a - z))) else: tmp = t + ((x - t) / (z / (y - a))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -5.1e-129) || !(a <= 5e-195)) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -5.1e-129) || ~((a <= 5e-195))) tmp = x + ((t - x) * ((y - z) / (a - z))); else tmp = t + ((x - t) / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -5.1e-129], N[Not[LessEqual[a, 5e-195]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.1 \cdot 10^{-129} \lor \neg \left(a \leq 5 \cdot 10^{-195}\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if a < -5.0999999999999999e-129 or 5.00000000000000009e-195 < a Initial program 67.8%
associate-*l/88.4%
Simplified88.4%
if -5.0999999999999999e-129 < a < 5.00000000000000009e-195Initial program 58.7%
associate-*l/69.1%
Simplified69.1%
Taylor expanded in z around inf 84.4%
associate--l+84.4%
associate-*r/84.4%
associate-*r/84.4%
div-sub84.4%
distribute-lft-out--84.4%
mul-1-neg84.4%
distribute-neg-frac84.4%
distribute-rgt-out--84.4%
unsub-neg84.4%
associate-/l*91.2%
Simplified91.2%
Final simplification89.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -3.2e-123) (not (<= a 5e-195))) (+ x (* (- t x) (/ (- y z) (- a z)))) (+ t (/ (- x t) (* z (/ 1.0 (- y a)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -3.2e-123) || !(a <= 5e-195)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x - t) / (z * (1.0 / (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 ((a <= (-3.2d-123)) .or. (.not. (a <= 5d-195))) then
tmp = x + ((t - x) * ((y - z) / (a - z)))
else
tmp = t + ((x - t) / (z * (1.0d0 / (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 ((a <= -3.2e-123) || !(a <= 5e-195)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + ((x - t) / (z * (1.0 / (y - a))));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -3.2e-123) or not (a <= 5e-195): tmp = x + ((t - x) * ((y - z) / (a - z))) else: tmp = t + ((x - t) / (z * (1.0 / (y - a)))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -3.2e-123) || !(a <= 5e-195)) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(x - t) / Float64(z * Float64(1.0 / Float64(y - a))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -3.2e-123) || ~((a <= 5e-195))) tmp = x + ((t - x) * ((y - z) / (a - z))); else tmp = t + ((x - t) / (z * (1.0 / (y - a)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -3.2e-123], N[Not[LessEqual[a, 5e-195]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z * N[(1.0 / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.2 \cdot 10^{-123} \lor \neg \left(a \leq 5 \cdot 10^{-195}\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x - t}{z \cdot \frac{1}{y - a}}\\
\end{array}
\end{array}
if a < -3.19999999999999979e-123 or 5.00000000000000009e-195 < a Initial program 67.8%
associate-*l/88.4%
Simplified88.4%
if -3.19999999999999979e-123 < a < 5.00000000000000009e-195Initial program 58.7%
associate-*l/69.1%
Simplified69.1%
Taylor expanded in z around inf 84.4%
associate--l+84.4%
associate-*r/84.4%
associate-*r/84.4%
div-sub84.4%
distribute-lft-out--84.4%
mul-1-neg84.4%
distribute-neg-frac84.4%
distribute-rgt-out--84.4%
unsub-neg84.4%
associate-/l*91.2%
Simplified91.2%
div-inv91.3%
Applied egg-rr91.3%
Final simplification89.2%
(FPCore (x y z t a)
:precision binary64
(if (<= y -9.5e+114)
(* y (/ x z))
(if (<= y -6.6e-95)
t
(if (<= y -6e-172)
x
(if (<= y 1.45e-168)
t
(if (<= y 1.8e+216) (* x (/ y z)) (/ t (/ a y))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -9.5e+114) {
tmp = y * (x / z);
} else if (y <= -6.6e-95) {
tmp = t;
} else if (y <= -6e-172) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else if (y <= 1.8e+216) {
tmp = x * (y / z);
} else {
tmp = t / (a / y);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (y <= (-9.5d+114)) then
tmp = y * (x / z)
else if (y <= (-6.6d-95)) then
tmp = t
else if (y <= (-6d-172)) then
tmp = x
else if (y <= 1.45d-168) then
tmp = t
else if (y <= 1.8d+216) then
tmp = x * (y / z)
else
tmp = t / (a / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -9.5e+114) {
tmp = y * (x / z);
} else if (y <= -6.6e-95) {
tmp = t;
} else if (y <= -6e-172) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else if (y <= 1.8e+216) {
tmp = x * (y / z);
} else {
tmp = t / (a / y);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -9.5e+114: tmp = y * (x / z) elif y <= -6.6e-95: tmp = t elif y <= -6e-172: tmp = x elif y <= 1.45e-168: tmp = t elif y <= 1.8e+216: tmp = x * (y / z) else: tmp = t / (a / y) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -9.5e+114) tmp = Float64(y * Float64(x / z)); elseif (y <= -6.6e-95) tmp = t; elseif (y <= -6e-172) tmp = x; elseif (y <= 1.45e-168) tmp = t; elseif (y <= 1.8e+216) tmp = Float64(x * Float64(y / z)); else tmp = Float64(t / Float64(a / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -9.5e+114) tmp = y * (x / z); elseif (y <= -6.6e-95) tmp = t; elseif (y <= -6e-172) tmp = x; elseif (y <= 1.45e-168) tmp = t; elseif (y <= 1.8e+216) tmp = x * (y / z); else tmp = t / (a / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -9.5e+114], N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -6.6e-95], t, If[LessEqual[y, -6e-172], x, If[LessEqual[y, 1.45e-168], t, If[LessEqual[y, 1.8e+216], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.5 \cdot 10^{+114}:\\
\;\;\;\;y \cdot \frac{x}{z}\\
\mathbf{elif}\;y \leq -6.6 \cdot 10^{-95}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq -6 \cdot 10^{-172}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{-168}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 1.8 \cdot 10^{+216}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\end{array}
\end{array}
if y < -9.5000000000000001e114Initial program 61.0%
associate-*l/92.3%
Simplified92.3%
Taylor expanded in z around inf 44.3%
associate--l+44.3%
associate-*r/44.3%
associate-*r/44.3%
div-sub44.3%
distribute-lft-out--44.3%
mul-1-neg44.3%
distribute-neg-frac44.3%
distribute-rgt-out--44.7%
unsub-neg44.7%
associate-/l*62.8%
Simplified62.8%
Taylor expanded in t around 0 28.4%
associate-/l*41.9%
associate-/r/41.9%
Simplified41.9%
Taylor expanded in y around inf 28.5%
associate-/l*42.0%
Simplified42.0%
associate-/r/42.0%
Applied egg-rr42.0%
if -9.5000000000000001e114 < y < -6.6e-95 or -5.99999999999999967e-172 < y < 1.4499999999999999e-168Initial program 60.1%
associate-*l/78.0%
Simplified78.0%
Taylor expanded in z around inf 44.9%
if -6.6e-95 < y < -5.99999999999999967e-172Initial program 87.1%
associate-*l/87.1%
Simplified87.1%
Taylor expanded in a around inf 80.5%
if 1.4499999999999999e-168 < y < 1.8000000000000001e216Initial program 69.8%
associate-*l/82.6%
Simplified82.6%
Taylor expanded in z around inf 44.2%
associate--l+44.2%
associate-*r/44.2%
associate-*r/44.2%
div-sub44.4%
distribute-lft-out--44.4%
mul-1-neg44.4%
distribute-neg-frac44.4%
distribute-rgt-out--45.8%
unsub-neg45.8%
associate-/l*55.3%
Simplified55.3%
Taylor expanded in t around 0 29.1%
associate-/l*34.2%
associate-/r/34.2%
Simplified34.2%
Taylor expanded in y around inf 29.0%
associate-/l*32.7%
Simplified32.7%
Taylor expanded in x around 0 29.0%
associate-/l*32.7%
*-rgt-identity32.7%
associate-*r/32.7%
associate-/r/32.7%
associate-*l/32.7%
*-lft-identity32.7%
Simplified32.7%
if 1.8000000000000001e216 < y Initial program 67.3%
+-commutative67.3%
associate-*l/87.6%
fma-def87.6%
Simplified87.6%
fma-udef87.6%
*-commutative87.6%
clear-num87.3%
un-div-inv87.4%
Applied egg-rr87.4%
Taylor expanded in t around -inf 46.0%
associate-/l*58.0%
Simplified58.0%
Taylor expanded in z around 0 49.7%
Final simplification43.3%
(FPCore (x y z t a)
:precision binary64
(if (<= y -2.15e+114)
(/ x (/ z y))
(if (<= y -5e-95)
t
(if (<= y -8.1e-168)
x
(if (<= y 1.45e-168)
t
(if (<= y 2e+217) (* x (/ y z)) (/ t (/ a y))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -2.15e+114) {
tmp = x / (z / y);
} else if (y <= -5e-95) {
tmp = t;
} else if (y <= -8.1e-168) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else if (y <= 2e+217) {
tmp = x * (y / z);
} else {
tmp = t / (a / y);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (y <= (-2.15d+114)) then
tmp = x / (z / y)
else if (y <= (-5d-95)) then
tmp = t
else if (y <= (-8.1d-168)) then
tmp = x
else if (y <= 1.45d-168) then
tmp = t
else if (y <= 2d+217) then
tmp = x * (y / z)
else
tmp = t / (a / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -2.15e+114) {
tmp = x / (z / y);
} else if (y <= -5e-95) {
tmp = t;
} else if (y <= -8.1e-168) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else if (y <= 2e+217) {
tmp = x * (y / z);
} else {
tmp = t / (a / y);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -2.15e+114: tmp = x / (z / y) elif y <= -5e-95: tmp = t elif y <= -8.1e-168: tmp = x elif y <= 1.45e-168: tmp = t elif y <= 2e+217: tmp = x * (y / z) else: tmp = t / (a / y) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -2.15e+114) tmp = Float64(x / Float64(z / y)); elseif (y <= -5e-95) tmp = t; elseif (y <= -8.1e-168) tmp = x; elseif (y <= 1.45e-168) tmp = t; elseif (y <= 2e+217) tmp = Float64(x * Float64(y / z)); else tmp = Float64(t / Float64(a / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -2.15e+114) tmp = x / (z / y); elseif (y <= -5e-95) tmp = t; elseif (y <= -8.1e-168) tmp = x; elseif (y <= 1.45e-168) tmp = t; elseif (y <= 2e+217) tmp = x * (y / z); else tmp = t / (a / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -2.15e+114], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -5e-95], t, If[LessEqual[y, -8.1e-168], x, If[LessEqual[y, 1.45e-168], t, If[LessEqual[y, 2e+217], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.15 \cdot 10^{+114}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq -5 \cdot 10^{-95}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq -8.1 \cdot 10^{-168}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{-168}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+217}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\end{array}
\end{array}
if y < -2.15e114Initial program 61.0%
associate-*l/92.3%
Simplified92.3%
Taylor expanded in z around inf 44.3%
associate--l+44.3%
associate-*r/44.3%
associate-*r/44.3%
div-sub44.3%
distribute-lft-out--44.3%
mul-1-neg44.3%
distribute-neg-frac44.3%
distribute-rgt-out--44.7%
unsub-neg44.7%
associate-/l*62.8%
Simplified62.8%
Taylor expanded in t around 0 28.4%
associate-/l*41.9%
associate-/r/41.9%
Simplified41.9%
Taylor expanded in y around inf 28.5%
associate-/l*42.0%
Simplified42.0%
if -2.15e114 < y < -4.9999999999999998e-95 or -8.1e-168 < y < 1.4499999999999999e-168Initial program 60.1%
associate-*l/78.0%
Simplified78.0%
Taylor expanded in z around inf 44.9%
if -4.9999999999999998e-95 < y < -8.1e-168Initial program 87.1%
associate-*l/87.1%
Simplified87.1%
Taylor expanded in a around inf 80.5%
if 1.4499999999999999e-168 < y < 1.99999999999999992e217Initial program 69.8%
associate-*l/82.6%
Simplified82.6%
Taylor expanded in z around inf 44.2%
associate--l+44.2%
associate-*r/44.2%
associate-*r/44.2%
div-sub44.4%
distribute-lft-out--44.4%
mul-1-neg44.4%
distribute-neg-frac44.4%
distribute-rgt-out--45.8%
unsub-neg45.8%
associate-/l*55.3%
Simplified55.3%
Taylor expanded in t around 0 29.1%
associate-/l*34.2%
associate-/r/34.2%
Simplified34.2%
Taylor expanded in y around inf 29.0%
associate-/l*32.7%
Simplified32.7%
Taylor expanded in x around 0 29.0%
associate-/l*32.7%
*-rgt-identity32.7%
associate-*r/32.7%
associate-/r/32.7%
associate-*l/32.7%
*-lft-identity32.7%
Simplified32.7%
if 1.99999999999999992e217 < y Initial program 67.3%
+-commutative67.3%
associate-*l/87.6%
fma-def87.6%
Simplified87.6%
fma-udef87.6%
*-commutative87.6%
clear-num87.3%
un-div-inv87.4%
Applied egg-rr87.4%
Taylor expanded in t around -inf 46.0%
associate-/l*58.0%
Simplified58.0%
Taylor expanded in z around 0 49.7%
Final simplification43.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t x) a))))
(if (<= z -3.2e-14)
(* x (/ (- y a) z))
(if (<= z -2.7e-173)
t_1
(if (<= z -2.9e-288) x (if (<= z 1.9e-8) t_1 (if (<= z 7e+74) x t)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / a);
double tmp;
if (z <= -3.2e-14) {
tmp = x * ((y - a) / z);
} else if (z <= -2.7e-173) {
tmp = t_1;
} else if (z <= -2.9e-288) {
tmp = x;
} else if (z <= 1.9e-8) {
tmp = t_1;
} else if (z <= 7e+74) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = y * ((t - x) / a)
if (z <= (-3.2d-14)) then
tmp = x * ((y - a) / z)
else if (z <= (-2.7d-173)) then
tmp = t_1
else if (z <= (-2.9d-288)) then
tmp = x
else if (z <= 1.9d-8) then
tmp = t_1
else if (z <= 7d+74) then
tmp = x
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / a);
double tmp;
if (z <= -3.2e-14) {
tmp = x * ((y - a) / z);
} else if (z <= -2.7e-173) {
tmp = t_1;
} else if (z <= -2.9e-288) {
tmp = x;
} else if (z <= 1.9e-8) {
tmp = t_1;
} else if (z <= 7e+74) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - x) / a) tmp = 0 if z <= -3.2e-14: tmp = x * ((y - a) / z) elif z <= -2.7e-173: tmp = t_1 elif z <= -2.9e-288: tmp = x elif z <= 1.9e-8: tmp = t_1 elif z <= 7e+74: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - x) / a)) tmp = 0.0 if (z <= -3.2e-14) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= -2.7e-173) tmp = t_1; elseif (z <= -2.9e-288) tmp = x; elseif (z <= 1.9e-8) tmp = t_1; elseif (z <= 7e+74) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - x) / a); tmp = 0.0; if (z <= -3.2e-14) tmp = x * ((y - a) / z); elseif (z <= -2.7e-173) tmp = t_1; elseif (z <= -2.9e-288) tmp = x; elseif (z <= 1.9e-8) tmp = t_1; elseif (z <= 7e+74) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.2e-14], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.7e-173], t$95$1, If[LessEqual[z, -2.9e-288], x, If[LessEqual[z, 1.9e-8], t$95$1, If[LessEqual[z, 7e+74], x, t]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - x}{a}\\
\mathbf{if}\;z \leq -3.2 \cdot 10^{-14}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{-173}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -2.9 \cdot 10^{-288}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{-8}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 7 \cdot 10^{+74}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3.2000000000000002e-14Initial program 42.3%
associate-*l/72.3%
Simplified72.3%
Taylor expanded in z around inf 57.5%
associate--l+57.5%
associate-*r/57.5%
associate-*r/57.5%
div-sub57.5%
distribute-lft-out--57.5%
mul-1-neg57.5%
distribute-neg-frac57.5%
distribute-rgt-out--57.6%
unsub-neg57.6%
associate-/l*71.5%
Simplified71.5%
Taylor expanded in t around 0 27.0%
associate-/l*37.2%
associate-/r/38.4%
Simplified38.4%
Taylor expanded in x around 0 27.0%
associate-*r/37.1%
Simplified37.1%
if -3.2000000000000002e-14 < z < -2.7e-173 or -2.90000000000000015e-288 < z < 1.90000000000000014e-8Initial program 84.8%
associate-*l/93.5%
Simplified93.5%
Taylor expanded in y around inf 66.4%
div-sub66.4%
Simplified66.4%
Taylor expanded in a around inf 52.4%
if -2.7e-173 < z < -2.90000000000000015e-288 or 1.90000000000000014e-8 < z < 7.00000000000000029e74Initial program 78.0%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in a around inf 45.5%
if 7.00000000000000029e74 < z Initial program 53.6%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 53.4%
Final simplification47.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t x) a))))
(if (<= z -1.4e-13)
(* (- y a) (/ x z))
(if (<= z -2.7e-173)
t_1
(if (<= z -3e-288) x (if (<= z 5.5e-7) t_1 (if (<= z 5.6e+73) x t)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / a);
double tmp;
if (z <= -1.4e-13) {
tmp = (y - a) * (x / z);
} else if (z <= -2.7e-173) {
tmp = t_1;
} else if (z <= -3e-288) {
tmp = x;
} else if (z <= 5.5e-7) {
tmp = t_1;
} else if (z <= 5.6e+73) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = y * ((t - x) / a)
if (z <= (-1.4d-13)) then
tmp = (y - a) * (x / z)
else if (z <= (-2.7d-173)) then
tmp = t_1
else if (z <= (-3d-288)) then
tmp = x
else if (z <= 5.5d-7) then
tmp = t_1
else if (z <= 5.6d+73) then
tmp = x
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / a);
double tmp;
if (z <= -1.4e-13) {
tmp = (y - a) * (x / z);
} else if (z <= -2.7e-173) {
tmp = t_1;
} else if (z <= -3e-288) {
tmp = x;
} else if (z <= 5.5e-7) {
tmp = t_1;
} else if (z <= 5.6e+73) {
tmp = x;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - x) / a) tmp = 0 if z <= -1.4e-13: tmp = (y - a) * (x / z) elif z <= -2.7e-173: tmp = t_1 elif z <= -3e-288: tmp = x elif z <= 5.5e-7: tmp = t_1 elif z <= 5.6e+73: tmp = x else: tmp = t return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - x) / a)) tmp = 0.0 if (z <= -1.4e-13) tmp = Float64(Float64(y - a) * Float64(x / z)); elseif (z <= -2.7e-173) tmp = t_1; elseif (z <= -3e-288) tmp = x; elseif (z <= 5.5e-7) tmp = t_1; elseif (z <= 5.6e+73) tmp = x; else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - x) / a); tmp = 0.0; if (z <= -1.4e-13) tmp = (y - a) * (x / z); elseif (z <= -2.7e-173) tmp = t_1; elseif (z <= -3e-288) tmp = x; elseif (z <= 5.5e-7) tmp = t_1; elseif (z <= 5.6e+73) tmp = x; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.4e-13], N[(N[(y - a), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.7e-173], t$95$1, If[LessEqual[z, -3e-288], x, If[LessEqual[z, 5.5e-7], t$95$1, If[LessEqual[z, 5.6e+73], x, t]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - x}{a}\\
\mathbf{if}\;z \leq -1.4 \cdot 10^{-13}:\\
\;\;\;\;\left(y - a\right) \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{-173}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-288}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{-7}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 5.6 \cdot 10^{+73}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.4000000000000001e-13Initial program 42.3%
associate-*l/72.3%
Simplified72.3%
Taylor expanded in z around inf 57.5%
associate--l+57.5%
associate-*r/57.5%
associate-*r/57.5%
div-sub57.5%
distribute-lft-out--57.5%
mul-1-neg57.5%
distribute-neg-frac57.5%
distribute-rgt-out--57.6%
unsub-neg57.6%
associate-/l*71.5%
Simplified71.5%
Taylor expanded in t around 0 27.0%
associate-/l*37.2%
associate-/r/38.4%
Simplified38.4%
if -1.4000000000000001e-13 < z < -2.7e-173 or -2.99999999999999999e-288 < z < 5.5000000000000003e-7Initial program 84.8%
associate-*l/93.5%
Simplified93.5%
Taylor expanded in y around inf 66.4%
div-sub66.4%
Simplified66.4%
Taylor expanded in a around inf 52.4%
if -2.7e-173 < z < -2.99999999999999999e-288 or 5.5000000000000003e-7 < z < 5.60000000000000016e73Initial program 78.0%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in a around inf 45.5%
if 5.60000000000000016e73 < z Initial program 53.6%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 53.4%
Final simplification47.3%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.95e+152)
(- t (/ a (/ z x)))
(if (<= z -1.55e-100)
(* y (/ (- t x) (- a z)))
(if (<= z 6.5e+47) (+ x (* (- t x) (/ y a))) (* t (/ (- y z) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.95e+152) {
tmp = t - (a / (z / x));
} else if (z <= -1.55e-100) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 6.5e+47) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.95d+152)) then
tmp = t - (a / (z / x))
else if (z <= (-1.55d-100)) then
tmp = y * ((t - x) / (a - z))
else if (z <= 6.5d+47) then
tmp = x + ((t - x) * (y / a))
else
tmp = t * ((y - z) / (a - z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.95e+152) {
tmp = t - (a / (z / x));
} else if (z <= -1.55e-100) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 6.5e+47) {
tmp = x + ((t - x) * (y / a));
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.95e+152: tmp = t - (a / (z / x)) elif z <= -1.55e-100: tmp = y * ((t - x) / (a - z)) elif z <= 6.5e+47: tmp = x + ((t - x) * (y / a)) else: tmp = t * ((y - z) / (a - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.95e+152) tmp = Float64(t - Float64(a / Float64(z / x))); elseif (z <= -1.55e-100) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (z <= 6.5e+47) tmp = Float64(x + Float64(Float64(t - x) * Float64(y / a))); else tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.95e+152) tmp = t - (a / (z / x)); elseif (z <= -1.55e-100) tmp = y * ((t - x) / (a - z)); elseif (z <= 6.5e+47) tmp = x + ((t - x) * (y / a)); else tmp = t * ((y - z) / (a - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.95e+152], N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.55e-100], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.5e+47], N[(x + N[(N[(t - x), $MachinePrecision] * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.95 \cdot 10^{+152}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\mathbf{elif}\;z \leq -1.55 \cdot 10^{-100}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+47}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if z < -1.95000000000000006e152Initial program 25.6%
associate-*l/60.9%
Simplified60.9%
Taylor expanded in z around inf 68.1%
associate--l+68.1%
associate-*r/68.1%
associate-*r/68.1%
div-sub68.1%
distribute-lft-out--68.1%
mul-1-neg68.1%
distribute-neg-frac68.1%
distribute-rgt-out--68.2%
unsub-neg68.2%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in y around 0 63.8%
associate-*r/63.8%
neg-mul-163.8%
Simplified63.8%
Taylor expanded in t around 0 61.7%
associate-/l*63.6%
Simplified63.6%
if -1.95000000000000006e152 < z < -1.5499999999999999e-100Initial program 59.0%
associate-*l/83.1%
Simplified83.1%
Taylor expanded in y around inf 57.4%
div-sub57.4%
Simplified57.4%
if -1.5499999999999999e-100 < z < 6.49999999999999988e47Initial program 86.5%
associate-*l/93.6%
Simplified93.6%
Taylor expanded in z around 0 75.9%
if 6.49999999999999988e47 < z Initial program 55.2%
associate-*l/76.5%
Simplified76.5%
Taylor expanded in x around 0 49.0%
associate-*r/66.9%
Simplified66.9%
Final simplification68.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.3e+152)
(- t (/ a (/ z x)))
(if (<= z -3.8e-112)
(* y (/ (- t x) (- a z)))
(if (<= z 7.3e+46) (+ x (/ y (/ a (- t x)))) (* t (/ (- y z) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.3e+152) {
tmp = t - (a / (z / x));
} else if (z <= -3.8e-112) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 7.3e+46) {
tmp = x + (y / (a / (t - x)));
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.3d+152)) then
tmp = t - (a / (z / x))
else if (z <= (-3.8d-112)) then
tmp = y * ((t - x) / (a - z))
else if (z <= 7.3d+46) then
tmp = x + (y / (a / (t - x)))
else
tmp = t * ((y - z) / (a - z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.3e+152) {
tmp = t - (a / (z / x));
} else if (z <= -3.8e-112) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 7.3e+46) {
tmp = x + (y / (a / (t - x)));
} else {
tmp = t * ((y - z) / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.3e+152: tmp = t - (a / (z / x)) elif z <= -3.8e-112: tmp = y * ((t - x) / (a - z)) elif z <= 7.3e+46: tmp = x + (y / (a / (t - x))) else: tmp = t * ((y - z) / (a - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.3e+152) tmp = Float64(t - Float64(a / Float64(z / x))); elseif (z <= -3.8e-112) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (z <= 7.3e+46) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); else tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.3e+152) tmp = t - (a / (z / x)); elseif (z <= -3.8e-112) tmp = y * ((t - x) / (a - z)); elseif (z <= 7.3e+46) tmp = x + (y / (a / (t - x))); else tmp = t * ((y - z) / (a - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.3e+152], N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.8e-112], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.3e+46], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.3 \cdot 10^{+152}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{-112}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;z \leq 7.3 \cdot 10^{+46}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if z < -2.29999999999999985e152Initial program 25.6%
associate-*l/60.9%
Simplified60.9%
Taylor expanded in z around inf 68.1%
associate--l+68.1%
associate-*r/68.1%
associate-*r/68.1%
div-sub68.1%
distribute-lft-out--68.1%
mul-1-neg68.1%
distribute-neg-frac68.1%
distribute-rgt-out--68.2%
unsub-neg68.2%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in y around 0 63.8%
associate-*r/63.8%
neg-mul-163.8%
Simplified63.8%
Taylor expanded in t around 0 61.7%
associate-/l*63.6%
Simplified63.6%
if -2.29999999999999985e152 < z < -3.79999999999999995e-112Initial program 59.0%
associate-*l/83.1%
Simplified83.1%
Taylor expanded in y around inf 57.4%
div-sub57.4%
Simplified57.4%
if -3.79999999999999995e-112 < z < 7.30000000000000028e46Initial program 86.5%
associate-*l/93.6%
Simplified93.6%
Taylor expanded in z around 0 68.0%
associate-/l*75.9%
Simplified75.9%
if 7.30000000000000028e46 < z Initial program 55.2%
associate-*l/76.5%
Simplified76.5%
Taylor expanded in x around 0 49.0%
associate-*r/66.9%
Simplified66.9%
Final simplification68.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.2e+152)
(- t (/ a (/ z x)))
(if (<= z -1.1e-115)
(* y (/ (- t x) (- a z)))
(if (<= z 8.8e+48) (+ x (/ y (/ a (- t x)))) (/ t (/ (- a z) (- y z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.2e+152) {
tmp = t - (a / (z / x));
} else if (z <= -1.1e-115) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 8.8e+48) {
tmp = x + (y / (a / (t - x)));
} else {
tmp = t / ((a - z) / (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.2d+152)) then
tmp = t - (a / (z / x))
else if (z <= (-1.1d-115)) then
tmp = y * ((t - x) / (a - z))
else if (z <= 8.8d+48) then
tmp = x + (y / (a / (t - x)))
else
tmp = t / ((a - z) / (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.2e+152) {
tmp = t - (a / (z / x));
} else if (z <= -1.1e-115) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 8.8e+48) {
tmp = x + (y / (a / (t - x)));
} else {
tmp = t / ((a - z) / (y - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.2e+152: tmp = t - (a / (z / x)) elif z <= -1.1e-115: tmp = y * ((t - x) / (a - z)) elif z <= 8.8e+48: tmp = x + (y / (a / (t - x))) else: tmp = t / ((a - z) / (y - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.2e+152) tmp = Float64(t - Float64(a / Float64(z / x))); elseif (z <= -1.1e-115) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (z <= 8.8e+48) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); else tmp = Float64(t / Float64(Float64(a - z) / Float64(y - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.2e+152) tmp = t - (a / (z / x)); elseif (z <= -1.1e-115) tmp = y * ((t - x) / (a - z)); elseif (z <= 8.8e+48) tmp = x + (y / (a / (t - x))); else tmp = t / ((a - z) / (y - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.2e+152], N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.1e-115], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.8e+48], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.2 \cdot 10^{+152}:\\
\;\;\;\;t - \frac{a}{\frac{z}{x}}\\
\mathbf{elif}\;z \leq -1.1 \cdot 10^{-115}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;z \leq 8.8 \cdot 10^{+48}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y - z}}\\
\end{array}
\end{array}
if z < -2.1999999999999998e152Initial program 25.6%
associate-*l/60.9%
Simplified60.9%
Taylor expanded in z around inf 68.1%
associate--l+68.1%
associate-*r/68.1%
associate-*r/68.1%
div-sub68.1%
distribute-lft-out--68.1%
mul-1-neg68.1%
distribute-neg-frac68.1%
distribute-rgt-out--68.2%
unsub-neg68.2%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in y around 0 63.8%
associate-*r/63.8%
neg-mul-163.8%
Simplified63.8%
Taylor expanded in t around 0 61.7%
associate-/l*63.6%
Simplified63.6%
if -2.1999999999999998e152 < z < -1.1e-115Initial program 59.0%
associate-*l/83.1%
Simplified83.1%
Taylor expanded in y around inf 57.4%
div-sub57.4%
Simplified57.4%
if -1.1e-115 < z < 8.7999999999999997e48Initial program 86.5%
associate-*l/93.6%
Simplified93.6%
Taylor expanded in z around 0 68.0%
associate-/l*75.9%
Simplified75.9%
if 8.7999999999999997e48 < z Initial program 55.2%
+-commutative55.2%
associate-*l/76.5%
fma-def76.5%
Simplified76.5%
fma-udef76.5%
*-commutative76.5%
clear-num76.4%
un-div-inv76.5%
Applied egg-rr76.5%
Taylor expanded in t around -inf 49.0%
associate-/l*66.9%
Simplified66.9%
Final simplification68.1%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.4e+152)
(+ t (/ (- x t) (/ (- z) a)))
(if (<= z -4.8e-104)
(* y (/ (- t x) (- a z)))
(if (<= z 1.75e+47)
(+ x (/ y (/ a (- t x))))
(/ t (/ (- a z) (- y z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.4e+152) {
tmp = t + ((x - t) / (-z / a));
} else if (z <= -4.8e-104) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 1.75e+47) {
tmp = x + (y / (a / (t - x)));
} else {
tmp = t / ((a - z) / (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 <= (-1.4d+152)) then
tmp = t + ((x - t) / (-z / a))
else if (z <= (-4.8d-104)) then
tmp = y * ((t - x) / (a - z))
else if (z <= 1.75d+47) then
tmp = x + (y / (a / (t - x)))
else
tmp = t / ((a - z) / (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 <= -1.4e+152) {
tmp = t + ((x - t) / (-z / a));
} else if (z <= -4.8e-104) {
tmp = y * ((t - x) / (a - z));
} else if (z <= 1.75e+47) {
tmp = x + (y / (a / (t - x)));
} else {
tmp = t / ((a - z) / (y - z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.4e+152: tmp = t + ((x - t) / (-z / a)) elif z <= -4.8e-104: tmp = y * ((t - x) / (a - z)) elif z <= 1.75e+47: tmp = x + (y / (a / (t - x))) else: tmp = t / ((a - z) / (y - z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.4e+152) tmp = Float64(t + Float64(Float64(x - t) / Float64(Float64(-z) / a))); elseif (z <= -4.8e-104) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (z <= 1.75e+47) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); else tmp = Float64(t / Float64(Float64(a - z) / Float64(y - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.4e+152) tmp = t + ((x - t) / (-z / a)); elseif (z <= -4.8e-104) tmp = y * ((t - x) / (a - z)); elseif (z <= 1.75e+47) tmp = x + (y / (a / (t - x))); else tmp = t / ((a - z) / (y - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.4e+152], N[(t + N[(N[(x - t), $MachinePrecision] / N[((-z) / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.8e-104], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.75e+47], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.4 \cdot 10^{+152}:\\
\;\;\;\;t + \frac{x - t}{\frac{-z}{a}}\\
\mathbf{elif}\;z \leq -4.8 \cdot 10^{-104}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;z \leq 1.75 \cdot 10^{+47}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y - z}}\\
\end{array}
\end{array}
if z < -1.4000000000000001e152Initial program 25.6%
associate-*l/60.9%
Simplified60.9%
Taylor expanded in z around inf 68.1%
associate--l+68.1%
associate-*r/68.1%
associate-*r/68.1%
div-sub68.1%
distribute-lft-out--68.1%
mul-1-neg68.1%
distribute-neg-frac68.1%
distribute-rgt-out--68.2%
unsub-neg68.2%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in y around 0 63.8%
associate-*r/63.8%
neg-mul-163.8%
Simplified63.8%
if -1.4000000000000001e152 < z < -4.8000000000000001e-104Initial program 59.0%
associate-*l/83.1%
Simplified83.1%
Taylor expanded in y around inf 57.4%
div-sub57.4%
Simplified57.4%
if -4.8000000000000001e-104 < z < 1.75000000000000008e47Initial program 86.5%
associate-*l/93.6%
Simplified93.6%
Taylor expanded in z around 0 68.0%
associate-/l*75.9%
Simplified75.9%
if 1.75000000000000008e47 < z Initial program 55.2%
+-commutative55.2%
associate-*l/76.5%
fma-def76.5%
Simplified76.5%
fma-udef76.5%
*-commutative76.5%
clear-num76.4%
un-div-inv76.5%
Applied egg-rr76.5%
Taylor expanded in t around -inf 49.0%
associate-/l*66.9%
Simplified66.9%
Final simplification68.1%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -1.15e+32) (not (<= a 8.2e-44))) (+ x (/ (- t x) (/ a (- y z)))) (+ t (/ (- x t) (/ z (- y a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -1.15e+32) || !(a <= 8.2e-44)) {
tmp = x + ((t - x) / (a / (y - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((a <= (-1.15d+32)) .or. (.not. (a <= 8.2d-44))) then
tmp = x + ((t - x) / (a / (y - z)))
else
tmp = t + ((x - t) / (z / (y - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -1.15e+32) || !(a <= 8.2e-44)) {
tmp = x + ((t - x) / (a / (y - z)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -1.15e+32) or not (a <= 8.2e-44): tmp = x + ((t - x) / (a / (y - z))) else: tmp = t + ((x - t) / (z / (y - a))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -1.15e+32) || !(a <= 8.2e-44)) tmp = Float64(x + Float64(Float64(t - x) / Float64(a / Float64(y - z)))); else tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -1.15e+32) || ~((a <= 8.2e-44))) tmp = x + ((t - x) / (a / (y - z))); else tmp = t + ((x - t) / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -1.15e+32], N[Not[LessEqual[a, 8.2e-44]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.15 \cdot 10^{+32} \lor \neg \left(a \leq 8.2 \cdot 10^{-44}\right):\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y - z}}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if a < -1.15e32 or 8.19999999999999984e-44 < a Initial program 64.7%
associate-*l/92.3%
Simplified92.3%
Taylor expanded in a around inf 59.1%
associate-/l*79.1%
Simplified79.1%
if -1.15e32 < a < 8.19999999999999984e-44Initial program 65.9%
associate-*l/74.9%
Simplified74.9%
Taylor expanded in z around inf 74.0%
associate--l+74.0%
associate-*r/74.0%
associate-*r/74.0%
div-sub74.0%
distribute-lft-out--74.0%
mul-1-neg74.0%
distribute-neg-frac74.0%
distribute-rgt-out--74.0%
unsub-neg74.0%
associate-/l*81.0%
Simplified81.0%
Final simplification80.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ y z))))
(if (<= y -6.6e+122)
t_1
(if (<= y -5.8e-95)
t
(if (<= y -5.8e-170) x (if (<= y 1.45e-168) t t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (y / z);
double tmp;
if (y <= -6.6e+122) {
tmp = t_1;
} else if (y <= -5.8e-95) {
tmp = t;
} else if (y <= -5.8e-170) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y / z)
if (y <= (-6.6d+122)) then
tmp = t_1
else if (y <= (-5.8d-95)) then
tmp = t
else if (y <= (-5.8d-170)) then
tmp = x
else if (y <= 1.45d-168) then
tmp = t
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (y / z);
double tmp;
if (y <= -6.6e+122) {
tmp = t_1;
} else if (y <= -5.8e-95) {
tmp = t;
} else if (y <= -5.8e-170) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (y / z) tmp = 0 if y <= -6.6e+122: tmp = t_1 elif y <= -5.8e-95: tmp = t elif y <= -5.8e-170: tmp = x elif y <= 1.45e-168: tmp = t else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(y / z)) tmp = 0.0 if (y <= -6.6e+122) tmp = t_1; elseif (y <= -5.8e-95) tmp = t; elseif (y <= -5.8e-170) tmp = x; elseif (y <= 1.45e-168) tmp = t; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (y / z); tmp = 0.0; if (y <= -6.6e+122) tmp = t_1; elseif (y <= -5.8e-95) tmp = t; elseif (y <= -5.8e-170) tmp = x; elseif (y <= 1.45e-168) tmp = t; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.6e+122], t$95$1, If[LessEqual[y, -5.8e-95], t, If[LessEqual[y, -5.8e-170], x, If[LessEqual[y, 1.45e-168], t, t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y}{z}\\
\mathbf{if}\;y \leq -6.6 \cdot 10^{+122}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -5.8 \cdot 10^{-95}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq -5.8 \cdot 10^{-170}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{-168}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -6.5999999999999998e122 or 1.4499999999999999e-168 < y Initial program 66.3%
associate-*l/86.1%
Simplified86.1%
Taylor expanded in z around inf 42.9%
associate--l+42.9%
associate-*r/42.9%
associate-*r/42.9%
div-sub43.0%
distribute-lft-out--43.0%
mul-1-neg43.0%
distribute-neg-frac43.0%
distribute-rgt-out--44.6%
unsub-neg44.6%
associate-/l*55.3%
Simplified55.3%
Taylor expanded in t around 0 28.1%
associate-/l*36.1%
associate-/r/35.6%
Simplified35.6%
Taylor expanded in y around inf 28.1%
associate-/l*35.2%
Simplified35.2%
Taylor expanded in x around 0 28.1%
associate-/l*35.2%
*-rgt-identity35.2%
associate-*r/35.2%
associate-/r/35.2%
associate-*l/35.2%
*-lft-identity35.2%
Simplified35.2%
if -6.5999999999999998e122 < y < -5.80000000000000004e-95 or -5.8000000000000001e-170 < y < 1.4499999999999999e-168Initial program 60.8%
associate-*l/78.5%
Simplified78.5%
Taylor expanded in z around inf 44.1%
if -5.80000000000000004e-95 < y < -5.8000000000000001e-170Initial program 87.1%
associate-*l/87.1%
Simplified87.1%
Taylor expanded in a around inf 80.5%
Final simplification41.4%
(FPCore (x y z t a)
:precision binary64
(if (<= y -3.2e+114)
(* y (/ x z))
(if (<= y -5.1e-95)
t
(if (<= y -1.06e-172) x (if (<= y 1.45e-168) t (* x (/ y z)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -3.2e+114) {
tmp = y * (x / z);
} else if (y <= -5.1e-95) {
tmp = t;
} else if (y <= -1.06e-172) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else {
tmp = 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 (y <= (-3.2d+114)) then
tmp = y * (x / z)
else if (y <= (-5.1d-95)) then
tmp = t
else if (y <= (-1.06d-172)) then
tmp = x
else if (y <= 1.45d-168) then
tmp = t
else
tmp = 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 (y <= -3.2e+114) {
tmp = y * (x / z);
} else if (y <= -5.1e-95) {
tmp = t;
} else if (y <= -1.06e-172) {
tmp = x;
} else if (y <= 1.45e-168) {
tmp = t;
} else {
tmp = x * (y / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -3.2e+114: tmp = y * (x / z) elif y <= -5.1e-95: tmp = t elif y <= -1.06e-172: tmp = x elif y <= 1.45e-168: tmp = t else: tmp = x * (y / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -3.2e+114) tmp = Float64(y * Float64(x / z)); elseif (y <= -5.1e-95) tmp = t; elseif (y <= -1.06e-172) tmp = x; elseif (y <= 1.45e-168) tmp = t; else tmp = Float64(x * Float64(y / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -3.2e+114) tmp = y * (x / z); elseif (y <= -5.1e-95) tmp = t; elseif (y <= -1.06e-172) tmp = x; elseif (y <= 1.45e-168) tmp = t; else tmp = x * (y / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -3.2e+114], N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -5.1e-95], t, If[LessEqual[y, -1.06e-172], x, If[LessEqual[y, 1.45e-168], t, N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.2 \cdot 10^{+114}:\\
\;\;\;\;y \cdot \frac{x}{z}\\
\mathbf{elif}\;y \leq -5.1 \cdot 10^{-95}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq -1.06 \cdot 10^{-172}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{-168}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if y < -3.2e114Initial program 61.0%
associate-*l/92.3%
Simplified92.3%
Taylor expanded in z around inf 44.3%
associate--l+44.3%
associate-*r/44.3%
associate-*r/44.3%
div-sub44.3%
distribute-lft-out--44.3%
mul-1-neg44.3%
distribute-neg-frac44.3%
distribute-rgt-out--44.7%
unsub-neg44.7%
associate-/l*62.8%
Simplified62.8%
Taylor expanded in t around 0 28.4%
associate-/l*41.9%
associate-/r/41.9%
Simplified41.9%
Taylor expanded in y around inf 28.5%
associate-/l*42.0%
Simplified42.0%
associate-/r/42.0%
Applied egg-rr42.0%
if -3.2e114 < y < -5.1e-95 or -1.05999999999999993e-172 < y < 1.4499999999999999e-168Initial program 60.1%
associate-*l/78.0%
Simplified78.0%
Taylor expanded in z around inf 44.9%
if -5.1e-95 < y < -1.05999999999999993e-172Initial program 87.1%
associate-*l/87.1%
Simplified87.1%
Taylor expanded in a around inf 80.5%
if 1.4499999999999999e-168 < y Initial program 69.2%
associate-*l/83.7%
Simplified83.7%
Taylor expanded in z around inf 41.5%
associate--l+41.5%
associate-*r/41.5%
associate-*r/41.5%
div-sub41.6%
distribute-lft-out--41.6%
mul-1-neg41.6%
distribute-neg-frac41.6%
distribute-rgt-out--43.7%
unsub-neg43.7%
associate-/l*51.0%
Simplified51.0%
Taylor expanded in t around 0 27.5%
associate-/l*32.9%
associate-/r/32.3%
Simplified32.3%
Taylor expanded in y around inf 27.4%
associate-/l*31.7%
Simplified31.7%
Taylor expanded in x around 0 27.4%
associate-/l*31.7%
*-rgt-identity31.7%
associate-*r/31.7%
associate-/r/31.7%
associate-*l/31.7%
*-lft-identity31.7%
Simplified31.7%
Final simplification41.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (/ a (/ z x)))))
(if (<= z -6.4e+150)
t_1
(if (<= z -52000000000000.0)
(* (- y a) (/ x z))
(if (<= z 7.2e+72) (+ x (/ t (/ a y))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -6.4e+150) {
tmp = t_1;
} else if (z <= -52000000000000.0) {
tmp = (y - a) * (x / z);
} else if (z <= 7.2e+72) {
tmp = x + (t / (a / y));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t - (a / (z / x))
if (z <= (-6.4d+150)) then
tmp = t_1
else if (z <= (-52000000000000.0d0)) then
tmp = (y - a) * (x / z)
else if (z <= 7.2d+72) then
tmp = x + (t / (a / y))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a / (z / x));
double tmp;
if (z <= -6.4e+150) {
tmp = t_1;
} else if (z <= -52000000000000.0) {
tmp = (y - a) * (x / z);
} else if (z <= 7.2e+72) {
tmp = x + (t / (a / y));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a / (z / x)) tmp = 0 if z <= -6.4e+150: tmp = t_1 elif z <= -52000000000000.0: tmp = (y - a) * (x / z) elif z <= 7.2e+72: tmp = x + (t / (a / y)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a / Float64(z / x))) tmp = 0.0 if (z <= -6.4e+150) tmp = t_1; elseif (z <= -52000000000000.0) tmp = Float64(Float64(y - a) * Float64(x / z)); elseif (z <= 7.2e+72) tmp = Float64(x + Float64(t / Float64(a / y))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a / (z / x)); tmp = 0.0; if (z <= -6.4e+150) tmp = t_1; elseif (z <= -52000000000000.0) tmp = (y - a) * (x / z); elseif (z <= 7.2e+72) tmp = x + (t / (a / y)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6.4e+150], t$95$1, If[LessEqual[z, -52000000000000.0], N[(N[(y - a), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.2e+72], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{a}{\frac{z}{x}}\\
\mathbf{if}\;z \leq -6.4 \cdot 10^{+150}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -52000000000000:\\
\;\;\;\;\left(y - a\right) \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq 7.2 \cdot 10^{+72}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -6.40000000000000031e150 or 7.20000000000000069e72 < z Initial program 42.0%
associate-*l/69.6%
Simplified69.6%
Taylor expanded in z around inf 65.6%
associate--l+65.6%
associate-*r/65.6%
associate-*r/65.6%
div-sub65.6%
distribute-lft-out--65.6%
mul-1-neg65.6%
distribute-neg-frac65.6%
distribute-rgt-out--65.6%
unsub-neg65.6%
associate-/l*83.3%
Simplified83.3%
Taylor expanded in y around 0 59.2%
associate-*r/59.2%
neg-mul-159.2%
Simplified59.2%
Taylor expanded in t around 0 57.3%
associate-/l*59.1%
Simplified59.1%
if -6.40000000000000031e150 < z < -5.2e13Initial program 49.4%
associate-*l/78.3%
Simplified78.3%
Taylor expanded in z around inf 53.1%
associate--l+53.1%
associate-*r/53.1%
associate-*r/53.1%
div-sub53.1%
distribute-lft-out--53.1%
mul-1-neg53.1%
distribute-neg-frac53.1%
distribute-rgt-out--53.1%
unsub-neg53.1%
associate-/l*63.0%
Simplified63.0%
Taylor expanded in t around 0 36.8%
associate-/l*40.4%
associate-/r/40.4%
Simplified40.4%
if -5.2e13 < z < 7.20000000000000069e72Initial program 82.2%
associate-*l/92.0%
Simplified92.0%
Taylor expanded in z around 0 60.6%
associate-/l*69.8%
Simplified69.8%
Taylor expanded in t around inf 50.7%
associate-/l*56.4%
Simplified56.4%
Final simplification55.5%
(FPCore (x y z t a) :precision binary64 (if (<= z -34000000000000.0) (* (- y a) (/ x z)) (if (<= z 3.2e+73) (+ x (/ t (/ a y))) (+ t (/ a (/ z t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -34000000000000.0) {
tmp = (y - a) * (x / z);
} else if (z <= 3.2e+73) {
tmp = x + (t / (a / y));
} else {
tmp = t + (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 <= (-34000000000000.0d0)) then
tmp = (y - a) * (x / z)
else if (z <= 3.2d+73) then
tmp = x + (t / (a / y))
else
tmp = t + (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 <= -34000000000000.0) {
tmp = (y - a) * (x / z);
} else if (z <= 3.2e+73) {
tmp = x + (t / (a / y));
} else {
tmp = t + (a / (z / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -34000000000000.0: tmp = (y - a) * (x / z) elif z <= 3.2e+73: tmp = x + (t / (a / y)) else: tmp = t + (a / (z / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -34000000000000.0) tmp = Float64(Float64(y - a) * Float64(x / z)); elseif (z <= 3.2e+73) tmp = Float64(x + Float64(t / Float64(a / y))); else tmp = Float64(t + Float64(a / Float64(z / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -34000000000000.0) tmp = (y - a) * (x / z); elseif (z <= 3.2e+73) tmp = x + (t / (a / y)); else tmp = t + (a / (z / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -34000000000000.0], N[(N[(y - a), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e+73], N[(x + N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(a / N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -34000000000000:\\
\;\;\;\;\left(y - a\right) \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+73}:\\
\;\;\;\;x + \frac{t}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{a}{\frac{z}{t}}\\
\end{array}
\end{array}
if z < -3.4e13Initial program 36.2%
associate-*l/69.5%
Simplified69.5%
Taylor expanded in z around inf 60.1%
associate--l+60.1%
associate-*r/60.1%
associate-*r/60.1%
div-sub60.1%
distribute-lft-out--60.1%
mul-1-neg60.1%
distribute-neg-frac60.1%
distribute-rgt-out--60.2%
unsub-neg60.2%
associate-/l*76.2%
Simplified76.2%
Taylor expanded in t around 0 29.3%
associate-/l*41.0%
associate-/r/42.4%
Simplified42.4%
if -3.4e13 < z < 3.19999999999999982e73Initial program 82.2%
associate-*l/92.0%
Simplified92.0%
Taylor expanded in z around 0 60.6%
associate-/l*69.8%
Simplified69.8%
Taylor expanded in t around inf 50.7%
associate-/l*56.4%
Simplified56.4%
if 3.19999999999999982e73 < z Initial program 53.6%
associate-*l/74.7%
Simplified74.7%
Taylor expanded in z around inf 65.2%
associate--l+65.2%
associate-*r/65.2%
associate-*r/65.2%
div-sub65.2%
distribute-lft-out--65.2%
mul-1-neg65.2%
distribute-neg-frac65.2%
distribute-rgt-out--65.2%
unsub-neg65.2%
associate-/l*80.4%
Simplified80.4%
Taylor expanded in y around 0 57.2%
associate-*r/57.2%
neg-mul-157.2%
Simplified57.2%
Taylor expanded in x around 0 51.5%
sub-neg51.5%
mul-1-neg51.5%
remove-double-neg51.5%
associate-/l*53.5%
Simplified53.5%
Final simplification52.4%
(FPCore (x y z t a) :precision binary64 (if (<= a -1e+184) x (if (<= a -4.8e+95) t (if (<= a -7.8e+37) x (if (<= a 1.2e-41) t x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1e+184) {
tmp = x;
} else if (a <= -4.8e+95) {
tmp = t;
} else if (a <= -7.8e+37) {
tmp = x;
} else if (a <= 1.2e-41) {
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 <= (-1d+184)) then
tmp = x
else if (a <= (-4.8d+95)) then
tmp = t
else if (a <= (-7.8d+37)) then
tmp = x
else if (a <= 1.2d-41) 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 <= -1e+184) {
tmp = x;
} else if (a <= -4.8e+95) {
tmp = t;
} else if (a <= -7.8e+37) {
tmp = x;
} else if (a <= 1.2e-41) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1e+184: tmp = x elif a <= -4.8e+95: tmp = t elif a <= -7.8e+37: tmp = x elif a <= 1.2e-41: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1e+184) tmp = x; elseif (a <= -4.8e+95) tmp = t; elseif (a <= -7.8e+37) tmp = x; elseif (a <= 1.2e-41) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1e+184) tmp = x; elseif (a <= -4.8e+95) tmp = t; elseif (a <= -7.8e+37) tmp = x; elseif (a <= 1.2e-41) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1e+184], x, If[LessEqual[a, -4.8e+95], t, If[LessEqual[a, -7.8e+37], x, If[LessEqual[a, 1.2e-41], t, x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1 \cdot 10^{+184}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -4.8 \cdot 10^{+95}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq -7.8 \cdot 10^{+37}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-41}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -1.00000000000000002e184 or -4.8000000000000001e95 < a < -7.7999999999999997e37 or 1.20000000000000011e-41 < a Initial program 69.1%
associate-*l/92.9%
Simplified92.9%
Taylor expanded in a around inf 48.4%
if -1.00000000000000002e184 < a < -4.8000000000000001e95 or -7.7999999999999997e37 < a < 1.20000000000000011e-41Initial program 62.7%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in z around inf 36.6%
Final simplification41.5%
(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 65.3%
associate-*l/83.1%
Simplified83.1%
Taylor expanded in z around inf 24.5%
Final simplification24.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 2023271
(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))))