
(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 29 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
(FPCore (x y z t a) :precision binary64 (if (or (<= z -3.6e+112) (not (<= z 6e+76))) (+ t (/ (- x t) (/ z (- y a)))) (fma (/ (- y z) (- a z)) (- t x) x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -3.6e+112) || !(z <= 6e+76)) {
tmp = t + ((x - t) / (z / (y - a)));
} else {
tmp = fma(((y - z) / (a - z)), (t - x), x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -3.6e+112) || !(z <= 6e+76)) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); else tmp = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x); end return tmp end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -3.6e+112], N[Not[LessEqual[z, 6e+76]], $MachinePrecision]], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.6 \cdot 10^{+112} \lor \neg \left(z \leq 6 \cdot 10^{+76}\right):\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
\end{array}
\end{array}
if z < -3.6e112 or 5.9999999999999996e76 < z Initial program 35.2%
associate-*l/56.5%
Simplified56.5%
Taylor expanded in z around inf 67.8%
associate--l+67.8%
associate-*r/67.8%
associate-*r/67.8%
div-sub67.8%
distribute-lft-out--67.8%
associate-*r/67.8%
mul-1-neg67.8%
distribute-rgt-out--68.9%
unsub-neg68.9%
associate-/l*86.5%
Simplified86.5%
if -3.6e112 < z < 5.9999999999999996e76Initial program 85.2%
+-commutative85.2%
associate-*l/93.6%
fma-def93.6%
Simplified93.6%
Final simplification91.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (- 1.0 (/ y z)))) (t_2 (* x (- 1.0 (/ y a)))))
(if (<= a -4.8e-37)
t_2
(if (<= a -1.2e-276)
t_1
(if (<= a 3.1e-291)
(/ x (/ z y))
(if (<= a 5e-106)
t_1
(if (<= a 1.95e-75)
t_2
(if (<= a 3.85e-50)
(/ t (/ (- a z) y))
(if (<= a 2.9e+75) (* y (/ (- x) (- a z))) t_2)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -4.8e-37) {
tmp = t_2;
} else if (a <= -1.2e-276) {
tmp = t_1;
} else if (a <= 3.1e-291) {
tmp = x / (z / y);
} else if (a <= 5e-106) {
tmp = t_1;
} else if (a <= 1.95e-75) {
tmp = t_2;
} else if (a <= 3.85e-50) {
tmp = t / ((a - z) / y);
} else if (a <= 2.9e+75) {
tmp = y * (-x / (a - z));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * (1.0d0 - (y / z))
t_2 = x * (1.0d0 - (y / a))
if (a <= (-4.8d-37)) then
tmp = t_2
else if (a <= (-1.2d-276)) then
tmp = t_1
else if (a <= 3.1d-291) then
tmp = x / (z / y)
else if (a <= 5d-106) then
tmp = t_1
else if (a <= 1.95d-75) then
tmp = t_2
else if (a <= 3.85d-50) then
tmp = t / ((a - z) / y)
else if (a <= 2.9d+75) then
tmp = y * (-x / (a - z))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -4.8e-37) {
tmp = t_2;
} else if (a <= -1.2e-276) {
tmp = t_1;
} else if (a <= 3.1e-291) {
tmp = x / (z / y);
} else if (a <= 5e-106) {
tmp = t_1;
} else if (a <= 1.95e-75) {
tmp = t_2;
} else if (a <= 3.85e-50) {
tmp = t / ((a - z) / y);
} else if (a <= 2.9e+75) {
tmp = y * (-x / (a - z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (1.0 - (y / z)) t_2 = x * (1.0 - (y / a)) tmp = 0 if a <= -4.8e-37: tmp = t_2 elif a <= -1.2e-276: tmp = t_1 elif a <= 3.1e-291: tmp = x / (z / y) elif a <= 5e-106: tmp = t_1 elif a <= 1.95e-75: tmp = t_2 elif a <= 3.85e-50: tmp = t / ((a - z) / y) elif a <= 2.9e+75: tmp = y * (-x / (a - z)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(1.0 - Float64(y / z))) t_2 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (a <= -4.8e-37) tmp = t_2; elseif (a <= -1.2e-276) tmp = t_1; elseif (a <= 3.1e-291) tmp = Float64(x / Float64(z / y)); elseif (a <= 5e-106) tmp = t_1; elseif (a <= 1.95e-75) tmp = t_2; elseif (a <= 3.85e-50) tmp = Float64(t / Float64(Float64(a - z) / y)); elseif (a <= 2.9e+75) tmp = Float64(y * Float64(Float64(-x) / Float64(a - z))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (1.0 - (y / z)); t_2 = x * (1.0 - (y / a)); tmp = 0.0; if (a <= -4.8e-37) tmp = t_2; elseif (a <= -1.2e-276) tmp = t_1; elseif (a <= 3.1e-291) tmp = x / (z / y); elseif (a <= 5e-106) tmp = t_1; elseif (a <= 1.95e-75) tmp = t_2; elseif (a <= 3.85e-50) tmp = t / ((a - z) / y); elseif (a <= 2.9e+75) tmp = y * (-x / (a - z)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.8e-37], t$95$2, If[LessEqual[a, -1.2e-276], t$95$1, If[LessEqual[a, 3.1e-291], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5e-106], t$95$1, If[LessEqual[a, 1.95e-75], t$95$2, If[LessEqual[a, 3.85e-50], N[(t / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e+75], N[(y * N[((-x) / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(1 - \frac{y}{z}\right)\\
t_2 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;a \leq -4.8 \cdot 10^{-37}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -1.2 \cdot 10^{-276}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 3.1 \cdot 10^{-291}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 5 \cdot 10^{-106}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.95 \cdot 10^{-75}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 3.85 \cdot 10^{-50}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y}}\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{+75}:\\
\;\;\;\;y \cdot \frac{-x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -4.79999999999999982e-37 or 4.99999999999999983e-106 < a < 1.9500000000000001e-75 or 2.8999999999999998e75 < a Initial program 70.9%
associate-*l/89.7%
Simplified89.7%
Taylor expanded in z around 0 72.4%
Taylor expanded in x around inf 58.5%
mul-1-neg58.5%
unsub-neg58.5%
Simplified58.5%
if -4.79999999999999982e-37 < a < -1.19999999999999991e-276 or 3.10000000000000011e-291 < a < 4.99999999999999983e-106Initial program 62.2%
associate-*l/70.5%
Simplified70.5%
Taylor expanded in z around inf 83.2%
associate--l+83.2%
associate-*r/83.2%
associate-*r/83.2%
div-sub83.2%
distribute-lft-out--83.2%
associate-*r/83.2%
mul-1-neg83.2%
distribute-rgt-out--83.2%
unsub-neg83.2%
associate-/l*87.6%
Simplified87.6%
Taylor expanded in y around inf 83.3%
Taylor expanded in t around inf 63.7%
if -1.19999999999999991e-276 < a < 3.10000000000000011e-291Initial program 67.8%
associate-*l/74.1%
Simplified74.1%
Taylor expanded in z around inf 93.4%
associate--l+93.4%
associate-*r/93.4%
associate-*r/93.4%
div-sub93.4%
distribute-lft-out--93.4%
associate-*r/93.4%
mul-1-neg93.4%
distribute-rgt-out--93.4%
unsub-neg93.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in t around 0 74.2%
associate-/l*80.8%
Simplified80.8%
if 1.9500000000000001e-75 < a < 3.84999999999999982e-50Initial program 76.8%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in x around 0 76.8%
associate-/l*99.6%
Simplified99.6%
Taylor expanded in y around inf 75.2%
if 3.84999999999999982e-50 < a < 2.8999999999999998e75Initial program 69.3%
associate-*l/72.6%
Simplified72.6%
Taylor expanded in y around inf 61.3%
div-sub61.3%
Simplified61.3%
Taylor expanded in t around 0 42.9%
neg-mul-142.9%
distribute-neg-frac42.9%
Simplified42.9%
Final simplification60.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (- 1.0 (/ y z)))) (t_2 (* x (- 1.0 (/ y a)))))
(if (<= a -5.5e-32)
t_2
(if (<= a -2.1e-276)
t_1
(if (<= a 1.05e-289)
(* y (/ (- x t) z))
(if (<= a 7.2e-107)
t_1
(if (<= a 2.5e-75)
t_2
(if (<= a 7.2e-52)
(/ t (/ (- a z) y))
(if (<= a 1.35e+61) (* y (/ (- x) (- a z))) t_2)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -5.5e-32) {
tmp = t_2;
} else if (a <= -2.1e-276) {
tmp = t_1;
} else if (a <= 1.05e-289) {
tmp = y * ((x - t) / z);
} else if (a <= 7.2e-107) {
tmp = t_1;
} else if (a <= 2.5e-75) {
tmp = t_2;
} else if (a <= 7.2e-52) {
tmp = t / ((a - z) / y);
} else if (a <= 1.35e+61) {
tmp = y * (-x / (a - z));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * (1.0d0 - (y / z))
t_2 = x * (1.0d0 - (y / a))
if (a <= (-5.5d-32)) then
tmp = t_2
else if (a <= (-2.1d-276)) then
tmp = t_1
else if (a <= 1.05d-289) then
tmp = y * ((x - t) / z)
else if (a <= 7.2d-107) then
tmp = t_1
else if (a <= 2.5d-75) then
tmp = t_2
else if (a <= 7.2d-52) then
tmp = t / ((a - z) / y)
else if (a <= 1.35d+61) then
tmp = y * (-x / (a - z))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -5.5e-32) {
tmp = t_2;
} else if (a <= -2.1e-276) {
tmp = t_1;
} else if (a <= 1.05e-289) {
tmp = y * ((x - t) / z);
} else if (a <= 7.2e-107) {
tmp = t_1;
} else if (a <= 2.5e-75) {
tmp = t_2;
} else if (a <= 7.2e-52) {
tmp = t / ((a - z) / y);
} else if (a <= 1.35e+61) {
tmp = y * (-x / (a - z));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (1.0 - (y / z)) t_2 = x * (1.0 - (y / a)) tmp = 0 if a <= -5.5e-32: tmp = t_2 elif a <= -2.1e-276: tmp = t_1 elif a <= 1.05e-289: tmp = y * ((x - t) / z) elif a <= 7.2e-107: tmp = t_1 elif a <= 2.5e-75: tmp = t_2 elif a <= 7.2e-52: tmp = t / ((a - z) / y) elif a <= 1.35e+61: tmp = y * (-x / (a - z)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(1.0 - Float64(y / z))) t_2 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (a <= -5.5e-32) tmp = t_2; elseif (a <= -2.1e-276) tmp = t_1; elseif (a <= 1.05e-289) tmp = Float64(y * Float64(Float64(x - t) / z)); elseif (a <= 7.2e-107) tmp = t_1; elseif (a <= 2.5e-75) tmp = t_2; elseif (a <= 7.2e-52) tmp = Float64(t / Float64(Float64(a - z) / y)); elseif (a <= 1.35e+61) tmp = Float64(y * Float64(Float64(-x) / Float64(a - z))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (1.0 - (y / z)); t_2 = x * (1.0 - (y / a)); tmp = 0.0; if (a <= -5.5e-32) tmp = t_2; elseif (a <= -2.1e-276) tmp = t_1; elseif (a <= 1.05e-289) tmp = y * ((x - t) / z); elseif (a <= 7.2e-107) tmp = t_1; elseif (a <= 2.5e-75) tmp = t_2; elseif (a <= 7.2e-52) tmp = t / ((a - z) / y); elseif (a <= 1.35e+61) tmp = y * (-x / (a - z)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -5.5e-32], t$95$2, If[LessEqual[a, -2.1e-276], t$95$1, If[LessEqual[a, 1.05e-289], N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.2e-107], t$95$1, If[LessEqual[a, 2.5e-75], t$95$2, If[LessEqual[a, 7.2e-52], N[(t / N[(N[(a - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+61], N[(y * N[((-x) / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(1 - \frac{y}{z}\right)\\
t_2 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;a \leq -5.5 \cdot 10^{-32}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -2.1 \cdot 10^{-276}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.05 \cdot 10^{-289}:\\
\;\;\;\;y \cdot \frac{x - t}{z}\\
\mathbf{elif}\;a \leq 7.2 \cdot 10^{-107}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.5 \cdot 10^{-75}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 7.2 \cdot 10^{-52}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y}}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{+61}:\\
\;\;\;\;y \cdot \frac{-x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -5.50000000000000024e-32 or 7.19999999999999953e-107 < a < 2.49999999999999989e-75 or 1.3500000000000001e61 < a Initial program 70.9%
associate-*l/89.7%
Simplified89.7%
Taylor expanded in z around 0 72.4%
Taylor expanded in x around inf 58.5%
mul-1-neg58.5%
unsub-neg58.5%
Simplified58.5%
if -5.50000000000000024e-32 < a < -2.1e-276 or 1.0499999999999999e-289 < a < 7.19999999999999953e-107Initial program 62.2%
associate-*l/70.5%
Simplified70.5%
Taylor expanded in z around inf 83.2%
associate--l+83.2%
associate-*r/83.2%
associate-*r/83.2%
div-sub83.2%
distribute-lft-out--83.2%
associate-*r/83.2%
mul-1-neg83.2%
distribute-rgt-out--83.2%
unsub-neg83.2%
associate-/l*87.6%
Simplified87.6%
Taylor expanded in y around inf 83.3%
Taylor expanded in t around inf 63.7%
if -2.1e-276 < a < 1.0499999999999999e-289Initial program 67.8%
associate-*l/74.1%
Simplified74.1%
Taylor expanded in z around inf 93.4%
associate--l+93.4%
associate-*r/93.4%
associate-*r/93.4%
div-sub93.4%
distribute-lft-out--93.4%
associate-*r/93.4%
mul-1-neg93.4%
distribute-rgt-out--93.4%
unsub-neg93.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in z around 0 80.7%
associate-*r/81.2%
neg-mul-181.2%
distribute-rgt-neg-in81.2%
distribute-neg-frac81.2%
neg-sub081.2%
associate--r-81.2%
neg-sub081.2%
Simplified81.2%
if 2.49999999999999989e-75 < a < 7.19999999999999976e-52Initial program 76.8%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in x around 0 76.8%
associate-/l*99.6%
Simplified99.6%
Taylor expanded in y around inf 75.2%
if 7.19999999999999976e-52 < a < 1.3500000000000001e61Initial program 69.3%
associate-*l/72.6%
Simplified72.6%
Taylor expanded in y around inf 61.3%
div-sub61.3%
Simplified61.3%
Taylor expanded in t around 0 42.9%
neg-mul-142.9%
distribute-neg-frac42.9%
Simplified42.9%
Final simplification60.4%
(FPCore (x y z t a)
:precision binary64
(if (<= y -3.8e+132)
(/ t (/ (- z) y))
(if (<= y -1.2e-284)
t
(if (<= y 7e+27)
x
(if (<= y 2e+104)
(/ x (/ z y))
(if (<= y 3.65e+183)
(/ t (/ a y))
(if (<= y 3.1e+231)
(/ (* x (- y)) a)
(if (<= y 1.95e+265) (* x (/ y z)) (* x (/ (- y) a))))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -3.8e+132) {
tmp = t / (-z / y);
} else if (y <= -1.2e-284) {
tmp = t;
} else if (y <= 7e+27) {
tmp = x;
} else if (y <= 2e+104) {
tmp = x / (z / y);
} else if (y <= 3.65e+183) {
tmp = t / (a / y);
} else if (y <= 3.1e+231) {
tmp = (x * -y) / a;
} else if (y <= 1.95e+265) {
tmp = x * (y / z);
} else {
tmp = x * (-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 (y <= (-3.8d+132)) then
tmp = t / (-z / y)
else if (y <= (-1.2d-284)) then
tmp = t
else if (y <= 7d+27) then
tmp = x
else if (y <= 2d+104) then
tmp = x / (z / y)
else if (y <= 3.65d+183) then
tmp = t / (a / y)
else if (y <= 3.1d+231) then
tmp = (x * -y) / a
else if (y <= 1.95d+265) then
tmp = x * (y / z)
else
tmp = x * (-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 (y <= -3.8e+132) {
tmp = t / (-z / y);
} else if (y <= -1.2e-284) {
tmp = t;
} else if (y <= 7e+27) {
tmp = x;
} else if (y <= 2e+104) {
tmp = x / (z / y);
} else if (y <= 3.65e+183) {
tmp = t / (a / y);
} else if (y <= 3.1e+231) {
tmp = (x * -y) / a;
} else if (y <= 1.95e+265) {
tmp = x * (y / z);
} else {
tmp = x * (-y / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -3.8e+132: tmp = t / (-z / y) elif y <= -1.2e-284: tmp = t elif y <= 7e+27: tmp = x elif y <= 2e+104: tmp = x / (z / y) elif y <= 3.65e+183: tmp = t / (a / y) elif y <= 3.1e+231: tmp = (x * -y) / a elif y <= 1.95e+265: tmp = x * (y / z) else: tmp = x * (-y / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -3.8e+132) tmp = Float64(t / Float64(Float64(-z) / y)); elseif (y <= -1.2e-284) tmp = t; elseif (y <= 7e+27) tmp = x; elseif (y <= 2e+104) tmp = Float64(x / Float64(z / y)); elseif (y <= 3.65e+183) tmp = Float64(t / Float64(a / y)); elseif (y <= 3.1e+231) tmp = Float64(Float64(x * Float64(-y)) / a); elseif (y <= 1.95e+265) tmp = Float64(x * Float64(y / z)); else tmp = Float64(x * Float64(Float64(-y) / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -3.8e+132) tmp = t / (-z / y); elseif (y <= -1.2e-284) tmp = t; elseif (y <= 7e+27) tmp = x; elseif (y <= 2e+104) tmp = x / (z / y); elseif (y <= 3.65e+183) tmp = t / (a / y); elseif (y <= 3.1e+231) tmp = (x * -y) / a; elseif (y <= 1.95e+265) tmp = x * (y / z); else tmp = x * (-y / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -3.8e+132], N[(t / N[((-z) / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.2e-284], t, If[LessEqual[y, 7e+27], x, If[LessEqual[y, 2e+104], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.65e+183], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.1e+231], N[(N[(x * (-y)), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[y, 1.95e+265], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(x * N[((-y) / a), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.8 \cdot 10^{+132}:\\
\;\;\;\;\frac{t}{\frac{-z}{y}}\\
\mathbf{elif}\;y \leq -1.2 \cdot 10^{-284}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 7 \cdot 10^{+27}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+104}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq 3.65 \cdot 10^{+183}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\mathbf{elif}\;y \leq 3.1 \cdot 10^{+231}:\\
\;\;\;\;\frac{x \cdot \left(-y\right)}{a}\\
\mathbf{elif}\;y \leq 1.95 \cdot 10^{+265}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{-y}{a}\\
\end{array}
\end{array}
if y < -3.80000000000000006e132Initial program 65.6%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in x around 0 30.5%
associate-/l*53.1%
Simplified53.1%
Taylor expanded in y around inf 52.0%
Taylor expanded in a around 0 38.2%
mul-1-neg38.2%
distribute-frac-neg38.2%
Simplified38.2%
if -3.80000000000000006e132 < y < -1.20000000000000001e-284Initial program 57.3%
associate-*l/68.1%
Simplified68.1%
Taylor expanded in z around inf 39.0%
if -1.20000000000000001e-284 < y < 7.0000000000000004e27Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
if 7.0000000000000004e27 < y < 2e104Initial program 60.9%
associate-*l/74.5%
Simplified74.5%
Taylor expanded in z around inf 53.7%
associate--l+53.7%
associate-*r/53.7%
associate-*r/53.7%
div-sub53.7%
distribute-lft-out--53.7%
associate-*r/53.7%
mul-1-neg53.7%
distribute-rgt-out--53.7%
unsub-neg53.7%
associate-/l*59.4%
Simplified59.4%
Taylor expanded in y around inf 58.8%
Taylor expanded in t around 0 35.9%
associate-/l*39.4%
Simplified39.4%
if 2e104 < y < 3.6499999999999999e183Initial program 74.5%
associate-*l/99.7%
Simplified99.7%
Taylor expanded in x around 0 65.4%
associate-/l*90.6%
Simplified90.6%
Taylor expanded in z around 0 77.3%
if 3.6499999999999999e183 < y < 3.0999999999999999e231Initial program 99.5%
associate-*l/90.5%
Simplified90.5%
Taylor expanded in z around 0 80.5%
Taylor expanded in t around 0 80.0%
mul-1-neg80.0%
Simplified80.0%
Taylor expanded in y around inf 80.0%
if 3.0999999999999999e231 < y < 1.9500000000000001e265Initial program 85.4%
associate-*l/88.3%
Simplified88.3%
Taylor expanded in z around inf 51.4%
associate--l+51.4%
associate-*r/51.4%
associate-*r/51.4%
div-sub51.7%
distribute-lft-out--51.7%
associate-*r/51.7%
mul-1-neg51.7%
distribute-rgt-out--51.7%
unsub-neg51.7%
associate-/l*65.2%
Simplified65.2%
Taylor expanded in y around inf 65.2%
Taylor expanded in t around 0 37.4%
associate-*r/51.0%
Simplified51.0%
if 1.9500000000000001e265 < y Initial program 53.6%
associate-*l/99.6%
Simplified99.6%
Taylor expanded in z around 0 68.7%
Taylor expanded in t around 0 28.1%
mul-1-neg28.1%
Simplified28.1%
Taylor expanded in y around inf 28.1%
mul-1-neg28.1%
associate-*r/56.3%
*-commutative56.3%
distribute-rgt-neg-in56.3%
Simplified56.3%
Final simplification44.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (- 1.0 (/ y a)))))
(if (<= a -9.6e-19)
t_1
(if (<= a 9.5e-245)
(+ t (* x (/ y z)))
(if (<= a 1.95e-160)
(* t (- 1.0 (/ y z)))
(if (<= a 2.1e+76)
(* y (/ (- t x) (- a z)))
(if (or (<= a 4e+119) (not (<= a 9e+165)))
t_1
(* (- y z) (/ t (- a z))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (1.0 - (y / a));
double tmp;
if (a <= -9.6e-19) {
tmp = t_1;
} else if (a <= 9.5e-245) {
tmp = t + (x * (y / z));
} else if (a <= 1.95e-160) {
tmp = t * (1.0 - (y / z));
} else if (a <= 2.1e+76) {
tmp = y * ((t - x) / (a - z));
} else if ((a <= 4e+119) || !(a <= 9e+165)) {
tmp = t_1;
} else {
tmp = (y - z) * (t / (a - z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x * (1.0d0 - (y / a))
if (a <= (-9.6d-19)) then
tmp = t_1
else if (a <= 9.5d-245) then
tmp = t + (x * (y / z))
else if (a <= 1.95d-160) then
tmp = t * (1.0d0 - (y / z))
else if (a <= 2.1d+76) then
tmp = y * ((t - x) / (a - z))
else if ((a <= 4d+119) .or. (.not. (a <= 9d+165))) then
tmp = t_1
else
tmp = (y - z) * (t / (a - z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (1.0 - (y / a));
double tmp;
if (a <= -9.6e-19) {
tmp = t_1;
} else if (a <= 9.5e-245) {
tmp = t + (x * (y / z));
} else if (a <= 1.95e-160) {
tmp = t * (1.0 - (y / z));
} else if (a <= 2.1e+76) {
tmp = y * ((t - x) / (a - z));
} else if ((a <= 4e+119) || !(a <= 9e+165)) {
tmp = t_1;
} else {
tmp = (y - z) * (t / (a - z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (1.0 - (y / a)) tmp = 0 if a <= -9.6e-19: tmp = t_1 elif a <= 9.5e-245: tmp = t + (x * (y / z)) elif a <= 1.95e-160: tmp = t * (1.0 - (y / z)) elif a <= 2.1e+76: tmp = y * ((t - x) / (a - z)) elif (a <= 4e+119) or not (a <= 9e+165): tmp = t_1 else: tmp = (y - z) * (t / (a - z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (a <= -9.6e-19) tmp = t_1; elseif (a <= 9.5e-245) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 1.95e-160) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (a <= 2.1e+76) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif ((a <= 4e+119) || !(a <= 9e+165)) tmp = t_1; else tmp = Float64(Float64(y - z) * Float64(t / Float64(a - z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (1.0 - (y / a)); tmp = 0.0; if (a <= -9.6e-19) tmp = t_1; elseif (a <= 9.5e-245) tmp = t + (x * (y / z)); elseif (a <= 1.95e-160) tmp = t * (1.0 - (y / z)); elseif (a <= 2.1e+76) tmp = y * ((t - x) / (a - z)); elseif ((a <= 4e+119) || ~((a <= 9e+165))) tmp = t_1; else tmp = (y - z) * (t / (a - z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -9.6e-19], t$95$1, If[LessEqual[a, 9.5e-245], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.95e-160], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.1e+76], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, 4e+119], N[Not[LessEqual[a, 9e+165]], $MachinePrecision]], t$95$1, N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;a \leq -9.6 \cdot 10^{-19}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 9.5 \cdot 10^{-245}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 1.95 \cdot 10^{-160}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{+76}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 4 \cdot 10^{+119} \lor \neg \left(a \leq 9 \cdot 10^{+165}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a - z}\\
\end{array}
\end{array}
if a < -9.60000000000000092e-19 or 2.10000000000000007e76 < a < 3.99999999999999978e119 or 8.9999999999999993e165 < a Initial program 73.7%
associate-*l/91.9%
Simplified91.9%
Taylor expanded in z around 0 75.4%
Taylor expanded in x around inf 63.1%
mul-1-neg63.1%
unsub-neg63.1%
Simplified63.1%
if -9.60000000000000092e-19 < a < 9.5000000000000002e-245Initial program 61.0%
associate-*l/68.4%
Simplified68.4%
Taylor expanded in z around inf 82.8%
associate--l+82.8%
associate-*r/82.8%
associate-*r/82.8%
div-sub82.8%
distribute-lft-out--82.8%
associate-*r/82.8%
mul-1-neg82.8%
distribute-rgt-out--82.8%
unsub-neg82.8%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in y around inf 84.1%
Taylor expanded in t around 0 73.0%
associate-*r/76.6%
neg-mul-176.6%
distribute-rgt-neg-in76.6%
distribute-neg-frac76.6%
Simplified76.6%
if 9.5000000000000002e-245 < a < 1.94999999999999995e-160Initial program 78.7%
associate-*l/84.0%
Simplified84.0%
Taylor expanded in z around inf 83.8%
associate--l+83.8%
associate-*r/83.8%
associate-*r/83.8%
div-sub83.8%
distribute-lft-out--83.8%
associate-*r/83.8%
mul-1-neg83.8%
distribute-rgt-out--83.8%
unsub-neg83.8%
associate-/l*88.8%
Simplified88.8%
Taylor expanded in y around inf 88.8%
Taylor expanded in t around inf 88.8%
if 1.94999999999999995e-160 < a < 2.10000000000000007e76Initial program 67.5%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in y around inf 64.5%
div-sub64.5%
Simplified64.5%
if 3.99999999999999978e119 < a < 8.9999999999999993e165Initial program 48.9%
associate-*l/84.9%
Simplified84.9%
Taylor expanded in x around 0 40.6%
associate-/l*69.7%
Simplified69.7%
associate-/r/69.7%
Applied egg-rr69.7%
Final simplification69.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ y a))) (t_2 (* x (/ y z))))
(if (<= y -1.26e+239)
t_2
(if (<= y -6.2e+144)
t_1
(if (<= y -1.9e-286)
t
(if (<= y 1.95e+28)
x
(if (or (<= y 1.45e+105) (not (<= y 4.7e+232))) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (y / a);
double t_2 = x * (y / z);
double tmp;
if (y <= -1.26e+239) {
tmp = t_2;
} else if (y <= -6.2e+144) {
tmp = t_1;
} else if (y <= -1.9e-286) {
tmp = t;
} else if (y <= 1.95e+28) {
tmp = x;
} else if ((y <= 1.45e+105) || !(y <= 4.7e+232)) {
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 * (y / a)
t_2 = x * (y / z)
if (y <= (-1.26d+239)) then
tmp = t_2
else if (y <= (-6.2d+144)) then
tmp = t_1
else if (y <= (-1.9d-286)) then
tmp = t
else if (y <= 1.95d+28) then
tmp = x
else if ((y <= 1.45d+105) .or. (.not. (y <= 4.7d+232))) 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 * (y / a);
double t_2 = x * (y / z);
double tmp;
if (y <= -1.26e+239) {
tmp = t_2;
} else if (y <= -6.2e+144) {
tmp = t_1;
} else if (y <= -1.9e-286) {
tmp = t;
} else if (y <= 1.95e+28) {
tmp = x;
} else if ((y <= 1.45e+105) || !(y <= 4.7e+232)) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (y / a) t_2 = x * (y / z) tmp = 0 if y <= -1.26e+239: tmp = t_2 elif y <= -6.2e+144: tmp = t_1 elif y <= -1.9e-286: tmp = t elif y <= 1.95e+28: tmp = x elif (y <= 1.45e+105) or not (y <= 4.7e+232): tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(y / a)) t_2 = Float64(x * Float64(y / z)) tmp = 0.0 if (y <= -1.26e+239) tmp = t_2; elseif (y <= -6.2e+144) tmp = t_1; elseif (y <= -1.9e-286) tmp = t; elseif (y <= 1.95e+28) tmp = x; elseif ((y <= 1.45e+105) || !(y <= 4.7e+232)) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (y / a); t_2 = x * (y / z); tmp = 0.0; if (y <= -1.26e+239) tmp = t_2; elseif (y <= -6.2e+144) tmp = t_1; elseif (y <= -1.9e-286) tmp = t; elseif (y <= 1.95e+28) tmp = x; elseif ((y <= 1.45e+105) || ~((y <= 4.7e+232))) 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[(y / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.26e+239], t$95$2, If[LessEqual[y, -6.2e+144], t$95$1, If[LessEqual[y, -1.9e-286], t, If[LessEqual[y, 1.95e+28], x, If[Or[LessEqual[y, 1.45e+105], N[Not[LessEqual[y, 4.7e+232]], $MachinePrecision]], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y}{a}\\
t_2 := x \cdot \frac{y}{z}\\
\mathbf{if}\;y \leq -1.26 \cdot 10^{+239}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -6.2 \cdot 10^{+144}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.9 \cdot 10^{-286}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 1.95 \cdot 10^{+28}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{+105} \lor \neg \left(y \leq 4.7 \cdot 10^{+232}\right):\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -1.25999999999999999e239 or 1.9499999999999999e28 < y < 1.45000000000000005e105 or 4.69999999999999992e232 < y Initial program 66.7%
associate-*l/86.4%
Simplified86.4%
Taylor expanded in z around inf 55.6%
associate--l+55.6%
associate-*r/55.6%
associate-*r/55.6%
div-sub55.7%
distribute-lft-out--55.7%
associate-*r/55.7%
mul-1-neg55.7%
distribute-rgt-out--55.8%
unsub-neg55.8%
associate-/l*62.9%
Simplified62.9%
Taylor expanded in y around inf 62.6%
Taylor expanded in t around 0 39.1%
associate-*r/45.2%
Simplified45.2%
if -1.25999999999999999e239 < y < -6.2000000000000003e144 or 1.45000000000000005e105 < y < 4.69999999999999992e232Initial program 77.4%
associate-*l/94.8%
Simplified94.8%
Taylor expanded in x around 0 41.5%
associate-/l*58.7%
Simplified58.7%
Taylor expanded in z around 0 54.0%
Taylor expanded in t around 0 43.2%
associate-*r/53.9%
Simplified53.9%
if -6.2000000000000003e144 < y < -1.9000000000000001e-286Initial program 57.2%
associate-*l/68.9%
Simplified68.9%
Taylor expanded in z around inf 38.2%
if -1.9000000000000001e-286 < y < 1.9499999999999999e28Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
Final simplification43.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* x (/ y z))))
(if (<= y -9.6e+236)
t_1
(if (<= y -4.3e+144)
(* t (/ y a))
(if (<= y -6.8e-288)
t
(if (<= y 1.06e+28)
x
(if (or (<= y 5e+105) (not (<= y 5.6e+232)))
t_1
(* y (/ t a)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x * (y / z);
double tmp;
if (y <= -9.6e+236) {
tmp = t_1;
} else if (y <= -4.3e+144) {
tmp = t * (y / a);
} else if (y <= -6.8e-288) {
tmp = t;
} else if (y <= 1.06e+28) {
tmp = x;
} else if ((y <= 5e+105) || !(y <= 5.6e+232)) {
tmp = t_1;
} else {
tmp = y * (t / a);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y / z)
if (y <= (-9.6d+236)) then
tmp = t_1
else if (y <= (-4.3d+144)) then
tmp = t * (y / a)
else if (y <= (-6.8d-288)) then
tmp = t
else if (y <= 1.06d+28) then
tmp = x
else if ((y <= 5d+105) .or. (.not. (y <= 5.6d+232))) then
tmp = t_1
else
tmp = y * (t / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x * (y / z);
double tmp;
if (y <= -9.6e+236) {
tmp = t_1;
} else if (y <= -4.3e+144) {
tmp = t * (y / a);
} else if (y <= -6.8e-288) {
tmp = t;
} else if (y <= 1.06e+28) {
tmp = x;
} else if ((y <= 5e+105) || !(y <= 5.6e+232)) {
tmp = t_1;
} else {
tmp = y * (t / a);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x * (y / z) tmp = 0 if y <= -9.6e+236: tmp = t_1 elif y <= -4.3e+144: tmp = t * (y / a) elif y <= -6.8e-288: tmp = t elif y <= 1.06e+28: tmp = x elif (y <= 5e+105) or not (y <= 5.6e+232): tmp = t_1 else: tmp = y * (t / a) return tmp
function code(x, y, z, t, a) t_1 = Float64(x * Float64(y / z)) tmp = 0.0 if (y <= -9.6e+236) tmp = t_1; elseif (y <= -4.3e+144) tmp = Float64(t * Float64(y / a)); elseif (y <= -6.8e-288) tmp = t; elseif (y <= 1.06e+28) tmp = x; elseif ((y <= 5e+105) || !(y <= 5.6e+232)) tmp = t_1; else tmp = Float64(y * Float64(t / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x * (y / z); tmp = 0.0; if (y <= -9.6e+236) tmp = t_1; elseif (y <= -4.3e+144) tmp = t * (y / a); elseif (y <= -6.8e-288) tmp = t; elseif (y <= 1.06e+28) tmp = x; elseif ((y <= 5e+105) || ~((y <= 5.6e+232))) tmp = t_1; else tmp = y * (t / a); 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, -9.6e+236], t$95$1, If[LessEqual[y, -4.3e+144], N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -6.8e-288], t, If[LessEqual[y, 1.06e+28], x, If[Or[LessEqual[y, 5e+105], N[Not[LessEqual[y, 5.6e+232]], $MachinePrecision]], t$95$1, N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y}{z}\\
\mathbf{if}\;y \leq -9.6 \cdot 10^{+236}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -4.3 \cdot 10^{+144}:\\
\;\;\;\;t \cdot \frac{y}{a}\\
\mathbf{elif}\;y \leq -6.8 \cdot 10^{-288}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 1.06 \cdot 10^{+28}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 5 \cdot 10^{+105} \lor \neg \left(y \leq 5.6 \cdot 10^{+232}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{t}{a}\\
\end{array}
\end{array}
if y < -9.60000000000000051e236 or 1.0600000000000001e28 < y < 5.00000000000000046e105 or 5.5999999999999998e232 < y Initial program 66.7%
associate-*l/86.4%
Simplified86.4%
Taylor expanded in z around inf 55.6%
associate--l+55.6%
associate-*r/55.6%
associate-*r/55.6%
div-sub55.7%
distribute-lft-out--55.7%
associate-*r/55.7%
mul-1-neg55.7%
distribute-rgt-out--55.8%
unsub-neg55.8%
associate-/l*62.9%
Simplified62.9%
Taylor expanded in y around inf 62.6%
Taylor expanded in t around 0 39.1%
associate-*r/45.2%
Simplified45.2%
if -9.60000000000000051e236 < y < -4.29999999999999984e144Initial program 64.1%
associate-*l/93.7%
Simplified93.7%
Taylor expanded in x around 0 34.2%
associate-/l*57.4%
Simplified57.4%
Taylor expanded in z around 0 49.3%
Taylor expanded in t around 0 31.7%
associate-*r/49.2%
Simplified49.2%
if -4.29999999999999984e144 < y < -6.79999999999999944e-288Initial program 57.2%
associate-*l/68.9%
Simplified68.9%
Taylor expanded in z around inf 38.2%
if -6.79999999999999944e-288 < y < 1.0600000000000001e28Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
if 5.00000000000000046e105 < y < 5.5999999999999998e232Initial program 87.0%
associate-*l/95.5%
Simplified95.5%
Taylor expanded in x around 0 46.9%
associate-/l*59.5%
Simplified59.5%
Taylor expanded in z around 0 57.4%
associate-/r/57.3%
Applied egg-rr57.3%
Final simplification43.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ t (/ a y))) (t_2 (* x (/ y z))))
(if (<= y -4.1e+234)
t_2
(if (<= y -4.3e+144)
t_1
(if (<= y -1.58e-283)
t
(if (<= y 2.75e+29)
x
(if (or (<= y 9.8e+101) (not (<= y 4.2e+251))) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t / (a / y);
double t_2 = x * (y / z);
double tmp;
if (y <= -4.1e+234) {
tmp = t_2;
} else if (y <= -4.3e+144) {
tmp = t_1;
} else if (y <= -1.58e-283) {
tmp = t;
} else if (y <= 2.75e+29) {
tmp = x;
} else if ((y <= 9.8e+101) || !(y <= 4.2e+251)) {
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 / y)
t_2 = x * (y / z)
if (y <= (-4.1d+234)) then
tmp = t_2
else if (y <= (-4.3d+144)) then
tmp = t_1
else if (y <= (-1.58d-283)) then
tmp = t
else if (y <= 2.75d+29) then
tmp = x
else if ((y <= 9.8d+101) .or. (.not. (y <= 4.2d+251))) 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 / y);
double t_2 = x * (y / z);
double tmp;
if (y <= -4.1e+234) {
tmp = t_2;
} else if (y <= -4.3e+144) {
tmp = t_1;
} else if (y <= -1.58e-283) {
tmp = t;
} else if (y <= 2.75e+29) {
tmp = x;
} else if ((y <= 9.8e+101) || !(y <= 4.2e+251)) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t / (a / y) t_2 = x * (y / z) tmp = 0 if y <= -4.1e+234: tmp = t_2 elif y <= -4.3e+144: tmp = t_1 elif y <= -1.58e-283: tmp = t elif y <= 2.75e+29: tmp = x elif (y <= 9.8e+101) or not (y <= 4.2e+251): tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t / Float64(a / y)) t_2 = Float64(x * Float64(y / z)) tmp = 0.0 if (y <= -4.1e+234) tmp = t_2; elseif (y <= -4.3e+144) tmp = t_1; elseif (y <= -1.58e-283) tmp = t; elseif (y <= 2.75e+29) tmp = x; elseif ((y <= 9.8e+101) || !(y <= 4.2e+251)) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t / (a / y); t_2 = x * (y / z); tmp = 0.0; if (y <= -4.1e+234) tmp = t_2; elseif (y <= -4.3e+144) tmp = t_1; elseif (y <= -1.58e-283) tmp = t; elseif (y <= 2.75e+29) tmp = x; elseif ((y <= 9.8e+101) || ~((y <= 4.2e+251))) 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 / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.1e+234], t$95$2, If[LessEqual[y, -4.3e+144], t$95$1, If[LessEqual[y, -1.58e-283], t, If[LessEqual[y, 2.75e+29], x, If[Or[LessEqual[y, 9.8e+101], N[Not[LessEqual[y, 4.2e+251]], $MachinePrecision]], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{\frac{a}{y}}\\
t_2 := x \cdot \frac{y}{z}\\
\mathbf{if}\;y \leq -4.1 \cdot 10^{+234}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -4.3 \cdot 10^{+144}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.58 \cdot 10^{-283}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 2.75 \cdot 10^{+29}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 9.8 \cdot 10^{+101} \lor \neg \left(y \leq 4.2 \cdot 10^{+251}\right):\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -4.09999999999999974e234 or 2.75e29 < y < 9.79999999999999965e101 or 4.2000000000000001e251 < y Initial program 65.6%
associate-*l/86.3%
Simplified86.3%
Taylor expanded in z around inf 58.5%
associate--l+58.5%
associate-*r/58.5%
associate-*r/58.5%
div-sub58.5%
distribute-lft-out--58.5%
associate-*r/58.5%
mul-1-neg58.5%
distribute-rgt-out--58.7%
unsub-neg58.7%
associate-/l*64.6%
Simplified64.6%
Taylor expanded in y around inf 64.4%
Taylor expanded in t around 0 40.6%
associate-*r/45.6%
Simplified45.6%
if -4.09999999999999974e234 < y < -4.29999999999999984e144 or 9.79999999999999965e101 < y < 4.2000000000000001e251Initial program 77.6%
associate-*l/93.9%
Simplified93.9%
Taylor expanded in x around 0 41.6%
associate-/l*56.7%
Simplified56.7%
Taylor expanded in z around 0 52.4%
if -4.29999999999999984e144 < y < -1.5800000000000001e-283Initial program 57.2%
associate-*l/68.9%
Simplified68.9%
Taylor expanded in z around inf 38.2%
if -1.5800000000000001e-283 < y < 2.75e29Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
Final simplification43.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ t (/ a y))) (t_2 (/ x (/ z y))))
(if (<= y -1e+234)
t_2
(if (<= y -6.2e+144)
t_1
(if (<= y -5e-286)
t
(if (<= y 5.9e+29)
x
(if (<= y 7e+104) t_2 (if (<= y 9.2e+251) t_1 (* x (/ y z))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t / (a / y);
double t_2 = x / (z / y);
double tmp;
if (y <= -1e+234) {
tmp = t_2;
} else if (y <= -6.2e+144) {
tmp = t_1;
} else if (y <= -5e-286) {
tmp = t;
} else if (y <= 5.9e+29) {
tmp = x;
} else if (y <= 7e+104) {
tmp = t_2;
} else if (y <= 9.2e+251) {
tmp = t_1;
} 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t / (a / y)
t_2 = x / (z / y)
if (y <= (-1d+234)) then
tmp = t_2
else if (y <= (-6.2d+144)) then
tmp = t_1
else if (y <= (-5d-286)) then
tmp = t
else if (y <= 5.9d+29) then
tmp = x
else if (y <= 7d+104) then
tmp = t_2
else if (y <= 9.2d+251) then
tmp = t_1
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 t_1 = t / (a / y);
double t_2 = x / (z / y);
double tmp;
if (y <= -1e+234) {
tmp = t_2;
} else if (y <= -6.2e+144) {
tmp = t_1;
} else if (y <= -5e-286) {
tmp = t;
} else if (y <= 5.9e+29) {
tmp = x;
} else if (y <= 7e+104) {
tmp = t_2;
} else if (y <= 9.2e+251) {
tmp = t_1;
} else {
tmp = x * (y / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t / (a / y) t_2 = x / (z / y) tmp = 0 if y <= -1e+234: tmp = t_2 elif y <= -6.2e+144: tmp = t_1 elif y <= -5e-286: tmp = t elif y <= 5.9e+29: tmp = x elif y <= 7e+104: tmp = t_2 elif y <= 9.2e+251: tmp = t_1 else: tmp = x * (y / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(t / Float64(a / y)) t_2 = Float64(x / Float64(z / y)) tmp = 0.0 if (y <= -1e+234) tmp = t_2; elseif (y <= -6.2e+144) tmp = t_1; elseif (y <= -5e-286) tmp = t; elseif (y <= 5.9e+29) tmp = x; elseif (y <= 7e+104) tmp = t_2; elseif (y <= 9.2e+251) tmp = t_1; else tmp = Float64(x * Float64(y / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t / (a / y); t_2 = x / (z / y); tmp = 0.0; if (y <= -1e+234) tmp = t_2; elseif (y <= -6.2e+144) tmp = t_1; elseif (y <= -5e-286) tmp = t; elseif (y <= 5.9e+29) tmp = x; elseif (y <= 7e+104) tmp = t_2; elseif (y <= 9.2e+251) tmp = t_1; else tmp = x * (y / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1e+234], t$95$2, If[LessEqual[y, -6.2e+144], t$95$1, If[LessEqual[y, -5e-286], t, If[LessEqual[y, 5.9e+29], x, If[LessEqual[y, 7e+104], t$95$2, If[LessEqual[y, 9.2e+251], t$95$1, N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{\frac{a}{y}}\\
t_2 := \frac{x}{\frac{z}{y}}\\
\mathbf{if}\;y \leq -1 \cdot 10^{+234}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -6.2 \cdot 10^{+144}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -5 \cdot 10^{-286}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 5.9 \cdot 10^{+29}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 7 \cdot 10^{+104}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 9.2 \cdot 10^{+251}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if y < -1.00000000000000002e234 or 5.8999999999999999e29 < y < 7.0000000000000003e104Initial program 63.7%
associate-*l/83.5%
Simplified83.5%
Taylor expanded in z around inf 58.5%
associate--l+58.5%
associate-*r/58.5%
associate-*r/58.5%
div-sub58.5%
distribute-lft-out--58.5%
associate-*r/58.5%
mul-1-neg58.5%
distribute-rgt-out--58.8%
unsub-neg58.8%
associate-/l*64.6%
Simplified64.6%
Taylor expanded in y around inf 64.2%
Taylor expanded in t around 0 38.5%
associate-/l*43.0%
Simplified43.0%
if -1.00000000000000002e234 < y < -6.2000000000000003e144 or 7.0000000000000003e104 < y < 9.19999999999999953e251Initial program 77.6%
associate-*l/93.9%
Simplified93.9%
Taylor expanded in x around 0 41.6%
associate-/l*56.7%
Simplified56.7%
Taylor expanded in z around 0 52.4%
if -6.2000000000000003e144 < y < -5.00000000000000037e-286Initial program 57.2%
associate-*l/68.9%
Simplified68.9%
Taylor expanded in z around inf 38.2%
if -5.00000000000000037e-286 < y < 5.8999999999999999e29Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
if 9.19999999999999953e251 < y Initial program 70.5%
associate-*l/93.7%
Simplified93.7%
Taylor expanded in z around inf 58.4%
associate--l+58.4%
associate-*r/58.4%
associate-*r/58.4%
div-sub58.4%
distribute-lft-out--58.4%
associate-*r/58.4%
mul-1-neg58.4%
distribute-rgt-out--58.4%
unsub-neg58.4%
associate-/l*64.8%
Simplified64.8%
Taylor expanded in y around inf 64.8%
Taylor expanded in t around 0 46.3%
associate-*r/52.6%
Simplified52.6%
Final simplification43.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* x (/ y z)))) (t_2 (* x (- 1.0 (/ y a)))))
(if (<= a -8.6e-19)
t_2
(if (<= a 6.8e-243)
t_1
(if (<= a 2.9e-108)
(* t (- 1.0 (/ y z)))
(if (or (<= a 2.8e-27) (not (<= a 7e-8))) t_2 t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + (x * (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -8.6e-19) {
tmp = t_2;
} else if (a <= 6.8e-243) {
tmp = t_1;
} else if (a <= 2.9e-108) {
tmp = t * (1.0 - (y / z));
} else if ((a <= 2.8e-27) || !(a <= 7e-8)) {
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 + (x * (y / z))
t_2 = x * (1.0d0 - (y / a))
if (a <= (-8.6d-19)) then
tmp = t_2
else if (a <= 6.8d-243) then
tmp = t_1
else if (a <= 2.9d-108) then
tmp = t * (1.0d0 - (y / z))
else if ((a <= 2.8d-27) .or. (.not. (a <= 7d-8))) 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 + (x * (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -8.6e-19) {
tmp = t_2;
} else if (a <= 6.8e-243) {
tmp = t_1;
} else if (a <= 2.9e-108) {
tmp = t * (1.0 - (y / z));
} else if ((a <= 2.8e-27) || !(a <= 7e-8)) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + (x * (y / z)) t_2 = x * (1.0 - (y / a)) tmp = 0 if a <= -8.6e-19: tmp = t_2 elif a <= 6.8e-243: tmp = t_1 elif a <= 2.9e-108: tmp = t * (1.0 - (y / z)) elif (a <= 2.8e-27) or not (a <= 7e-8): tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(x * Float64(y / z))) t_2 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (a <= -8.6e-19) tmp = t_2; elseif (a <= 6.8e-243) tmp = t_1; elseif (a <= 2.9e-108) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif ((a <= 2.8e-27) || !(a <= 7e-8)) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + (x * (y / z)); t_2 = x * (1.0 - (y / a)); tmp = 0.0; if (a <= -8.6e-19) tmp = t_2; elseif (a <= 6.8e-243) tmp = t_1; elseif (a <= 2.9e-108) tmp = t * (1.0 - (y / z)); elseif ((a <= 2.8e-27) || ~((a <= 7e-8))) 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[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -8.6e-19], t$95$2, If[LessEqual[a, 6.8e-243], t$95$1, If[LessEqual[a, 2.9e-108], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, 2.8e-27], N[Not[LessEqual[a, 7e-8]], $MachinePrecision]], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + x \cdot \frac{y}{z}\\
t_2 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;a \leq -8.6 \cdot 10^{-19}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 6.8 \cdot 10^{-243}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{-108}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-27} \lor \neg \left(a \leq 7 \cdot 10^{-8}\right):\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -8.6e-19 or 2.9000000000000001e-108 < a < 2.8e-27 or 7.00000000000000048e-8 < a Initial program 72.6%
associate-*l/89.8%
Simplified89.8%
Taylor expanded in z around 0 71.6%
Taylor expanded in x around inf 56.3%
mul-1-neg56.3%
unsub-neg56.3%
Simplified56.3%
if -8.6e-19 < a < 6.79999999999999992e-243 or 2.8e-27 < a < 7.00000000000000048e-8Initial program 60.8%
associate-*l/68.3%
Simplified68.3%
Taylor expanded in z around inf 83.5%
associate--l+83.5%
associate-*r/83.5%
associate-*r/83.5%
div-sub83.5%
distribute-lft-out--83.5%
associate-*r/83.5%
mul-1-neg83.5%
distribute-rgt-out--83.5%
unsub-neg83.5%
associate-/l*86.9%
Simplified86.9%
Taylor expanded in y around inf 82.4%
Taylor expanded in t around 0 71.6%
associate-*r/74.8%
neg-mul-174.8%
distribute-rgt-neg-in74.8%
distribute-neg-frac74.8%
Simplified74.8%
if 6.79999999999999992e-243 < a < 2.9000000000000001e-108Initial program 66.0%
associate-*l/75.9%
Simplified75.9%
Taylor expanded in z around inf 79.6%
associate--l+79.6%
associate-*r/79.6%
associate-*r/79.6%
div-sub79.6%
distribute-lft-out--79.6%
associate-*r/79.6%
mul-1-neg79.6%
distribute-rgt-out--79.6%
unsub-neg79.6%
associate-/l*92.8%
Simplified92.8%
Taylor expanded in y around inf 86.5%
Taylor expanded in t around inf 79.5%
Final simplification65.5%
(FPCore (x y z t a)
:precision binary64
(if (<= y -5.8e+132)
(* (/ y z) (- t))
(if (<= y -1.52e-285)
t
(if (<= y 5.9e+29)
x
(if (<= y 2.2e+104)
(/ x (/ z y))
(if (<= y 4.5e+180) (/ t (/ a y)) (* x (/ (- y) a))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -5.8e+132) {
tmp = (y / z) * -t;
} else if (y <= -1.52e-285) {
tmp = t;
} else if (y <= 5.9e+29) {
tmp = x;
} else if (y <= 2.2e+104) {
tmp = x / (z / y);
} else if (y <= 4.5e+180) {
tmp = t / (a / y);
} else {
tmp = x * (-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 (y <= (-5.8d+132)) then
tmp = (y / z) * -t
else if (y <= (-1.52d-285)) then
tmp = t
else if (y <= 5.9d+29) then
tmp = x
else if (y <= 2.2d+104) then
tmp = x / (z / y)
else if (y <= 4.5d+180) then
tmp = t / (a / y)
else
tmp = x * (-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 (y <= -5.8e+132) {
tmp = (y / z) * -t;
} else if (y <= -1.52e-285) {
tmp = t;
} else if (y <= 5.9e+29) {
tmp = x;
} else if (y <= 2.2e+104) {
tmp = x / (z / y);
} else if (y <= 4.5e+180) {
tmp = t / (a / y);
} else {
tmp = x * (-y / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -5.8e+132: tmp = (y / z) * -t elif y <= -1.52e-285: tmp = t elif y <= 5.9e+29: tmp = x elif y <= 2.2e+104: tmp = x / (z / y) elif y <= 4.5e+180: tmp = t / (a / y) else: tmp = x * (-y / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -5.8e+132) tmp = Float64(Float64(y / z) * Float64(-t)); elseif (y <= -1.52e-285) tmp = t; elseif (y <= 5.9e+29) tmp = x; elseif (y <= 2.2e+104) tmp = Float64(x / Float64(z / y)); elseif (y <= 4.5e+180) tmp = Float64(t / Float64(a / y)); else tmp = Float64(x * Float64(Float64(-y) / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -5.8e+132) tmp = (y / z) * -t; elseif (y <= -1.52e-285) tmp = t; elseif (y <= 5.9e+29) tmp = x; elseif (y <= 2.2e+104) tmp = x / (z / y); elseif (y <= 4.5e+180) tmp = t / (a / y); else tmp = x * (-y / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -5.8e+132], N[(N[(y / z), $MachinePrecision] * (-t)), $MachinePrecision], If[LessEqual[y, -1.52e-285], t, If[LessEqual[y, 5.9e+29], x, If[LessEqual[y, 2.2e+104], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.5e+180], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision], N[(x * N[((-y) / a), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.8 \cdot 10^{+132}:\\
\;\;\;\;\frac{y}{z} \cdot \left(-t\right)\\
\mathbf{elif}\;y \leq -1.52 \cdot 10^{-285}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 5.9 \cdot 10^{+29}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 2.2 \cdot 10^{+104}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{+180}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{-y}{a}\\
\end{array}
\end{array}
if y < -5.7999999999999997e132Initial program 65.6%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in x around 0 30.5%
associate-/l*53.1%
Simplified53.1%
Taylor expanded in y around inf 52.0%
Taylor expanded in a around 0 27.4%
mul-1-neg27.4%
associate-*r/38.2%
distribute-rgt-neg-in38.2%
distribute-neg-frac38.2%
Simplified38.2%
if -5.7999999999999997e132 < y < -1.5200000000000001e-285Initial program 57.3%
associate-*l/68.1%
Simplified68.1%
Taylor expanded in z around inf 39.0%
if -1.5200000000000001e-285 < y < 5.8999999999999999e29Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
if 5.8999999999999999e29 < y < 2.2e104Initial program 60.9%
associate-*l/74.5%
Simplified74.5%
Taylor expanded in z around inf 53.7%
associate--l+53.7%
associate-*r/53.7%
associate-*r/53.7%
div-sub53.7%
distribute-lft-out--53.7%
associate-*r/53.7%
mul-1-neg53.7%
distribute-rgt-out--53.7%
unsub-neg53.7%
associate-/l*59.4%
Simplified59.4%
Taylor expanded in y around inf 58.8%
Taylor expanded in t around 0 35.9%
associate-/l*39.4%
Simplified39.4%
if 2.2e104 < y < 4.49999999999999981e180Initial program 74.5%
associate-*l/99.7%
Simplified99.7%
Taylor expanded in x around 0 65.4%
associate-/l*90.6%
Simplified90.6%
Taylor expanded in z around 0 77.3%
if 4.49999999999999981e180 < y Initial program 81.9%
associate-*l/91.8%
Simplified91.8%
Taylor expanded in z around 0 61.7%
Taylor expanded in t around 0 44.0%
mul-1-neg44.0%
Simplified44.0%
Taylor expanded in y around inf 44.0%
mul-1-neg44.0%
associate-*r/48.2%
*-commutative48.2%
distribute-rgt-neg-in48.2%
Simplified48.2%
Final simplification42.9%
(FPCore (x y z t a)
:precision binary64
(if (<= y -3.2e+132)
(/ t (/ (- z) y))
(if (<= y -2e-284)
t
(if (<= y 7.5e+28)
x
(if (<= y 3.6e+105)
(/ x (/ z y))
(if (<= y 1.1e+180) (/ t (/ a y)) (* x (/ (- y) a))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -3.2e+132) {
tmp = t / (-z / y);
} else if (y <= -2e-284) {
tmp = t;
} else if (y <= 7.5e+28) {
tmp = x;
} else if (y <= 3.6e+105) {
tmp = x / (z / y);
} else if (y <= 1.1e+180) {
tmp = t / (a / y);
} else {
tmp = x * (-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 (y <= (-3.2d+132)) then
tmp = t / (-z / y)
else if (y <= (-2d-284)) then
tmp = t
else if (y <= 7.5d+28) then
tmp = x
else if (y <= 3.6d+105) then
tmp = x / (z / y)
else if (y <= 1.1d+180) then
tmp = t / (a / y)
else
tmp = x * (-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 (y <= -3.2e+132) {
tmp = t / (-z / y);
} else if (y <= -2e-284) {
tmp = t;
} else if (y <= 7.5e+28) {
tmp = x;
} else if (y <= 3.6e+105) {
tmp = x / (z / y);
} else if (y <= 1.1e+180) {
tmp = t / (a / y);
} else {
tmp = x * (-y / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -3.2e+132: tmp = t / (-z / y) elif y <= -2e-284: tmp = t elif y <= 7.5e+28: tmp = x elif y <= 3.6e+105: tmp = x / (z / y) elif y <= 1.1e+180: tmp = t / (a / y) else: tmp = x * (-y / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -3.2e+132) tmp = Float64(t / Float64(Float64(-z) / y)); elseif (y <= -2e-284) tmp = t; elseif (y <= 7.5e+28) tmp = x; elseif (y <= 3.6e+105) tmp = Float64(x / Float64(z / y)); elseif (y <= 1.1e+180) tmp = Float64(t / Float64(a / y)); else tmp = Float64(x * Float64(Float64(-y) / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (y <= -3.2e+132) tmp = t / (-z / y); elseif (y <= -2e-284) tmp = t; elseif (y <= 7.5e+28) tmp = x; elseif (y <= 3.6e+105) tmp = x / (z / y); elseif (y <= 1.1e+180) tmp = t / (a / y); else tmp = x * (-y / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -3.2e+132], N[(t / N[((-z) / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2e-284], t, If[LessEqual[y, 7.5e+28], x, If[LessEqual[y, 3.6e+105], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.1e+180], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision], N[(x * N[((-y) / a), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.2 \cdot 10^{+132}:\\
\;\;\;\;\frac{t}{\frac{-z}{y}}\\
\mathbf{elif}\;y \leq -2 \cdot 10^{-284}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 7.5 \cdot 10^{+28}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{+105}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{+180}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{-y}{a}\\
\end{array}
\end{array}
if y < -3.1999999999999997e132Initial program 65.6%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in x around 0 30.5%
associate-/l*53.1%
Simplified53.1%
Taylor expanded in y around inf 52.0%
Taylor expanded in a around 0 38.2%
mul-1-neg38.2%
distribute-frac-neg38.2%
Simplified38.2%
if -3.1999999999999997e132 < y < -2.00000000000000007e-284Initial program 57.3%
associate-*l/68.1%
Simplified68.1%
Taylor expanded in z around inf 39.0%
if -2.00000000000000007e-284 < y < 7.4999999999999998e28Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
if 7.4999999999999998e28 < y < 3.5999999999999999e105Initial program 60.9%
associate-*l/74.5%
Simplified74.5%
Taylor expanded in z around inf 53.7%
associate--l+53.7%
associate-*r/53.7%
associate-*r/53.7%
div-sub53.7%
distribute-lft-out--53.7%
associate-*r/53.7%
mul-1-neg53.7%
distribute-rgt-out--53.7%
unsub-neg53.7%
associate-/l*59.4%
Simplified59.4%
Taylor expanded in y around inf 58.8%
Taylor expanded in t around 0 35.9%
associate-/l*39.4%
Simplified39.4%
if 3.5999999999999999e105 < y < 1.1e180Initial program 74.5%
associate-*l/99.7%
Simplified99.7%
Taylor expanded in x around 0 65.4%
associate-/l*90.6%
Simplified90.6%
Taylor expanded in z around 0 77.3%
if 1.1e180 < y Initial program 81.9%
associate-*l/91.8%
Simplified91.8%
Taylor expanded in z around 0 61.7%
Taylor expanded in t around 0 44.0%
mul-1-neg44.0%
Simplified44.0%
Taylor expanded in y around inf 44.0%
mul-1-neg44.0%
associate-*r/48.2%
*-commutative48.2%
distribute-rgt-neg-in48.2%
Simplified48.2%
Final simplification42.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (- t x) (/ (- y z) a)))))
(if (<= a -4.3e-20)
t_1
(if (<= a 3.6e-106)
(+ t (/ (- x t) (/ z y)))
(if (or (<= a 1.2e-27) (not (<= a 1.7e+81)))
t_1
(+ t (* x (/ (- y a) z))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) * ((y - z) / a));
double tmp;
if (a <= -4.3e-20) {
tmp = t_1;
} else if (a <= 3.6e-106) {
tmp = t + ((x - t) / (z / y));
} else if ((a <= 1.2e-27) || !(a <= 1.7e+81)) {
tmp = t_1;
} else {
tmp = t + (x * ((y - a) / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + ((t - x) * ((y - z) / a))
if (a <= (-4.3d-20)) then
tmp = t_1
else if (a <= 3.6d-106) then
tmp = t + ((x - t) / (z / y))
else if ((a <= 1.2d-27) .or. (.not. (a <= 1.7d+81))) then
tmp = t_1
else
tmp = t + (x * ((y - a) / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((t - x) * ((y - z) / a));
double tmp;
if (a <= -4.3e-20) {
tmp = t_1;
} else if (a <= 3.6e-106) {
tmp = t + ((x - t) / (z / y));
} else if ((a <= 1.2e-27) || !(a <= 1.7e+81)) {
tmp = t_1;
} else {
tmp = t + (x * ((y - a) / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((t - x) * ((y - z) / a)) tmp = 0 if a <= -4.3e-20: tmp = t_1 elif a <= 3.6e-106: tmp = t + ((x - t) / (z / y)) elif (a <= 1.2e-27) or not (a <= 1.7e+81): tmp = t_1 else: tmp = t + (x * ((y - a) / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / a))) tmp = 0.0 if (a <= -4.3e-20) tmp = t_1; elseif (a <= 3.6e-106) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / y))); elseif ((a <= 1.2e-27) || !(a <= 1.7e+81)) tmp = t_1; else tmp = Float64(t + Float64(x * Float64(Float64(y - a) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((t - x) * ((y - z) / a)); tmp = 0.0; if (a <= -4.3e-20) tmp = t_1; elseif (a <= 3.6e-106) tmp = t + ((x - t) / (z / y)); elseif ((a <= 1.2e-27) || ~((a <= 1.7e+81))) tmp = t_1; else tmp = t + (x * ((y - a) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.3e-20], t$95$1, If[LessEqual[a, 3.6e-106], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, 1.2e-27], N[Not[LessEqual[a, 1.7e+81]], $MachinePrecision]], t$95$1, N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(t - x\right) \cdot \frac{y - z}{a}\\
\mathbf{if}\;a \leq -4.3 \cdot 10^{-20}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 3.6 \cdot 10^{-106}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-27} \lor \neg \left(a \leq 1.7 \cdot 10^{+81}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \frac{y - a}{z}\\
\end{array}
\end{array}
if a < -4.30000000000000011e-20 or 3.60000000000000013e-106 < a < 1.20000000000000001e-27 or 1.70000000000000001e81 < a Initial program 73.8%
associate-*l/92.7%
Simplified92.7%
Taylor expanded in a around inf 80.6%
if -4.30000000000000011e-20 < a < 3.60000000000000013e-106Initial program 62.3%
associate-*l/70.3%
Simplified70.3%
Taylor expanded in z around inf 82.0%
associate--l+82.0%
associate-*r/82.0%
associate-*r/82.0%
div-sub82.0%
distribute-lft-out--82.0%
associate-*r/82.0%
mul-1-neg82.0%
distribute-rgt-out--82.0%
unsub-neg82.0%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in y around inf 84.7%
if 1.20000000000000001e-27 < a < 1.70000000000000001e81Initial program 59.2%
associate-*l/62.9%
Simplified62.9%
Taylor expanded in z around inf 72.5%
associate--l+72.5%
associate-*r/72.5%
associate-*r/72.5%
div-sub72.5%
distribute-lft-out--72.5%
associate-*r/72.5%
mul-1-neg72.5%
distribute-rgt-out--72.5%
unsub-neg72.5%
associate-/l*76.7%
Simplified76.7%
Taylor expanded in t around 0 63.7%
mul-1-neg63.7%
associate-*r/72.9%
distribute-lft-neg-in72.9%
Simplified72.9%
Final simplification81.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (/ (- x t) (/ z (- y a))))))
(if (<= z -6.1e-25)
t_1
(if (<= z 3.2e-79)
(+ x (/ y (/ a (- t x))))
(if (or (<= z 270000000000.0) (not (<= z 6.8e+41)))
t_1
(+ x (* (- t x) (/ (- y z) a))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((x - t) / (z / (y - a)));
double tmp;
if (z <= -6.1e-25) {
tmp = t_1;
} else if (z <= 3.2e-79) {
tmp = x + (y / (a / (t - x)));
} else if ((z <= 270000000000.0) || !(z <= 6.8e+41)) {
tmp = t_1;
} else {
tmp = x + ((t - x) * ((y - z) / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t + ((x - t) / (z / (y - a)))
if (z <= (-6.1d-25)) then
tmp = t_1
else if (z <= 3.2d-79) then
tmp = x + (y / (a / (t - x)))
else if ((z <= 270000000000.0d0) .or. (.not. (z <= 6.8d+41))) then
tmp = t_1
else
tmp = x + ((t - x) * ((y - z) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((x - t) / (z / (y - a)));
double tmp;
if (z <= -6.1e-25) {
tmp = t_1;
} else if (z <= 3.2e-79) {
tmp = x + (y / (a / (t - x)));
} else if ((z <= 270000000000.0) || !(z <= 6.8e+41)) {
tmp = t_1;
} else {
tmp = x + ((t - x) * ((y - z) / a));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t + ((x - t) / (z / (y - a))) tmp = 0 if z <= -6.1e-25: tmp = t_1 elif z <= 3.2e-79: tmp = x + (y / (a / (t - x))) elif (z <= 270000000000.0) or not (z <= 6.8e+41): tmp = t_1 else: tmp = x + ((t - x) * ((y - z) / a)) return tmp
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))) tmp = 0.0 if (z <= -6.1e-25) tmp = t_1; elseif (z <= 3.2e-79) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); elseif ((z <= 270000000000.0) || !(z <= 6.8e+41)) tmp = t_1; else tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t + ((x - t) / (z / (y - a))); tmp = 0.0; if (z <= -6.1e-25) tmp = t_1; elseif (z <= 3.2e-79) tmp = x + (y / (a / (t - x))); elseif ((z <= 270000000000.0) || ~((z <= 6.8e+41))) tmp = t_1; else tmp = x + ((t - x) * ((y - z) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6.1e-25], t$95$1, If[LessEqual[z, 3.2e-79], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 270000000000.0], N[Not[LessEqual[z, 6.8e+41]], $MachinePrecision]], t$95$1, N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{if}\;z \leq -6.1 \cdot 10^{-25}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{-79}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{elif}\;z \leq 270000000000 \lor \neg \left(z \leq 6.8 \cdot 10^{+41}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a}\\
\end{array}
\end{array}
if z < -6.10000000000000018e-25 or 3.19999999999999988e-79 < z < 2.7e11 or 6.79999999999999996e41 < z Initial program 50.0%
associate-*l/67.1%
Simplified67.1%
Taylor expanded in z around inf 70.0%
associate--l+70.0%
associate-*r/70.0%
associate-*r/70.0%
div-sub70.0%
distribute-lft-out--70.0%
associate-*r/70.0%
mul-1-neg70.0%
distribute-rgt-out--70.7%
unsub-neg70.7%
associate-/l*82.1%
Simplified82.1%
if -6.10000000000000018e-25 < z < 3.19999999999999988e-79Initial program 90.3%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in z around 0 79.6%
associate-/l*85.7%
Simplified85.7%
if 2.7e11 < z < 6.79999999999999996e41Initial program 64.3%
associate-*l/99.6%
Simplified99.6%
Taylor expanded in a around inf 87.5%
Final simplification83.8%
(FPCore (x y z t a)
:precision binary64
(if (<= y -4.4e+132)
(* (/ y z) (- t))
(if (<= y -1.5e-284)
t
(if (<= y 2.05e+30)
x
(if (<= y 6.5e+104)
(/ x (/ z y))
(if (<= y 1.3e+250) (/ t (/ a y)) (* x (/ y z))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -4.4e+132) {
tmp = (y / z) * -t;
} else if (y <= -1.5e-284) {
tmp = t;
} else if (y <= 2.05e+30) {
tmp = x;
} else if (y <= 6.5e+104) {
tmp = x / (z / y);
} else if (y <= 1.3e+250) {
tmp = t / (a / y);
} 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 <= (-4.4d+132)) then
tmp = (y / z) * -t
else if (y <= (-1.5d-284)) then
tmp = t
else if (y <= 2.05d+30) then
tmp = x
else if (y <= 6.5d+104) then
tmp = x / (z / y)
else if (y <= 1.3d+250) then
tmp = t / (a / y)
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 <= -4.4e+132) {
tmp = (y / z) * -t;
} else if (y <= -1.5e-284) {
tmp = t;
} else if (y <= 2.05e+30) {
tmp = x;
} else if (y <= 6.5e+104) {
tmp = x / (z / y);
} else if (y <= 1.3e+250) {
tmp = t / (a / y);
} else {
tmp = x * (y / z);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if y <= -4.4e+132: tmp = (y / z) * -t elif y <= -1.5e-284: tmp = t elif y <= 2.05e+30: tmp = x elif y <= 6.5e+104: tmp = x / (z / y) elif y <= 1.3e+250: tmp = t / (a / y) else: tmp = x * (y / z) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (y <= -4.4e+132) tmp = Float64(Float64(y / z) * Float64(-t)); elseif (y <= -1.5e-284) tmp = t; elseif (y <= 2.05e+30) tmp = x; elseif (y <= 6.5e+104) tmp = Float64(x / Float64(z / y)); elseif (y <= 1.3e+250) tmp = Float64(t / Float64(a / y)); 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 <= -4.4e+132) tmp = (y / z) * -t; elseif (y <= -1.5e-284) tmp = t; elseif (y <= 2.05e+30) tmp = x; elseif (y <= 6.5e+104) tmp = x / (z / y); elseif (y <= 1.3e+250) tmp = t / (a / y); else tmp = x * (y / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -4.4e+132], N[(N[(y / z), $MachinePrecision] * (-t)), $MachinePrecision], If[LessEqual[y, -1.5e-284], t, If[LessEqual[y, 2.05e+30], x, If[LessEqual[y, 6.5e+104], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.3e+250], N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision], N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.4 \cdot 10^{+132}:\\
\;\;\;\;\frac{y}{z} \cdot \left(-t\right)\\
\mathbf{elif}\;y \leq -1.5 \cdot 10^{-284}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 2.05 \cdot 10^{+30}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 6.5 \cdot 10^{+104}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq 1.3 \cdot 10^{+250}:\\
\;\;\;\;\frac{t}{\frac{a}{y}}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if y < -4.39999999999999977e132Initial program 65.6%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in x around 0 30.5%
associate-/l*53.1%
Simplified53.1%
Taylor expanded in y around inf 52.0%
Taylor expanded in a around 0 27.4%
mul-1-neg27.4%
associate-*r/38.2%
distribute-rgt-neg-in38.2%
distribute-neg-frac38.2%
Simplified38.2%
if -4.39999999999999977e132 < y < -1.5e-284Initial program 57.3%
associate-*l/68.1%
Simplified68.1%
Taylor expanded in z around inf 39.0%
if -1.5e-284 < y < 2.05000000000000003e30Initial program 74.6%
associate-*l/80.9%
Simplified80.9%
Taylor expanded in a around inf 43.0%
if 2.05000000000000003e30 < y < 6.5000000000000005e104Initial program 60.9%
associate-*l/74.5%
Simplified74.5%
Taylor expanded in z around inf 53.7%
associate--l+53.7%
associate-*r/53.7%
associate-*r/53.7%
div-sub53.7%
distribute-lft-out--53.7%
associate-*r/53.7%
mul-1-neg53.7%
distribute-rgt-out--53.7%
unsub-neg53.7%
associate-/l*59.4%
Simplified59.4%
Taylor expanded in y around inf 58.8%
Taylor expanded in t around 0 35.9%
associate-/l*39.4%
Simplified39.4%
if 6.5000000000000005e104 < y < 1.30000000000000006e250Initial program 85.6%
associate-*l/93.9%
Simplified93.9%
Taylor expanded in x around 0 45.9%
associate-/l*56.3%
Simplified56.3%
Taylor expanded in z around 0 54.3%
if 1.30000000000000006e250 < y Initial program 70.5%
associate-*l/93.7%
Simplified93.7%
Taylor expanded in z around inf 58.4%
associate--l+58.4%
associate-*r/58.4%
associate-*r/58.4%
div-sub58.4%
distribute-lft-out--58.4%
associate-*r/58.4%
mul-1-neg58.4%
distribute-rgt-out--58.4%
unsub-neg58.4%
associate-/l*64.8%
Simplified64.8%
Taylor expanded in y around inf 64.8%
Taylor expanded in t around 0 46.3%
associate-*r/52.6%
Simplified52.6%
Final simplification42.6%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.65e-20)
(+ t (* x (/ (- y a) z)))
(if (<= z 1.7e-76)
(+ x (/ y (/ a (- t x))))
(if (or (<= z 55000.0) (not (<= z 2.6e+37)))
(+ t (/ (- x t) (/ z y)))
(+ x (/ (* z (- x t)) a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.65e-20) {
tmp = t + (x * ((y - a) / z));
} else if (z <= 1.7e-76) {
tmp = x + (y / (a / (t - x)));
} else if ((z <= 55000.0) || !(z <= 2.6e+37)) {
tmp = t + ((x - t) / (z / y));
} else {
tmp = x + ((z * (x - t)) / a);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.65d-20)) then
tmp = t + (x * ((y - a) / z))
else if (z <= 1.7d-76) then
tmp = x + (y / (a / (t - x)))
else if ((z <= 55000.0d0) .or. (.not. (z <= 2.6d+37))) then
tmp = t + ((x - t) / (z / y))
else
tmp = x + ((z * (x - t)) / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.65e-20) {
tmp = t + (x * ((y - a) / z));
} else if (z <= 1.7e-76) {
tmp = x + (y / (a / (t - x)));
} else if ((z <= 55000.0) || !(z <= 2.6e+37)) {
tmp = t + ((x - t) / (z / y));
} else {
tmp = x + ((z * (x - t)) / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.65e-20: tmp = t + (x * ((y - a) / z)) elif z <= 1.7e-76: tmp = x + (y / (a / (t - x))) elif (z <= 55000.0) or not (z <= 2.6e+37): tmp = t + ((x - t) / (z / y)) else: tmp = x + ((z * (x - t)) / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.65e-20) tmp = Float64(t + Float64(x * Float64(Float64(y - a) / z))); elseif (z <= 1.7e-76) tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); elseif ((z <= 55000.0) || !(z <= 2.6e+37)) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / y))); else tmp = Float64(x + Float64(Float64(z * Float64(x - t)) / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.65e-20) tmp = t + (x * ((y - a) / z)); elseif (z <= 1.7e-76) tmp = x + (y / (a / (t - x))); elseif ((z <= 55000.0) || ~((z <= 2.6e+37))) tmp = t + ((x - t) / (z / y)); else tmp = x + ((z * (x - t)) / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.65e-20], N[(t + N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.7e-76], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 55000.0], N[Not[LessEqual[z, 2.6e+37]], $MachinePrecision]], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z * N[(x - t), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.65 \cdot 10^{-20}:\\
\;\;\;\;t + x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{-76}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\mathbf{elif}\;z \leq 55000 \lor \neg \left(z \leq 2.6 \cdot 10^{+37}\right):\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{z \cdot \left(x - t\right)}{a}\\
\end{array}
\end{array}
if z < -2.6500000000000001e-20Initial program 49.1%
associate-*l/60.5%
Simplified60.5%
Taylor expanded in z around inf 67.1%
associate--l+67.1%
associate-*r/67.1%
associate-*r/67.1%
div-sub67.1%
distribute-lft-out--67.1%
associate-*r/67.1%
mul-1-neg67.1%
distribute-rgt-out--67.1%
unsub-neg67.1%
associate-/l*75.9%
Simplified75.9%
Taylor expanded in t around 0 65.8%
mul-1-neg65.8%
associate-*r/71.6%
distribute-lft-neg-in71.6%
Simplified71.6%
if -2.6500000000000001e-20 < z < 1.7e-76Initial program 90.4%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in z around 0 79.0%
associate-/l*85.0%
Simplified85.0%
if 1.7e-76 < z < 55000 or 2.5999999999999999e37 < z Initial program 51.5%
associate-*l/73.2%
Simplified73.2%
Taylor expanded in z around inf 71.8%
associate--l+71.8%
associate-*r/71.8%
associate-*r/71.8%
div-sub71.8%
distribute-lft-out--71.8%
associate-*r/71.8%
mul-1-neg71.8%
distribute-rgt-out--73.1%
unsub-neg73.1%
associate-/l*86.5%
Simplified86.5%
Taylor expanded in y around inf 78.7%
if 55000 < z < 2.5999999999999999e37Initial program 52.4%
associate-*l/99.5%
Simplified99.5%
Taylor expanded in a around inf 99.5%
Taylor expanded in y around 0 72.0%
mul-1-neg72.0%
Simplified72.0%
Final simplification79.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (* (/ y a) (- x t)))))
(if (<= a -1.46e-19)
t_1
(if (<= a 1.3e-243)
(+ t (* x (/ y z)))
(if (<= a 1.2e-159)
(* t (- 1.0 (/ y z)))
(if (<= a 2e+71) (* y (/ (- t x) (- a z))) t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((y / a) * (x - t));
double tmp;
if (a <= -1.46e-19) {
tmp = t_1;
} else if (a <= 1.3e-243) {
tmp = t + (x * (y / z));
} else if (a <= 1.2e-159) {
tmp = t * (1.0 - (y / z));
} else if (a <= 2e+71) {
tmp = y * ((t - x) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x - ((y / a) * (x - t))
if (a <= (-1.46d-19)) then
tmp = t_1
else if (a <= 1.3d-243) then
tmp = t + (x * (y / z))
else if (a <= 1.2d-159) then
tmp = t * (1.0d0 - (y / z))
else if (a <= 2d+71) then
tmp = y * ((t - x) / (a - z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((y / a) * (x - t));
double tmp;
if (a <= -1.46e-19) {
tmp = t_1;
} else if (a <= 1.3e-243) {
tmp = t + (x * (y / z));
} else if (a <= 1.2e-159) {
tmp = t * (1.0 - (y / z));
} else if (a <= 2e+71) {
tmp = y * ((t - x) / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - ((y / a) * (x - t)) tmp = 0 if a <= -1.46e-19: tmp = t_1 elif a <= 1.3e-243: tmp = t + (x * (y / z)) elif a <= 1.2e-159: tmp = t * (1.0 - (y / z)) elif a <= 2e+71: tmp = y * ((t - x) / (a - z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(y / a) * Float64(x - t))) tmp = 0.0 if (a <= -1.46e-19) tmp = t_1; elseif (a <= 1.3e-243) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 1.2e-159) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (a <= 2e+71) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - ((y / a) * (x - t)); tmp = 0.0; if (a <= -1.46e-19) tmp = t_1; elseif (a <= 1.3e-243) tmp = t + (x * (y / z)); elseif (a <= 1.2e-159) tmp = t * (1.0 - (y / z)); elseif (a <= 2e+71) tmp = y * ((t - x) / (a - z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(y / a), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.46e-19], t$95$1, If[LessEqual[a, 1.3e-243], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.2e-159], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2e+71], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{y}{a} \cdot \left(x - t\right)\\
\mathbf{if}\;a \leq -1.46 \cdot 10^{-19}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.3 \cdot 10^{-243}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 1.2 \cdot 10^{-159}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 2 \cdot 10^{+71}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -1.46000000000000008e-19 or 2.0000000000000001e71 < a Initial program 70.8%
associate-*l/91.0%
Simplified91.0%
Taylor expanded in z around 0 73.2%
if -1.46000000000000008e-19 < a < 1.2999999999999999e-243Initial program 61.0%
associate-*l/68.4%
Simplified68.4%
Taylor expanded in z around inf 82.8%
associate--l+82.8%
associate-*r/82.8%
associate-*r/82.8%
div-sub82.8%
distribute-lft-out--82.8%
associate-*r/82.8%
mul-1-neg82.8%
distribute-rgt-out--82.8%
unsub-neg82.8%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in y around inf 84.1%
Taylor expanded in t around 0 73.0%
associate-*r/76.6%
neg-mul-176.6%
distribute-rgt-neg-in76.6%
distribute-neg-frac76.6%
Simplified76.6%
if 1.2999999999999999e-243 < a < 1.19999999999999999e-159Initial program 78.7%
associate-*l/84.0%
Simplified84.0%
Taylor expanded in z around inf 83.8%
associate--l+83.8%
associate-*r/83.8%
associate-*r/83.8%
div-sub83.8%
distribute-lft-out--83.8%
associate-*r/83.8%
mul-1-neg83.8%
distribute-rgt-out--83.8%
unsub-neg83.8%
associate-/l*88.8%
Simplified88.8%
Taylor expanded in y around inf 88.8%
Taylor expanded in t around inf 88.8%
if 1.19999999999999999e-159 < a < 2.0000000000000001e71Initial program 67.5%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in y around inf 64.5%
div-sub64.5%
Simplified64.5%
Final simplification73.9%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.35e-20)
(- x (* (/ y a) (- x t)))
(if (<= a 3.2e-243)
(+ t (* x (/ y z)))
(if (<= a 3e-160)
(* t (- 1.0 (/ y z)))
(if (<= a 3.8e+63)
(* y (/ (- t x) (- a z)))
(+ x (/ y (/ a (- t x)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.35e-20) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 3.2e-243) {
tmp = t + (x * (y / z));
} else if (a <= 3e-160) {
tmp = t * (1.0 - (y / z));
} else if (a <= 3.8e+63) {
tmp = y * ((t - x) / (a - z));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-2.35d-20)) then
tmp = x - ((y / a) * (x - t))
else if (a <= 3.2d-243) then
tmp = t + (x * (y / z))
else if (a <= 3d-160) then
tmp = t * (1.0d0 - (y / z))
else if (a <= 3.8d+63) then
tmp = y * ((t - x) / (a - z))
else
tmp = x + (y / (a / (t - x)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.35e-20) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 3.2e-243) {
tmp = t + (x * (y / z));
} else if (a <= 3e-160) {
tmp = t * (1.0 - (y / z));
} else if (a <= 3.8e+63) {
tmp = y * ((t - x) / (a - z));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.35e-20: tmp = x - ((y / a) * (x - t)) elif a <= 3.2e-243: tmp = t + (x * (y / z)) elif a <= 3e-160: tmp = t * (1.0 - (y / z)) elif a <= 3.8e+63: tmp = y * ((t - x) / (a - z)) else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.35e-20) tmp = Float64(x - Float64(Float64(y / a) * Float64(x - t))); elseif (a <= 3.2e-243) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 3e-160) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (a <= 3.8e+63) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); else tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.35e-20) tmp = x - ((y / a) * (x - t)); elseif (a <= 3.2e-243) tmp = t + (x * (y / z)); elseif (a <= 3e-160) tmp = t * (1.0 - (y / z)); elseif (a <= 3.8e+63) tmp = y * ((t - x) / (a - z)); else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.35e-20], N[(x - N[(N[(y / a), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.2e-243], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3e-160], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.8e+63], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.35 \cdot 10^{-20}:\\
\;\;\;\;x - \frac{y}{a} \cdot \left(x - t\right)\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{-243}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 3 \cdot 10^{-160}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 3.8 \cdot 10^{+63}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if a < -2.35000000000000007e-20Initial program 70.1%
associate-*l/90.2%
Simplified90.2%
Taylor expanded in z around 0 71.4%
if -2.35000000000000007e-20 < a < 3.1999999999999998e-243Initial program 61.0%
associate-*l/68.4%
Simplified68.4%
Taylor expanded in z around inf 82.8%
associate--l+82.8%
associate-*r/82.8%
associate-*r/82.8%
div-sub82.8%
distribute-lft-out--82.8%
associate-*r/82.8%
mul-1-neg82.8%
distribute-rgt-out--82.8%
unsub-neg82.8%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in y around inf 84.1%
Taylor expanded in t around 0 73.0%
associate-*r/76.6%
neg-mul-176.6%
distribute-rgt-neg-in76.6%
distribute-neg-frac76.6%
Simplified76.6%
if 3.1999999999999998e-243 < a < 2.99999999999999997e-160Initial program 78.7%
associate-*l/84.0%
Simplified84.0%
Taylor expanded in z around inf 83.8%
associate--l+83.8%
associate-*r/83.8%
associate-*r/83.8%
div-sub83.8%
distribute-lft-out--83.8%
associate-*r/83.8%
mul-1-neg83.8%
distribute-rgt-out--83.8%
unsub-neg83.8%
associate-/l*88.8%
Simplified88.8%
Taylor expanded in y around inf 88.8%
Taylor expanded in t around inf 88.8%
if 2.99999999999999997e-160 < a < 3.8000000000000001e63Initial program 67.5%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in y around inf 64.5%
div-sub64.5%
Simplified64.5%
if 3.8000000000000001e63 < a Initial program 71.6%
associate-*l/92.0%
Simplified92.0%
Taylor expanded in z around 0 64.1%
associate-/l*75.4%
Simplified75.4%
Final simplification73.9%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.9e-20)
(- x (* (/ y a) (- x t)))
(if (<= a 7.6e-243)
(+ t (* x (/ y z)))
(if (<= a 1.25e-160)
(* t (- 1.0 (/ y z)))
(if (<= a 8.6e+45)
(* (- t x) (/ y (- a z)))
(+ x (/ (- t x) (/ a y))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.9e-20) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 7.6e-243) {
tmp = t + (x * (y / z));
} else if (a <= 1.25e-160) {
tmp = t * (1.0 - (y / z));
} else if (a <= 8.6e+45) {
tmp = (t - x) * (y / (a - z));
} else {
tmp = x + ((t - x) / (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 (a <= (-2.9d-20)) then
tmp = x - ((y / a) * (x - t))
else if (a <= 7.6d-243) then
tmp = t + (x * (y / z))
else if (a <= 1.25d-160) then
tmp = t * (1.0d0 - (y / z))
else if (a <= 8.6d+45) then
tmp = (t - x) * (y / (a - z))
else
tmp = x + ((t - x) / (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 (a <= -2.9e-20) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 7.6e-243) {
tmp = t + (x * (y / z));
} else if (a <= 1.25e-160) {
tmp = t * (1.0 - (y / z));
} else if (a <= 8.6e+45) {
tmp = (t - x) * (y / (a - z));
} else {
tmp = x + ((t - x) / (a / y));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -2.9e-20: tmp = x - ((y / a) * (x - t)) elif a <= 7.6e-243: tmp = t + (x * (y / z)) elif a <= 1.25e-160: tmp = t * (1.0 - (y / z)) elif a <= 8.6e+45: tmp = (t - x) * (y / (a - z)) else: tmp = x + ((t - x) / (a / y)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.9e-20) tmp = Float64(x - Float64(Float64(y / a) * Float64(x - t))); elseif (a <= 7.6e-243) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 1.25e-160) tmp = Float64(t * Float64(1.0 - Float64(y / z))); elseif (a <= 8.6e+45) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); else tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -2.9e-20) tmp = x - ((y / a) * (x - t)); elseif (a <= 7.6e-243) tmp = t + (x * (y / z)); elseif (a <= 1.25e-160) tmp = t * (1.0 - (y / z)); elseif (a <= 8.6e+45) tmp = (t - x) * (y / (a - z)); else tmp = x + ((t - x) / (a / y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.9e-20], N[(x - N[(N[(y / a), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.6e-243], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.25e-160], N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 8.6e+45], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.9 \cdot 10^{-20}:\\
\;\;\;\;x - \frac{y}{a} \cdot \left(x - t\right)\\
\mathbf{elif}\;a \leq 7.6 \cdot 10^{-243}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{-160}:\\
\;\;\;\;t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{elif}\;a \leq 8.6 \cdot 10^{+45}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\
\end{array}
\end{array}
if a < -2.9e-20Initial program 70.1%
associate-*l/90.2%
Simplified90.2%
Taylor expanded in z around 0 71.4%
if -2.9e-20 < a < 7.5999999999999996e-243Initial program 61.0%
associate-*l/68.4%
Simplified68.4%
Taylor expanded in z around inf 82.8%
associate--l+82.8%
associate-*r/82.8%
associate-*r/82.8%
div-sub82.8%
distribute-lft-out--82.8%
associate-*r/82.8%
mul-1-neg82.8%
distribute-rgt-out--82.8%
unsub-neg82.8%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in y around inf 84.1%
Taylor expanded in t around 0 73.0%
associate-*r/76.6%
neg-mul-176.6%
distribute-rgt-neg-in76.6%
distribute-neg-frac76.6%
Simplified76.6%
if 7.5999999999999996e-243 < a < 1.24999999999999999e-160Initial program 78.7%
associate-*l/84.0%
Simplified84.0%
Taylor expanded in z around inf 83.8%
associate--l+83.8%
associate-*r/83.8%
associate-*r/83.8%
div-sub83.8%
distribute-lft-out--83.8%
associate-*r/83.8%
mul-1-neg83.8%
distribute-rgt-out--83.8%
unsub-neg83.8%
associate-/l*88.8%
Simplified88.8%
Taylor expanded in y around inf 88.8%
Taylor expanded in t around inf 88.8%
if 1.24999999999999999e-160 < a < 8.6000000000000006e45Initial program 66.8%
associate-*l/75.1%
Simplified75.1%
Taylor expanded in y around -inf 53.2%
associate-*l/63.7%
Simplified63.7%
if 8.6000000000000006e45 < a Initial program 72.2%
associate-*l/92.1%
Simplified92.1%
Taylor expanded in z around 0 75.8%
*-commutative75.8%
clear-num75.8%
un-div-inv75.9%
Applied egg-rr75.9%
Final simplification73.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (* (/ y a) (- x t)))))
(if (<= a -4.6e-20)
t_1
(if (<= a 5e-106)
(+ t (/ (- x t) (/ z y)))
(if (<= a 4.6e-74)
t_1
(if (<= a 2.15e+22)
(* (- t x) (/ y (- a z)))
(+ x (/ (- t x) (/ a y)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((y / a) * (x - t));
double tmp;
if (a <= -4.6e-20) {
tmp = t_1;
} else if (a <= 5e-106) {
tmp = t + ((x - t) / (z / y));
} else if (a <= 4.6e-74) {
tmp = t_1;
} else if (a <= 2.15e+22) {
tmp = (t - x) * (y / (a - z));
} else {
tmp = x + ((t - x) / (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) :: t_1
real(8) :: tmp
t_1 = x - ((y / a) * (x - t))
if (a <= (-4.6d-20)) then
tmp = t_1
else if (a <= 5d-106) then
tmp = t + ((x - t) / (z / y))
else if (a <= 4.6d-74) then
tmp = t_1
else if (a <= 2.15d+22) then
tmp = (t - x) * (y / (a - z))
else
tmp = x + ((t - x) / (a / y))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((y / a) * (x - t));
double tmp;
if (a <= -4.6e-20) {
tmp = t_1;
} else if (a <= 5e-106) {
tmp = t + ((x - t) / (z / y));
} else if (a <= 4.6e-74) {
tmp = t_1;
} else if (a <= 2.15e+22) {
tmp = (t - x) * (y / (a - z));
} else {
tmp = x + ((t - x) / (a / y));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - ((y / a) * (x - t)) tmp = 0 if a <= -4.6e-20: tmp = t_1 elif a <= 5e-106: tmp = t + ((x - t) / (z / y)) elif a <= 4.6e-74: tmp = t_1 elif a <= 2.15e+22: tmp = (t - x) * (y / (a - z)) else: tmp = x + ((t - x) / (a / y)) return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(y / a) * Float64(x - t))) tmp = 0.0 if (a <= -4.6e-20) tmp = t_1; elseif (a <= 5e-106) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / y))); elseif (a <= 4.6e-74) tmp = t_1; elseif (a <= 2.15e+22) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); else tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - ((y / a) * (x - t)); tmp = 0.0; if (a <= -4.6e-20) tmp = t_1; elseif (a <= 5e-106) tmp = t + ((x - t) / (z / y)); elseif (a <= 4.6e-74) tmp = t_1; elseif (a <= 2.15e+22) tmp = (t - x) * (y / (a - z)); else tmp = x + ((t - x) / (a / y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(y / a), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.6e-20], t$95$1, If[LessEqual[a, 5e-106], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.6e-74], t$95$1, If[LessEqual[a, 2.15e+22], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{y}{a} \cdot \left(x - t\right)\\
\mathbf{if}\;a \leq -4.6 \cdot 10^{-20}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 5 \cdot 10^{-106}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{-74}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 2.15 \cdot 10^{+22}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\
\end{array}
\end{array}
if a < -4.5999999999999998e-20 or 4.99999999999999983e-106 < a < 4.59999999999999961e-74Initial program 72.7%
associate-*l/91.1%
Simplified91.1%
Taylor expanded in z around 0 73.9%
if -4.5999999999999998e-20 < a < 4.99999999999999983e-106Initial program 62.3%
associate-*l/70.3%
Simplified70.3%
Taylor expanded in z around inf 82.0%
associate--l+82.0%
associate-*r/82.0%
associate-*r/82.0%
div-sub82.0%
distribute-lft-out--82.0%
associate-*r/82.0%
mul-1-neg82.0%
distribute-rgt-out--82.0%
unsub-neg82.0%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in y around inf 84.7%
if 4.59999999999999961e-74 < a < 2.1500000000000001e22Initial program 68.2%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in y around -inf 51.9%
associate-*l/55.6%
Simplified55.6%
if 2.1500000000000001e22 < a Initial program 72.0%
associate-*l/90.7%
Simplified90.7%
Taylor expanded in z around 0 75.3%
*-commutative75.3%
clear-num75.3%
un-div-inv75.4%
Applied egg-rr75.4%
Final simplification77.2%
(FPCore (x y z t a)
:precision binary64
(if (<= a -7.5e-19)
(- x (* (/ y a) (- x t)))
(if (<= a 4.5e-108)
(+ t (/ (- x t) (/ z y)))
(if (<= a 2.05e-19)
(* (- t x) (/ y (- a z)))
(if (<= a 0.00036)
(/ t (/ (- a z) (- y z)))
(+ x (/ (- t x) (/ a y))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -7.5e-19) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 4.5e-108) {
tmp = t + ((x - t) / (z / y));
} else if (a <= 2.05e-19) {
tmp = (t - x) * (y / (a - z));
} else if (a <= 0.00036) {
tmp = t / ((a - z) / (y - z));
} else {
tmp = x + ((t - x) / (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 (a <= (-7.5d-19)) then
tmp = x - ((y / a) * (x - t))
else if (a <= 4.5d-108) then
tmp = t + ((x - t) / (z / y))
else if (a <= 2.05d-19) then
tmp = (t - x) * (y / (a - z))
else if (a <= 0.00036d0) then
tmp = t / ((a - z) / (y - z))
else
tmp = x + ((t - x) / (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 (a <= -7.5e-19) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 4.5e-108) {
tmp = t + ((x - t) / (z / y));
} else if (a <= 2.05e-19) {
tmp = (t - x) * (y / (a - z));
} else if (a <= 0.00036) {
tmp = t / ((a - z) / (y - z));
} else {
tmp = x + ((t - x) / (a / y));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -7.5e-19: tmp = x - ((y / a) * (x - t)) elif a <= 4.5e-108: tmp = t + ((x - t) / (z / y)) elif a <= 2.05e-19: tmp = (t - x) * (y / (a - z)) elif a <= 0.00036: tmp = t / ((a - z) / (y - z)) else: tmp = x + ((t - x) / (a / y)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -7.5e-19) tmp = Float64(x - Float64(Float64(y / a) * Float64(x - t))); elseif (a <= 4.5e-108) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / y))); elseif (a <= 2.05e-19) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); elseif (a <= 0.00036) tmp = Float64(t / Float64(Float64(a - z) / Float64(y - z))); else tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -7.5e-19) tmp = x - ((y / a) * (x - t)); elseif (a <= 4.5e-108) tmp = t + ((x - t) / (z / y)); elseif (a <= 2.05e-19) tmp = (t - x) * (y / (a - z)); elseif (a <= 0.00036) tmp = t / ((a - z) / (y - z)); else tmp = x + ((t - x) / (a / y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -7.5e-19], N[(x - N[(N[(y / a), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.5e-108], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.05e-19], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 0.00036], N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -7.5 \cdot 10^{-19}:\\
\;\;\;\;x - \frac{y}{a} \cdot \left(x - t\right)\\
\mathbf{elif}\;a \leq 4.5 \cdot 10^{-108}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 2.05 \cdot 10^{-19}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{elif}\;a \leq 0.00036:\\
\;\;\;\;\frac{t}{\frac{a - z}{y - z}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\
\end{array}
\end{array}
if a < -7.49999999999999957e-19Initial program 70.1%
associate-*l/90.2%
Simplified90.2%
Taylor expanded in z around 0 71.4%
if -7.49999999999999957e-19 < a < 4.4999999999999997e-108Initial program 62.3%
associate-*l/70.3%
Simplified70.3%
Taylor expanded in z around inf 82.0%
associate--l+82.0%
associate-*r/82.0%
associate-*r/82.0%
div-sub82.0%
distribute-lft-out--82.0%
associate-*r/82.0%
mul-1-neg82.0%
distribute-rgt-out--82.0%
unsub-neg82.0%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in y around inf 84.7%
if 4.4999999999999997e-108 < a < 2.04999999999999993e-19Initial program 78.4%
associate-*l/83.8%
Simplified83.8%
Taylor expanded in y around -inf 62.3%
associate-*l/67.4%
Simplified67.4%
if 2.04999999999999993e-19 < a < 3.60000000000000023e-4Initial program 83.3%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in x around 0 66.1%
associate-/l*82.8%
Simplified82.8%
if 3.60000000000000023e-4 < a Initial program 70.4%
associate-*l/87.0%
Simplified87.0%
Taylor expanded in z around 0 71.8%
*-commutative71.8%
clear-num71.8%
un-div-inv71.9%
Applied egg-rr71.9%
Final simplification77.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (- 1.0 (/ y z)))))
(if (<= a -9.5e-28)
x
(if (<= a -1.2e-276)
t_1
(if (<= a 5.2e-291) (/ x (/ z y)) (if (<= a 6.7e+19) t_1 x))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double tmp;
if (a <= -9.5e-28) {
tmp = x;
} else if (a <= -1.2e-276) {
tmp = t_1;
} else if (a <= 5.2e-291) {
tmp = x / (z / y);
} else if (a <= 6.7e+19) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t * (1.0d0 - (y / z))
if (a <= (-9.5d-28)) then
tmp = x
else if (a <= (-1.2d-276)) then
tmp = t_1
else if (a <= 5.2d-291) then
tmp = x / (z / y)
else if (a <= 6.7d+19) then
tmp = t_1
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double tmp;
if (a <= -9.5e-28) {
tmp = x;
} else if (a <= -1.2e-276) {
tmp = t_1;
} else if (a <= 5.2e-291) {
tmp = x / (z / y);
} else if (a <= 6.7e+19) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (1.0 - (y / z)) tmp = 0 if a <= -9.5e-28: tmp = x elif a <= -1.2e-276: tmp = t_1 elif a <= 5.2e-291: tmp = x / (z / y) elif a <= 6.7e+19: tmp = t_1 else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(1.0 - Float64(y / z))) tmp = 0.0 if (a <= -9.5e-28) tmp = x; elseif (a <= -1.2e-276) tmp = t_1; elseif (a <= 5.2e-291) tmp = Float64(x / Float64(z / y)); elseif (a <= 6.7e+19) tmp = t_1; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (1.0 - (y / z)); tmp = 0.0; if (a <= -9.5e-28) tmp = x; elseif (a <= -1.2e-276) tmp = t_1; elseif (a <= 5.2e-291) tmp = x / (z / y); elseif (a <= 6.7e+19) tmp = t_1; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -9.5e-28], x, If[LessEqual[a, -1.2e-276], t$95$1, If[LessEqual[a, 5.2e-291], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 6.7e+19], t$95$1, x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{if}\;a \leq -9.5 \cdot 10^{-28}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.2 \cdot 10^{-276}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 5.2 \cdot 10^{-291}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 6.7 \cdot 10^{+19}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -9.50000000000000001e-28 or 6.7e19 < a Initial program 70.0%
associate-*l/88.8%
Simplified88.8%
Taylor expanded in a around inf 42.5%
if -9.50000000000000001e-28 < a < -1.19999999999999991e-276 or 5.1999999999999997e-291 < a < 6.7e19Initial program 65.2%
associate-*l/73.0%
Simplified73.0%
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%
associate-*r/76.1%
mul-1-neg76.1%
distribute-rgt-out--76.1%
unsub-neg76.1%
associate-/l*80.2%
Simplified80.2%
Taylor expanded in y around inf 73.7%
Taylor expanded in t around inf 55.0%
if -1.19999999999999991e-276 < a < 5.1999999999999997e-291Initial program 67.8%
associate-*l/74.1%
Simplified74.1%
Taylor expanded in z around inf 93.4%
associate--l+93.4%
associate-*r/93.4%
associate-*r/93.4%
div-sub93.4%
distribute-lft-out--93.4%
associate-*r/93.4%
mul-1-neg93.4%
distribute-rgt-out--93.4%
unsub-neg93.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in t around 0 74.2%
associate-/l*80.8%
Simplified80.8%
Final simplification50.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (- 1.0 (/ y z)))) (t_2 (* x (- 1.0 (/ y a)))))
(if (<= a -4e-35)
t_2
(if (<= a -1.95e-276)
t_1
(if (<= a 3e-291) (/ x (/ z y)) (if (<= a 5e-106) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (1.0 - (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -4e-35) {
tmp = t_2;
} else if (a <= -1.95e-276) {
tmp = t_1;
} else if (a <= 3e-291) {
tmp = x / (z / y);
} else if (a <= 5e-106) {
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 * (1.0d0 - (y / z))
t_2 = x * (1.0d0 - (y / a))
if (a <= (-4d-35)) then
tmp = t_2
else if (a <= (-1.95d-276)) then
tmp = t_1
else if (a <= 3d-291) then
tmp = x / (z / y)
else if (a <= 5d-106) 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 * (1.0 - (y / z));
double t_2 = x * (1.0 - (y / a));
double tmp;
if (a <= -4e-35) {
tmp = t_2;
} else if (a <= -1.95e-276) {
tmp = t_1;
} else if (a <= 3e-291) {
tmp = x / (z / y);
} else if (a <= 5e-106) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (1.0 - (y / z)) t_2 = x * (1.0 - (y / a)) tmp = 0 if a <= -4e-35: tmp = t_2 elif a <= -1.95e-276: tmp = t_1 elif a <= 3e-291: tmp = x / (z / y) elif a <= 5e-106: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(1.0 - Float64(y / z))) t_2 = Float64(x * Float64(1.0 - Float64(y / a))) tmp = 0.0 if (a <= -4e-35) tmp = t_2; elseif (a <= -1.95e-276) tmp = t_1; elseif (a <= 3e-291) tmp = Float64(x / Float64(z / y)); elseif (a <= 5e-106) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (1.0 - (y / z)); t_2 = x * (1.0 - (y / a)); tmp = 0.0; if (a <= -4e-35) tmp = t_2; elseif (a <= -1.95e-276) tmp = t_1; elseif (a <= 3e-291) tmp = x / (z / y); elseif (a <= 5e-106) 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[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4e-35], t$95$2, If[LessEqual[a, -1.95e-276], t$95$1, If[LessEqual[a, 3e-291], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5e-106], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(1 - \frac{y}{z}\right)\\
t_2 := x \cdot \left(1 - \frac{y}{a}\right)\\
\mathbf{if}\;a \leq -4 \cdot 10^{-35}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -1.95 \cdot 10^{-276}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 3 \cdot 10^{-291}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 5 \cdot 10^{-106}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -4.00000000000000003e-35 or 4.99999999999999983e-106 < a Initial program 70.8%
associate-*l/87.2%
Simplified87.2%
Taylor expanded in z around 0 66.8%
Taylor expanded in x around inf 52.4%
mul-1-neg52.4%
unsub-neg52.4%
Simplified52.4%
if -4.00000000000000003e-35 < a < -1.95e-276 or 3.0000000000000001e-291 < a < 4.99999999999999983e-106Initial program 62.2%
associate-*l/70.5%
Simplified70.5%
Taylor expanded in z around inf 83.2%
associate--l+83.2%
associate-*r/83.2%
associate-*r/83.2%
div-sub83.2%
distribute-lft-out--83.2%
associate-*r/83.2%
mul-1-neg83.2%
distribute-rgt-out--83.2%
unsub-neg83.2%
associate-/l*87.6%
Simplified87.6%
Taylor expanded in y around inf 83.3%
Taylor expanded in t around inf 63.7%
if -1.95e-276 < a < 3.0000000000000001e-291Initial program 67.8%
associate-*l/74.1%
Simplified74.1%
Taylor expanded in z around inf 93.4%
associate--l+93.4%
associate-*r/93.4%
associate-*r/93.4%
div-sub93.4%
distribute-lft-out--93.4%
associate-*r/93.4%
mul-1-neg93.4%
distribute-rgt-out--93.4%
unsub-neg93.4%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in t around 0 74.2%
associate-/l*80.8%
Simplified80.8%
Final simplification58.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t x) (- a z)))))
(if (<= y -2.25e+33)
t_1
(if (<= y 6e-297)
(+ t (* x (/ y z)))
(if (<= y 1.55e-10) (- x (/ (* x y) a)) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / (a - z));
double tmp;
if (y <= -2.25e+33) {
tmp = t_1;
} else if (y <= 6e-297) {
tmp = t + (x * (y / z));
} else if (y <= 1.55e-10) {
tmp = x - ((x * y) / a);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = y * ((t - x) / (a - z))
if (y <= (-2.25d+33)) then
tmp = t_1
else if (y <= 6d-297) then
tmp = t + (x * (y / z))
else if (y <= 1.55d-10) then
tmp = x - ((x * y) / a)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / (a - z));
double tmp;
if (y <= -2.25e+33) {
tmp = t_1;
} else if (y <= 6e-297) {
tmp = t + (x * (y / z));
} else if (y <= 1.55e-10) {
tmp = x - ((x * y) / a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - x) / (a - z)) tmp = 0 if y <= -2.25e+33: tmp = t_1 elif y <= 6e-297: tmp = t + (x * (y / z)) elif y <= 1.55e-10: tmp = x - ((x * y) / a) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - x) / Float64(a - z))) tmp = 0.0 if (y <= -2.25e+33) tmp = t_1; elseif (y <= 6e-297) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (y <= 1.55e-10) tmp = Float64(x - Float64(Float64(x * y) / a)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - x) / (a - z)); tmp = 0.0; if (y <= -2.25e+33) tmp = t_1; elseif (y <= 6e-297) tmp = t + (x * (y / z)); elseif (y <= 1.55e-10) tmp = x - ((x * y) / a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.25e+33], t$95$1, If[LessEqual[y, 6e-297], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.55e-10], N[(x - N[(N[(x * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;y \leq -2.25 \cdot 10^{+33}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 6 \cdot 10^{-297}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;y \leq 1.55 \cdot 10^{-10}:\\
\;\;\;\;x - \frac{x \cdot y}{a}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -2.25e33 or 1.55000000000000008e-10 < y Initial program 71.6%
associate-*l/86.6%
Simplified86.6%
Taylor expanded in y around inf 76.3%
div-sub76.3%
Simplified76.3%
if -2.25e33 < y < 5.9999999999999999e-297Initial program 55.6%
associate-*l/68.4%
Simplified68.4%
Taylor expanded in z around inf 59.7%
associate--l+59.7%
associate-*r/59.7%
associate-*r/59.7%
div-sub59.7%
distribute-lft-out--59.7%
associate-*r/59.7%
mul-1-neg59.7%
distribute-rgt-out--59.7%
unsub-neg59.7%
associate-/l*66.8%
Simplified66.8%
Taylor expanded in y around inf 54.9%
Taylor expanded in t around 0 54.4%
associate-*r/54.7%
neg-mul-154.7%
distribute-rgt-neg-in54.7%
distribute-neg-frac54.7%
Simplified54.7%
if 5.9999999999999999e-297 < y < 1.55000000000000008e-10Initial program 70.5%
associate-*l/78.7%
Simplified78.7%
Taylor expanded in z around 0 51.2%
Taylor expanded in t around 0 47.8%
mul-1-neg47.8%
Simplified47.8%
Final simplification64.8%
(FPCore (x y z t a)
:precision binary64
(if (<= a -6e-43)
(- x (* (/ y a) (- x t)))
(if (<= a 2.1e-159)
(+ t (/ (* y (- x t)) z))
(if (<= a 3.5e+48) (* (- t x) (/ y (- a z))) (+ x (/ (- t x) (/ a y)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -6e-43) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 2.1e-159) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 3.5e+48) {
tmp = (t - x) * (y / (a - z));
} else {
tmp = x + ((t - x) / (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 (a <= (-6d-43)) then
tmp = x - ((y / a) * (x - t))
else if (a <= 2.1d-159) then
tmp = t + ((y * (x - t)) / z)
else if (a <= 3.5d+48) then
tmp = (t - x) * (y / (a - z))
else
tmp = x + ((t - x) / (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 (a <= -6e-43) {
tmp = x - ((y / a) * (x - t));
} else if (a <= 2.1e-159) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 3.5e+48) {
tmp = (t - x) * (y / (a - z));
} else {
tmp = x + ((t - x) / (a / y));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -6e-43: tmp = x - ((y / a) * (x - t)) elif a <= 2.1e-159: tmp = t + ((y * (x - t)) / z) elif a <= 3.5e+48: tmp = (t - x) * (y / (a - z)) else: tmp = x + ((t - x) / (a / y)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -6e-43) tmp = Float64(x - Float64(Float64(y / a) * Float64(x - t))); elseif (a <= 2.1e-159) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (a <= 3.5e+48) tmp = Float64(Float64(t - x) * Float64(y / Float64(a - z))); else tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -6e-43) tmp = x - ((y / a) * (x - t)); elseif (a <= 2.1e-159) tmp = t + ((y * (x - t)) / z); elseif (a <= 3.5e+48) tmp = (t - x) * (y / (a - z)); else tmp = x + ((t - x) / (a / y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -6e-43], N[(x - N[(N[(y / a), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.1e-159], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.5e+48], N[(N[(t - x), $MachinePrecision] * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6 \cdot 10^{-43}:\\
\;\;\;\;x - \frac{y}{a} \cdot \left(x - t\right)\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{-159}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;a \leq 3.5 \cdot 10^{+48}:\\
\;\;\;\;\left(t - x\right) \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\
\end{array}
\end{array}
if a < -6.00000000000000007e-43Initial program 67.9%
associate-*l/86.3%
Simplified86.3%
Taylor expanded in z around 0 67.7%
if -6.00000000000000007e-43 < a < 2.0999999999999999e-159Initial program 65.3%
associate-*l/72.5%
Simplified72.5%
Taylor expanded in z around inf 86.7%
associate--l+86.7%
associate-*r/86.7%
associate-*r/86.7%
div-sub86.7%
distribute-lft-out--86.7%
associate-*r/86.7%
mul-1-neg86.7%
distribute-rgt-out--86.7%
unsub-neg86.7%
associate-/l*89.1%
Simplified89.1%
Taylor expanded in y around inf 84.6%
if 2.0999999999999999e-159 < a < 3.4999999999999997e48Initial program 66.8%
associate-*l/75.1%
Simplified75.1%
Taylor expanded in y around -inf 53.2%
associate-*l/63.7%
Simplified63.7%
if 3.4999999999999997e48 < a Initial program 72.2%
associate-*l/92.1%
Simplified92.1%
Taylor expanded in z around 0 75.8%
*-commutative75.8%
clear-num75.8%
un-div-inv75.9%
Applied egg-rr75.9%
Final simplification74.8%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -1.05e+116) (not (<= z 1.3e+76))) (+ t (/ (- x t) (/ z (- y a)))) (+ x (* (- t x) (/ (- y z) (- a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.05e+116) || !(z <= 1.3e+76)) {
tmp = t + ((x - t) / (z / (y - a)));
} else {
tmp = x + ((t - x) * ((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.05d+116)) .or. (.not. (z <= 1.3d+76))) then
tmp = t + ((x - t) / (z / (y - a)))
else
tmp = x + ((t - x) * ((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.05e+116) || !(z <= 1.3e+76)) {
tmp = t + ((x - t) / (z / (y - a)));
} else {
tmp = x + ((t - x) * ((y - z) / (a - z)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -1.05e+116) or not (z <= 1.3e+76): tmp = t + ((x - t) / (z / (y - a))) else: tmp = x + ((t - x) * ((y - z) / (a - z))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -1.05e+116) || !(z <= 1.3e+76)) tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); else tmp = Float64(x + Float64(Float64(t - x) * 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.05e+116) || ~((z <= 1.3e+76))) tmp = t + ((x - t) / (z / (y - a))); else tmp = x + ((t - x) * ((y - z) / (a - z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.05e+116], N[Not[LessEqual[z, 1.3e+76]], $MachinePrecision]], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.05 \cdot 10^{+116} \lor \neg \left(z \leq 1.3 \cdot 10^{+76}\right):\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\mathbf{else}:\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\end{array}
\end{array}
if z < -1.0500000000000001e116 or 1.3e76 < z Initial program 35.2%
associate-*l/56.5%
Simplified56.5%
Taylor expanded in z around inf 67.8%
associate--l+67.8%
associate-*r/67.8%
associate-*r/67.8%
div-sub67.8%
distribute-lft-out--67.8%
associate-*r/67.8%
mul-1-neg67.8%
distribute-rgt-out--68.9%
unsub-neg68.9%
associate-/l*86.5%
Simplified86.5%
if -1.0500000000000001e116 < z < 1.3e76Initial program 85.2%
associate-*l/93.6%
Simplified93.6%
Final simplification91.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ y a))))
(if (<= y -4.5e+144)
t_1
(if (<= y -4.5e-287) t (if (<= y 2.75e-17) x t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (y / a);
double tmp;
if (y <= -4.5e+144) {
tmp = t_1;
} else if (y <= -4.5e-287) {
tmp = t;
} else if (y <= 2.75e-17) {
tmp = 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 / a)
if (y <= (-4.5d+144)) then
tmp = t_1
else if (y <= (-4.5d-287)) then
tmp = t
else if (y <= 2.75d-17) then
tmp = 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 / a);
double tmp;
if (y <= -4.5e+144) {
tmp = t_1;
} else if (y <= -4.5e-287) {
tmp = t;
} else if (y <= 2.75e-17) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (y / a) tmp = 0 if y <= -4.5e+144: tmp = t_1 elif y <= -4.5e-287: tmp = t elif y <= 2.75e-17: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(y / a)) tmp = 0.0 if (y <= -4.5e+144) tmp = t_1; elseif (y <= -4.5e-287) tmp = t; elseif (y <= 2.75e-17) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (y / a); tmp = 0.0; if (y <= -4.5e+144) tmp = t_1; elseif (y <= -4.5e-287) tmp = t; elseif (y <= 2.75e-17) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.5e+144], t$95$1, If[LessEqual[y, -4.5e-287], t, If[LessEqual[y, 2.75e-17], x, t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y}{a}\\
\mathbf{if}\;y \leq -4.5 \cdot 10^{+144}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -4.5 \cdot 10^{-287}:\\
\;\;\;\;t\\
\mathbf{elif}\;y \leq 2.75 \cdot 10^{-17}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -4.49999999999999967e144 or 2.75e-17 < y Initial program 73.2%
associate-*l/89.8%
Simplified89.8%
Taylor expanded in x around 0 38.9%
associate-/l*49.7%
Simplified49.7%
Taylor expanded in z around 0 34.3%
Taylor expanded in t around 0 29.0%
associate-*r/34.3%
Simplified34.3%
if -4.49999999999999967e144 < y < -4.50000000000000017e-287Initial program 57.2%
associate-*l/68.9%
Simplified68.9%
Taylor expanded in z around inf 38.2%
if -4.50000000000000017e-287 < y < 2.75e-17Initial program 70.9%
associate-*l/78.5%
Simplified78.5%
Taylor expanded in a around inf 46.8%
Final simplification38.5%
(FPCore (x y z t a) :precision binary64 (if (<= a -9.5e-28) x (if (<= a 6.6e+19) t x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -9.5e-28) {
tmp = x;
} else if (a <= 6.6e+19) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-9.5d-28)) then
tmp = x
else if (a <= 6.6d+19) then
tmp = t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -9.5e-28) {
tmp = x;
} else if (a <= 6.6e+19) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -9.5e-28: tmp = x elif a <= 6.6e+19: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -9.5e-28) tmp = x; elseif (a <= 6.6e+19) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -9.5e-28) tmp = x; elseif (a <= 6.6e+19) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -9.5e-28], x, If[LessEqual[a, 6.6e+19], t, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -9.5 \cdot 10^{-28}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 6.6 \cdot 10^{+19}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -9.50000000000000001e-28 or 6.6e19 < a Initial program 70.0%
associate-*l/88.8%
Simplified88.8%
Taylor expanded in a around inf 42.5%
if -9.50000000000000001e-28 < a < 6.6e19Initial program 65.5%
associate-*l/73.1%
Simplified73.1%
Taylor expanded in z around inf 34.1%
Final simplification38.1%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 67.6%
associate-*l/80.5%
Simplified80.5%
Taylor expanded in z around inf 22.8%
Final simplification22.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* (/ y z) (- t x)))))
(if (< z -1.2536131056095036e+188)
t_1
(if (< z 4.446702369113811e+64)
(+ x (/ (- y z) (/ (- a z) (- t x))))
t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = t - ((y / z) * (t - x))
if (z < (-1.2536131056095036d+188)) then
tmp = t_1
else if (z < 4.446702369113811d+64) then
tmp = x + ((y - z) / ((a - z) / (t - x)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - ((y / z) * (t - x));
double tmp;
if (z < -1.2536131056095036e+188) {
tmp = t_1;
} else if (z < 4.446702369113811e+64) {
tmp = x + ((y - z) / ((a - z) / (t - x)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - ((y / z) * (t - x)) tmp = 0 if z < -1.2536131056095036e+188: tmp = t_1 elif z < 4.446702369113811e+64: tmp = x + ((y - z) / ((a - z) / (t - x))) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(Float64(y / z) * Float64(t - x))) tmp = 0.0 if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = Float64(x + Float64(Float64(y - z) / Float64(Float64(a - z) / Float64(t - x)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - ((y / z) * (t - x)); tmp = 0.0; if (z < -1.2536131056095036e+188) tmp = t_1; elseif (z < 4.446702369113811e+64) tmp = x + ((y - z) / ((a - z) / (t - x))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(N[(y / z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -1.2536131056095036e+188], t$95$1, If[Less[z, 4.446702369113811e+64], N[(x + N[(N[(y - z), $MachinePrecision] / N[(N[(a - z), $MachinePrecision] / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - \frac{y}{z} \cdot \left(t - x\right)\\
\mathbf{if}\;z < -1.2536131056095036 \cdot 10^{+188}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z < 4.446702369113811 \cdot 10^{+64}:\\
\;\;\;\;x + \frac{y - z}{\frac{a - z}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
herbie shell --seed 2024020
(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))))