
(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 20 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y z) (- t x)) (- a z))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + (((y - z) * (t - x)) / (a - z))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - z) * (t - x)) / (a - z));
}
def code(x, y, z, t, a): return x + (((y - z) * (t - x)) / (a - z))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - z) * (t - x)) / (a - z)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* (- y z) (- t x)) (- a z)))))
(if (or (<= t_1 -5e-282) (not (<= t_1 0.0)))
(+ x (* (- t x) (/ (- y z) (- a z))))
(+ t (/ (* (- y a) (- x t)) z)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-282) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + (((y - a) * (x - t)) / z);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + (((y - z) * (t - x)) / (a - z))
if ((t_1 <= (-5d-282)) .or. (.not. (t_1 <= 0.0d0))) then
tmp = x + ((t - x) * ((y - z) / (a - z)))
else
tmp = t + (((y - a) * (x - t)) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - z) * (t - x)) / (a - z));
double tmp;
if ((t_1 <= -5e-282) || !(t_1 <= 0.0)) {
tmp = x + ((t - x) * ((y - z) / (a - z)));
} else {
tmp = t + (((y - a) * (x - t)) / z);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - z) * (t - x)) / (a - z)) tmp = 0 if (t_1 <= -5e-282) or not (t_1 <= 0.0): tmp = x + ((t - x) * ((y - z) / (a - z))) else: tmp = t + (((y - a) * (x - t)) / z) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - z) * Float64(t - x)) / Float64(a - z))) tmp = 0.0 if ((t_1 <= -5e-282) || !(t_1 <= 0.0)) tmp = Float64(x + Float64(Float64(t - x) * Float64(Float64(y - z) / Float64(a - z)))); else tmp = Float64(t + Float64(Float64(Float64(y - a) * Float64(x - t)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((y - z) * (t - x)) / (a - z)); tmp = 0.0; if ((t_1 <= -5e-282) || ~((t_1 <= 0.0))) tmp = x + ((t - x) * ((y - z) / (a - z))); else tmp = t + (((y - a) * (x - t)) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - z), $MachinePrecision] * N[(t - x), $MachinePrecision]), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-282], N[Not[LessEqual[t$95$1, 0.0]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(N[(y - a), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\left(y - z\right) \cdot \left(t - x\right)}{a - z}\\
\mathbf{if}\;t_1 \leq -5 \cdot 10^{-282} \lor \neg \left(t_1 \leq 0\right):\\
\;\;\;\;x + \left(t - x\right) \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{\left(y - a\right) \cdot \left(x - t\right)}{z}\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < -5.0000000000000001e-282 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) Initial program 74.2%
associate-*l/90.0%
Simplified90.0%
if -5.0000000000000001e-282 < (+.f64 x (/.f64 (*.f64 (-.f64 y z) (-.f64 t x)) (-.f64 a z))) < 0.0Initial program 4.5%
+-commutative4.5%
associate-*l/4.5%
fma-def4.5%
Simplified4.5%
Taylor expanded in z around -inf 99.9%
Final simplification90.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* t (/ (- y z) a))))
(t_2 (- t (/ (- t x) (/ z y))))
(t_3 (- t (* x (/ (- a y) z)))))
(if (<= a -3.4e+125)
t_1
(if (<= a -5.5e+43)
(/ t (/ (- a z) (- y z)))
(if (<= a -1.3e+33)
t_1
(if (<= a -5.2e-50)
t_3
(if (<= a -3.2e-83)
(* y (/ (- t x) (- a z)))
(if (<= a -5.4e-129)
t_2
(if (<= a -1.22e-211)
t_3
(if (<= a 1.3e-127)
t_2
(if (<= a 3.9e+77)
(* t (/ (- y z) (- a z)))
(+ x (/ y (/ a (- t x)))))))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (t * ((y - z) / a));
double t_2 = t - ((t - x) / (z / y));
double t_3 = t - (x * ((a - y) / z));
double tmp;
if (a <= -3.4e+125) {
tmp = t_1;
} else if (a <= -5.5e+43) {
tmp = t / ((a - z) / (y - z));
} else if (a <= -1.3e+33) {
tmp = t_1;
} else if (a <= -5.2e-50) {
tmp = t_3;
} else if (a <= -3.2e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= -5.4e-129) {
tmp = t_2;
} else if (a <= -1.22e-211) {
tmp = t_3;
} else if (a <= 1.3e-127) {
tmp = t_2;
} else if (a <= 3.9e+77) {
tmp = t * ((y - z) / (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) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (t * ((y - z) / a))
t_2 = t - ((t - x) / (z / y))
t_3 = t - (x * ((a - y) / z))
if (a <= (-3.4d+125)) then
tmp = t_1
else if (a <= (-5.5d+43)) then
tmp = t / ((a - z) / (y - z))
else if (a <= (-1.3d+33)) then
tmp = t_1
else if (a <= (-5.2d-50)) then
tmp = t_3
else if (a <= (-3.2d-83)) then
tmp = y * ((t - x) / (a - z))
else if (a <= (-5.4d-129)) then
tmp = t_2
else if (a <= (-1.22d-211)) then
tmp = t_3
else if (a <= 1.3d-127) then
tmp = t_2
else if (a <= 3.9d+77) then
tmp = t * ((y - z) / (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 t_1 = x + (t * ((y - z) / a));
double t_2 = t - ((t - x) / (z / y));
double t_3 = t - (x * ((a - y) / z));
double tmp;
if (a <= -3.4e+125) {
tmp = t_1;
} else if (a <= -5.5e+43) {
tmp = t / ((a - z) / (y - z));
} else if (a <= -1.3e+33) {
tmp = t_1;
} else if (a <= -5.2e-50) {
tmp = t_3;
} else if (a <= -3.2e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= -5.4e-129) {
tmp = t_2;
} else if (a <= -1.22e-211) {
tmp = t_3;
} else if (a <= 1.3e-127) {
tmp = t_2;
} else if (a <= 3.9e+77) {
tmp = t * ((y - z) / (a - z));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (t * ((y - z) / a)) t_2 = t - ((t - x) / (z / y)) t_3 = t - (x * ((a - y) / z)) tmp = 0 if a <= -3.4e+125: tmp = t_1 elif a <= -5.5e+43: tmp = t / ((a - z) / (y - z)) elif a <= -1.3e+33: tmp = t_1 elif a <= -5.2e-50: tmp = t_3 elif a <= -3.2e-83: tmp = y * ((t - x) / (a - z)) elif a <= -5.4e-129: tmp = t_2 elif a <= -1.22e-211: tmp = t_3 elif a <= 1.3e-127: tmp = t_2 elif a <= 3.9e+77: tmp = t * ((y - z) / (a - z)) else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(t * Float64(Float64(y - z) / a))) t_2 = Float64(t - Float64(Float64(t - x) / Float64(z / y))) t_3 = Float64(t - Float64(x * Float64(Float64(a - y) / z))) tmp = 0.0 if (a <= -3.4e+125) tmp = t_1; elseif (a <= -5.5e+43) tmp = Float64(t / Float64(Float64(a - z) / Float64(y - z))); elseif (a <= -1.3e+33) tmp = t_1; elseif (a <= -5.2e-50) tmp = t_3; elseif (a <= -3.2e-83) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= -5.4e-129) tmp = t_2; elseif (a <= -1.22e-211) tmp = t_3; elseif (a <= 1.3e-127) tmp = t_2; elseif (a <= 3.9e+77) tmp = Float64(t * Float64(Float64(y - z) / 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) t_1 = x + (t * ((y - z) / a)); t_2 = t - ((t - x) / (z / y)); t_3 = t - (x * ((a - y) / z)); tmp = 0.0; if (a <= -3.4e+125) tmp = t_1; elseif (a <= -5.5e+43) tmp = t / ((a - z) / (y - z)); elseif (a <= -1.3e+33) tmp = t_1; elseif (a <= -5.2e-50) tmp = t_3; elseif (a <= -3.2e-83) tmp = y * ((t - x) / (a - z)); elseif (a <= -5.4e-129) tmp = t_2; elseif (a <= -1.22e-211) tmp = t_3; elseif (a <= 1.3e-127) tmp = t_2; elseif (a <= 3.9e+77) tmp = t * ((y - z) / (a - z)); else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t - N[(N[(t - x), $MachinePrecision] / N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t - N[(x * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.4e+125], t$95$1, If[LessEqual[a, -5.5e+43], N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.3e+33], t$95$1, If[LessEqual[a, -5.2e-50], t$95$3, If[LessEqual[a, -3.2e-83], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -5.4e-129], t$95$2, If[LessEqual[a, -1.22e-211], t$95$3, If[LessEqual[a, 1.3e-127], t$95$2, If[LessEqual[a, 3.9e+77], N[(t * N[(N[(y - z), $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}
t_1 := x + t \cdot \frac{y - z}{a}\\
t_2 := t - \frac{t - x}{\frac{z}{y}}\\
t_3 := t - x \cdot \frac{a - y}{z}\\
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -5.5 \cdot 10^{+43}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y - z}}\\
\mathbf{elif}\;a \leq -1.3 \cdot 10^{+33}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -5.2 \cdot 10^{-50}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq -3.2 \cdot 10^{-83}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq -5.4 \cdot 10^{-129}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -1.22 \cdot 10^{-211}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 1.3 \cdot 10^{-127}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 3.9 \cdot 10^{+77}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or -5.49999999999999989e43 < a < -1.2999999999999999e33Initial program 70.1%
associate-/l*97.2%
Simplified97.2%
Taylor expanded in a around inf 85.7%
Taylor expanded in t around inf 82.2%
associate-/r/82.2%
Applied egg-rr82.2%
if -3.3999999999999999e125 < a < -5.49999999999999989e43Initial program 70.6%
associate-*l/87.8%
Simplified87.8%
Taylor expanded in x around 0 69.9%
associate-/l*81.6%
Simplified81.6%
if -1.2999999999999999e33 < a < -5.2000000000000003e-50 or -5.39999999999999998e-129 < a < -1.21999999999999996e-211Initial program 61.1%
associate-*l/64.3%
Simplified64.3%
Taylor expanded in z around inf 67.8%
associate--l+67.8%
associate-*r/67.8%
associate-*r/67.8%
div-sub71.2%
distribute-lft-out--71.2%
associate-*r/71.2%
distribute-rgt-out--71.2%
mul-1-neg71.2%
unsub-neg71.2%
associate-/l*77.3%
Simplified77.3%
Taylor expanded in t around 0 71.1%
associate-*r/77.4%
neg-mul-177.4%
distribute-rgt-neg-in77.4%
distribute-neg-frac77.4%
Simplified77.4%
if -5.2000000000000003e-50 < a < -3.2000000000000001e-83Initial program 78.2%
associate-*l/78.0%
Simplified78.0%
Taylor expanded in y around inf 89.8%
div-sub89.8%
Simplified89.8%
if -3.2000000000000001e-83 < a < -5.39999999999999998e-129 or -1.21999999999999996e-211 < a < 1.29999999999999995e-127Initial program 67.0%
associate-*l/73.4%
Simplified73.4%
Taylor expanded in z around inf 92.3%
associate--l+92.3%
associate-*r/92.3%
associate-*r/92.3%
div-sub92.2%
distribute-lft-out--92.2%
associate-*r/92.2%
distribute-rgt-out--92.2%
mul-1-neg92.2%
unsub-neg92.2%
associate-/l*90.7%
Simplified90.7%
Taylor expanded in y around inf 88.3%
if 1.29999999999999995e-127 < a < 3.8999999999999998e77Initial program 62.1%
associate-*l/77.3%
Simplified77.3%
Taylor expanded in x around 0 57.4%
associate-*r/72.3%
Simplified72.3%
if 3.8999999999999998e77 < a Initial program 74.6%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in z around 0 65.2%
associate-/l*75.2%
Simplified75.2%
Final simplification80.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ x (/ z y))) (t_2 (+ t (/ a (/ z t)))))
(if (<= a -3.4e+125)
x
(if (<= a -0.03)
t_2
(if (<= a -1.35e-281)
t_1
(if (<= a 4.15e-280)
t_2
(if (<= a 5.6e-201)
t_1
(if (<= a 4.6e+59)
t_2
(if (<= a 2.7e+116) (* y (/ (- t x) a)) x)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x / (z / y);
double t_2 = t + (a / (z / t));
double tmp;
if (a <= -3.4e+125) {
tmp = x;
} else if (a <= -0.03) {
tmp = t_2;
} else if (a <= -1.35e-281) {
tmp = t_1;
} else if (a <= 4.15e-280) {
tmp = t_2;
} else if (a <= 5.6e-201) {
tmp = t_1;
} else if (a <= 4.6e+59) {
tmp = t_2;
} else if (a <= 2.7e+116) {
tmp = y * ((t - x) / a);
} 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) :: t_2
real(8) :: tmp
t_1 = x / (z / y)
t_2 = t + (a / (z / t))
if (a <= (-3.4d+125)) then
tmp = x
else if (a <= (-0.03d0)) then
tmp = t_2
else if (a <= (-1.35d-281)) then
tmp = t_1
else if (a <= 4.15d-280) then
tmp = t_2
else if (a <= 5.6d-201) then
tmp = t_1
else if (a <= 4.6d+59) then
tmp = t_2
else if (a <= 2.7d+116) then
tmp = y * ((t - x) / a)
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 = x / (z / y);
double t_2 = t + (a / (z / t));
double tmp;
if (a <= -3.4e+125) {
tmp = x;
} else if (a <= -0.03) {
tmp = t_2;
} else if (a <= -1.35e-281) {
tmp = t_1;
} else if (a <= 4.15e-280) {
tmp = t_2;
} else if (a <= 5.6e-201) {
tmp = t_1;
} else if (a <= 4.6e+59) {
tmp = t_2;
} else if (a <= 2.7e+116) {
tmp = y * ((t - x) / a);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x / (z / y) t_2 = t + (a / (z / t)) tmp = 0 if a <= -3.4e+125: tmp = x elif a <= -0.03: tmp = t_2 elif a <= -1.35e-281: tmp = t_1 elif a <= 4.15e-280: tmp = t_2 elif a <= 5.6e-201: tmp = t_1 elif a <= 4.6e+59: tmp = t_2 elif a <= 2.7e+116: tmp = y * ((t - x) / a) else: tmp = x return tmp
function code(x, y, z, t, a) t_1 = Float64(x / Float64(z / y)) t_2 = Float64(t + Float64(a / Float64(z / t))) tmp = 0.0 if (a <= -3.4e+125) tmp = x; elseif (a <= -0.03) tmp = t_2; elseif (a <= -1.35e-281) tmp = t_1; elseif (a <= 4.15e-280) tmp = t_2; elseif (a <= 5.6e-201) tmp = t_1; elseif (a <= 4.6e+59) tmp = t_2; elseif (a <= 2.7e+116) tmp = Float64(y * Float64(Float64(t - x) / a)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x / (z / y); t_2 = t + (a / (z / t)); tmp = 0.0; if (a <= -3.4e+125) tmp = x; elseif (a <= -0.03) tmp = t_2; elseif (a <= -1.35e-281) tmp = t_1; elseif (a <= 4.15e-280) tmp = t_2; elseif (a <= 5.6e-201) tmp = t_1; elseif (a <= 4.6e+59) tmp = t_2; elseif (a <= 2.7e+116) tmp = y * ((t - x) / a); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(a / N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.4e+125], x, If[LessEqual[a, -0.03], t$95$2, If[LessEqual[a, -1.35e-281], t$95$1, If[LessEqual[a, 4.15e-280], t$95$2, If[LessEqual[a, 5.6e-201], t$95$1, If[LessEqual[a, 4.6e+59], t$95$2, If[LessEqual[a, 2.7e+116], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], x]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{\frac{z}{y}}\\
t_2 := t + \frac{a}{\frac{z}{t}}\\
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -0.03:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -1.35 \cdot 10^{-281}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 4.15 \cdot 10^{-280}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-201}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{+59}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{+116}:\\
\;\;\;\;y \cdot \frac{t - x}{a}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 2.7e116 < a Initial program 70.8%
associate-*l/96.3%
Simplified96.3%
Taylor expanded in a around inf 58.6%
if -3.3999999999999999e125 < a < -0.029999999999999999 or -1.34999999999999995e-281 < a < 4.14999999999999985e-280 or 5.5999999999999998e-201 < a < 4.60000000000000016e59Initial program 61.4%
associate-*l/75.6%
Simplified75.6%
Taylor expanded in z around inf 66.2%
associate--l+66.2%
associate-*r/66.2%
associate-*r/66.2%
div-sub67.3%
distribute-lft-out--67.3%
associate-*r/67.3%
distribute-rgt-out--67.4%
mul-1-neg67.4%
unsub-neg67.4%
associate-/l*72.5%
Simplified72.5%
Taylor expanded in y around 0 52.4%
sub-neg52.4%
mul-1-neg52.4%
remove-double-neg52.4%
associate-/l*56.5%
Simplified56.5%
Taylor expanded in t around inf 47.6%
associate-/l*48.7%
Simplified48.7%
if -0.029999999999999999 < a < -1.34999999999999995e-281 or 4.14999999999999985e-280 < a < 5.5999999999999998e-201Initial program 70.7%
associate-*l/72.6%
Simplified72.6%
Taylor expanded in z around inf 79.1%
associate--l+79.1%
associate-*r/79.1%
associate-*r/79.1%
div-sub82.0%
distribute-lft-out--82.0%
associate-*r/82.0%
distribute-rgt-out--82.0%
mul-1-neg82.0%
unsub-neg82.0%
associate-/l*84.7%
Simplified84.7%
Taylor expanded in t around 0 59.3%
associate-/l*62.1%
Simplified62.1%
Taylor expanded in y around inf 53.1%
if 4.60000000000000016e59 < a < 2.7e116Initial program 86.1%
associate-*l/99.5%
Simplified99.5%
Taylor expanded in y around inf 67.7%
Taylor expanded in a around inf 49.0%
Final simplification53.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* t (/ y z))))
(t_2 (+ x (* t (/ y a))))
(t_3 (/ x (/ z y))))
(if (<= a -6e+118)
t_2
(if (<= a -5e-46)
t_1
(if (<= a -4.7e-278)
t_3
(if (<= a 2.7e-278)
t_1
(if (<= a 1.15e-201) t_3 (if (<= a 4.6e+58) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (t * (y / z));
double t_2 = x + (t * (y / a));
double t_3 = x / (z / y);
double tmp;
if (a <= -6e+118) {
tmp = t_2;
} else if (a <= -5e-46) {
tmp = t_1;
} else if (a <= -4.7e-278) {
tmp = t_3;
} else if (a <= 2.7e-278) {
tmp = t_1;
} else if (a <= 1.15e-201) {
tmp = t_3;
} else if (a <= 4.6e+58) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = t - (t * (y / z))
t_2 = x + (t * (y / a))
t_3 = x / (z / y)
if (a <= (-6d+118)) then
tmp = t_2
else if (a <= (-5d-46)) then
tmp = t_1
else if (a <= (-4.7d-278)) then
tmp = t_3
else if (a <= 2.7d-278) then
tmp = t_1
else if (a <= 1.15d-201) then
tmp = t_3
else if (a <= 4.6d+58) 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 - (t * (y / z));
double t_2 = x + (t * (y / a));
double t_3 = x / (z / y);
double tmp;
if (a <= -6e+118) {
tmp = t_2;
} else if (a <= -5e-46) {
tmp = t_1;
} else if (a <= -4.7e-278) {
tmp = t_3;
} else if (a <= 2.7e-278) {
tmp = t_1;
} else if (a <= 1.15e-201) {
tmp = t_3;
} else if (a <= 4.6e+58) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (t * (y / z)) t_2 = x + (t * (y / a)) t_3 = x / (z / y) tmp = 0 if a <= -6e+118: tmp = t_2 elif a <= -5e-46: tmp = t_1 elif a <= -4.7e-278: tmp = t_3 elif a <= 2.7e-278: tmp = t_1 elif a <= 1.15e-201: tmp = t_3 elif a <= 4.6e+58: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(t * Float64(y / z))) t_2 = Float64(x + Float64(t * Float64(y / a))) t_3 = Float64(x / Float64(z / y)) tmp = 0.0 if (a <= -6e+118) tmp = t_2; elseif (a <= -5e-46) tmp = t_1; elseif (a <= -4.7e-278) tmp = t_3; elseif (a <= 2.7e-278) tmp = t_1; elseif (a <= 1.15e-201) tmp = t_3; elseif (a <= 4.6e+58) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (t * (y / z)); t_2 = x + (t * (y / a)); t_3 = x / (z / y); tmp = 0.0; if (a <= -6e+118) tmp = t_2; elseif (a <= -5e-46) tmp = t_1; elseif (a <= -4.7e-278) tmp = t_3; elseif (a <= 2.7e-278) tmp = t_1; elseif (a <= 1.15e-201) tmp = t_3; elseif (a <= 4.6e+58) 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[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6e+118], t$95$2, If[LessEqual[a, -5e-46], t$95$1, If[LessEqual[a, -4.7e-278], t$95$3, If[LessEqual[a, 2.7e-278], t$95$1, If[LessEqual[a, 1.15e-201], t$95$3, If[LessEqual[a, 4.6e+58], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - t \cdot \frac{y}{z}\\
t_2 := x + t \cdot \frac{y}{a}\\
t_3 := \frac{x}{\frac{z}{y}}\\
\mathbf{if}\;a \leq -6 \cdot 10^{+118}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -5 \cdot 10^{-46}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -4.7 \cdot 10^{-278}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-278}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.15 \cdot 10^{-201}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 4.6 \cdot 10^{+58}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -6e118 or 4.60000000000000005e58 < a Initial program 72.4%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in z around 0 64.4%
associate-/l*76.1%
Simplified76.1%
Taylor expanded in t around inf 60.5%
associate-*r/69.5%
Simplified69.5%
if -6e118 < a < -4.99999999999999992e-46 or -4.6999999999999997e-278 < a < 2.7000000000000001e-278 or 1.14999999999999993e-201 < a < 4.60000000000000005e58Initial program 60.2%
associate-*l/73.4%
Simplified73.4%
Taylor expanded in z around inf 66.7%
associate--l+66.7%
associate-*r/66.7%
associate-*r/66.7%
div-sub68.7%
distribute-lft-out--68.7%
associate-*r/68.7%
distribute-rgt-out--68.8%
mul-1-neg68.8%
unsub-neg68.8%
associate-/l*74.4%
Simplified74.4%
Taylor expanded in y around inf 67.1%
Taylor expanded in t around inf 56.7%
associate-*r/59.5%
Simplified59.5%
if -4.99999999999999992e-46 < a < -4.6999999999999997e-278 or 2.7000000000000001e-278 < a < 1.14999999999999993e-201Initial program 74.7%
associate-*l/75.4%
Simplified75.4%
Taylor expanded in z around inf 81.1%
associate--l+81.1%
associate-*r/81.1%
associate-*r/81.1%
div-sub82.7%
distribute-lft-out--82.7%
associate-*r/82.7%
distribute-rgt-out--82.7%
mul-1-neg82.7%
unsub-neg82.7%
associate-/l*84.3%
Simplified84.3%
Taylor expanded in t around 0 62.0%
associate-/l*63.5%
Simplified63.5%
Taylor expanded in y around inf 56.4%
Final simplification62.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* t (/ y z))))
(t_2 (+ x (* t (/ y a))))
(t_3 (/ x (/ z (- y a)))))
(if (<= a -6e+118)
t_2
(if (<= a -5.5e-20)
t_1
(if (<= a -4.6e-278)
t_3
(if (<= a 2.1e-275)
t_1
(if (<= a 1.32e-201) t_3 (if (<= a 5.6e+57) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (t * (y / z));
double t_2 = x + (t * (y / a));
double t_3 = x / (z / (y - a));
double tmp;
if (a <= -6e+118) {
tmp = t_2;
} else if (a <= -5.5e-20) {
tmp = t_1;
} else if (a <= -4.6e-278) {
tmp = t_3;
} else if (a <= 2.1e-275) {
tmp = t_1;
} else if (a <= 1.32e-201) {
tmp = t_3;
} else if (a <= 5.6e+57) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = t - (t * (y / z))
t_2 = x + (t * (y / a))
t_3 = x / (z / (y - a))
if (a <= (-6d+118)) then
tmp = t_2
else if (a <= (-5.5d-20)) then
tmp = t_1
else if (a <= (-4.6d-278)) then
tmp = t_3
else if (a <= 2.1d-275) then
tmp = t_1
else if (a <= 1.32d-201) then
tmp = t_3
else if (a <= 5.6d+57) 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 - (t * (y / z));
double t_2 = x + (t * (y / a));
double t_3 = x / (z / (y - a));
double tmp;
if (a <= -6e+118) {
tmp = t_2;
} else if (a <= -5.5e-20) {
tmp = t_1;
} else if (a <= -4.6e-278) {
tmp = t_3;
} else if (a <= 2.1e-275) {
tmp = t_1;
} else if (a <= 1.32e-201) {
tmp = t_3;
} else if (a <= 5.6e+57) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (t * (y / z)) t_2 = x + (t * (y / a)) t_3 = x / (z / (y - a)) tmp = 0 if a <= -6e+118: tmp = t_2 elif a <= -5.5e-20: tmp = t_1 elif a <= -4.6e-278: tmp = t_3 elif a <= 2.1e-275: tmp = t_1 elif a <= 1.32e-201: tmp = t_3 elif a <= 5.6e+57: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(t * Float64(y / z))) t_2 = Float64(x + Float64(t * Float64(y / a))) t_3 = Float64(x / Float64(z / Float64(y - a))) tmp = 0.0 if (a <= -6e+118) tmp = t_2; elseif (a <= -5.5e-20) tmp = t_1; elseif (a <= -4.6e-278) tmp = t_3; elseif (a <= 2.1e-275) tmp = t_1; elseif (a <= 1.32e-201) tmp = t_3; elseif (a <= 5.6e+57) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (t * (y / z)); t_2 = x + (t * (y / a)); t_3 = x / (z / (y - a)); tmp = 0.0; if (a <= -6e+118) tmp = t_2; elseif (a <= -5.5e-20) tmp = t_1; elseif (a <= -4.6e-278) tmp = t_3; elseif (a <= 2.1e-275) tmp = t_1; elseif (a <= 1.32e-201) tmp = t_3; elseif (a <= 5.6e+57) 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[(t * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6e+118], t$95$2, If[LessEqual[a, -5.5e-20], t$95$1, If[LessEqual[a, -4.6e-278], t$95$3, If[LessEqual[a, 2.1e-275], t$95$1, If[LessEqual[a, 1.32e-201], t$95$3, If[LessEqual[a, 5.6e+57], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - t \cdot \frac{y}{z}\\
t_2 := x + t \cdot \frac{y}{a}\\
t_3 := \frac{x}{\frac{z}{y - a}}\\
\mathbf{if}\;a \leq -6 \cdot 10^{+118}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -5.5 \cdot 10^{-20}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -4.6 \cdot 10^{-278}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{-275}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.32 \cdot 10^{-201}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{+57}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -6e118 or 5.59999999999999999e57 < a Initial program 72.4%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in z around 0 64.4%
associate-/l*76.1%
Simplified76.1%
Taylor expanded in t around inf 60.5%
associate-*r/69.5%
Simplified69.5%
if -6e118 < a < -5.4999999999999996e-20 or -4.60000000000000006e-278 < a < 2.09999999999999988e-275 or 1.31999999999999996e-201 < a < 5.59999999999999999e57Initial program 61.5%
associate-*l/74.4%
Simplified74.4%
Taylor expanded in z around inf 67.3%
associate--l+67.3%
associate-*r/67.3%
associate-*r/67.3%
div-sub69.4%
distribute-lft-out--69.4%
associate-*r/69.4%
distribute-rgt-out--69.4%
mul-1-neg69.4%
unsub-neg69.4%
associate-/l*74.4%
Simplified74.4%
Taylor expanded in y around inf 68.8%
Taylor expanded in t around inf 58.9%
associate-*r/60.9%
Simplified60.9%
if -5.4999999999999996e-20 < a < -4.60000000000000006e-278 or 2.09999999999999988e-275 < a < 1.31999999999999996e-201Initial program 71.9%
associate-*l/73.9%
Simplified73.9%
Taylor expanded in z around inf 79.4%
associate--l+79.4%
associate-*r/79.4%
associate-*r/79.4%
div-sub80.9%
distribute-lft-out--80.9%
associate-*r/80.9%
distribute-rgt-out--80.9%
mul-1-neg80.9%
unsub-neg80.9%
associate-/l*83.7%
Simplified83.7%
Taylor expanded in t around 0 61.3%
associate-/l*62.7%
Simplified62.7%
Final simplification64.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (+ x (* t (/ y a)))))
(if (<= a -3.4e+125)
t_2
(if (<= a -5.6e-46)
t_1
(if (<= a -2.95e-83)
(* y (/ (- t x) (- a z)))
(if (<= a 1.3e-127)
(+ t (* x (/ y z)))
(if (<= a 2.7e+69) t_1 t_2)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t * (y / a));
double tmp;
if (a <= -3.4e+125) {
tmp = t_2;
} else if (a <= -5.6e-46) {
tmp = t_1;
} else if (a <= -2.95e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 1.3e-127) {
tmp = t + (x * (y / z));
} else if (a <= 2.7e+69) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = x + (t * (y / a))
if (a <= (-3.4d+125)) then
tmp = t_2
else if (a <= (-5.6d-46)) then
tmp = t_1
else if (a <= (-2.95d-83)) then
tmp = y * ((t - x) / (a - z))
else if (a <= 1.3d-127) then
tmp = t + (x * (y / z))
else if (a <= 2.7d+69) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t * (y / a));
double tmp;
if (a <= -3.4e+125) {
tmp = t_2;
} else if (a <= -5.6e-46) {
tmp = t_1;
} else if (a <= -2.95e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 1.3e-127) {
tmp = t + (x * (y / z));
} else if (a <= 2.7e+69) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + (t * (y / a)) tmp = 0 if a <= -3.4e+125: tmp = t_2 elif a <= -5.6e-46: tmp = t_1 elif a <= -2.95e-83: tmp = y * ((t - x) / (a - z)) elif a <= 1.3e-127: tmp = t + (x * (y / z)) elif a <= 2.7e+69: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(x + Float64(t * Float64(y / a))) tmp = 0.0 if (a <= -3.4e+125) tmp = t_2; elseif (a <= -5.6e-46) tmp = t_1; elseif (a <= -2.95e-83) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= 1.3e-127) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 2.7e+69) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = x + (t * (y / a)); tmp = 0.0; if (a <= -3.4e+125) tmp = t_2; elseif (a <= -5.6e-46) tmp = t_1; elseif (a <= -2.95e-83) tmp = y * ((t - x) / (a - z)); elseif (a <= 1.3e-127) tmp = t + (x * (y / z)); elseif (a <= 2.7e+69) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.4e+125], t$95$2, If[LessEqual[a, -5.6e-46], t$95$1, If[LessEqual[a, -2.95e-83], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.3e-127], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.7e+69], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + t \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -5.6 \cdot 10^{-46}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -2.95 \cdot 10^{-83}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 1.3 \cdot 10^{-127}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{+69}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 2.6999999999999998e69 < a Initial program 71.9%
associate-*l/96.7%
Simplified96.7%
Taylor expanded in z around 0 64.6%
associate-/l*75.9%
Simplified75.9%
Taylor expanded in t around inf 60.5%
associate-*r/68.9%
Simplified68.9%
if -3.3999999999999999e125 < a < -5.5999999999999997e-46 or 1.29999999999999995e-127 < a < 2.6999999999999998e69Initial program 63.0%
associate-*l/76.6%
Simplified76.6%
Taylor expanded in x around 0 57.6%
associate-*r/71.1%
Simplified71.1%
if -5.5999999999999997e-46 < a < -2.9499999999999998e-83Initial program 64.3%
associate-*l/64.3%
Simplified64.3%
Taylor expanded in y around inf 82.9%
div-sub82.9%
Simplified82.9%
if -2.9499999999999998e-83 < a < 1.29999999999999995e-127Initial program 69.6%
associate-*l/74.8%
Simplified74.8%
Taylor expanded in z around inf 88.8%
associate--l+88.8%
associate-*r/88.8%
associate-*r/88.8%
div-sub88.8%
distribute-lft-out--88.8%
associate-*r/88.8%
distribute-rgt-out--88.8%
mul-1-neg88.8%
unsub-neg88.8%
associate-/l*87.6%
Simplified87.6%
Taylor expanded in y around inf 83.1%
Taylor expanded in t around 0 75.7%
associate-*r/74.5%
neg-mul-174.5%
distribute-rgt-neg-in74.5%
distribute-neg-frac74.5%
Simplified74.5%
Final simplification71.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (+ x (* t (/ (- y z) a)))))
(if (<= a -3.4e+125)
t_2
(if (<= a -5e-46)
t_1
(if (<= a -4.8e-83)
(* y (/ (- t x) (- a z)))
(if (<= a 1.35e-127)
(+ t (* x (/ y z)))
(if (<= a 4.7e+64) t_1 t_2)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t * ((y - z) / a));
double tmp;
if (a <= -3.4e+125) {
tmp = t_2;
} else if (a <= -5e-46) {
tmp = t_1;
} else if (a <= -4.8e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 1.35e-127) {
tmp = t + (x * (y / z));
} else if (a <= 4.7e+64) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = x + (t * ((y - z) / a))
if (a <= (-3.4d+125)) then
tmp = t_2
else if (a <= (-5d-46)) then
tmp = t_1
else if (a <= (-4.8d-83)) then
tmp = y * ((t - x) / (a - z))
else if (a <= 1.35d-127) then
tmp = t + (x * (y / z))
else if (a <= 4.7d+64) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t * ((y - z) / a));
double tmp;
if (a <= -3.4e+125) {
tmp = t_2;
} else if (a <= -5e-46) {
tmp = t_1;
} else if (a <= -4.8e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 1.35e-127) {
tmp = t + (x * (y / z));
} else if (a <= 4.7e+64) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + (t * ((y - z) / a)) tmp = 0 if a <= -3.4e+125: tmp = t_2 elif a <= -5e-46: tmp = t_1 elif a <= -4.8e-83: tmp = y * ((t - x) / (a - z)) elif a <= 1.35e-127: tmp = t + (x * (y / z)) elif a <= 4.7e+64: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(x + Float64(t * Float64(Float64(y - z) / a))) tmp = 0.0 if (a <= -3.4e+125) tmp = t_2; elseif (a <= -5e-46) tmp = t_1; elseif (a <= -4.8e-83) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= 1.35e-127) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 4.7e+64) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = x + (t * ((y - z) / a)); tmp = 0.0; if (a <= -3.4e+125) tmp = t_2; elseif (a <= -5e-46) tmp = t_1; elseif (a <= -4.8e-83) tmp = y * ((t - x) / (a - z)); elseif (a <= 1.35e-127) tmp = t + (x * (y / z)); elseif (a <= 4.7e+64) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.4e+125], t$95$2, If[LessEqual[a, -5e-46], t$95$1, If[LessEqual[a, -4.8e-83], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e-127], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.7e+64], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + t \cdot \frac{y - z}{a}\\
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -5 \cdot 10^{-46}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -4.8 \cdot 10^{-83}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{-127}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 4.7 \cdot 10^{+64}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 4.70000000000000029e64 < a Initial program 71.9%
associate-/l*95.5%
Simplified95.5%
Taylor expanded in a around inf 83.8%
Taylor expanded in t around inf 76.7%
associate-/r/76.7%
Applied egg-rr76.7%
if -3.3999999999999999e125 < a < -4.99999999999999992e-46 or 1.35e-127 < a < 4.70000000000000029e64Initial program 63.0%
associate-*l/76.6%
Simplified76.6%
Taylor expanded in x around 0 57.6%
associate-*r/71.1%
Simplified71.1%
if -4.99999999999999992e-46 < a < -4.8000000000000002e-83Initial program 64.3%
associate-*l/64.3%
Simplified64.3%
Taylor expanded in y around inf 82.9%
div-sub82.9%
Simplified82.9%
if -4.8000000000000002e-83 < a < 1.35e-127Initial program 69.6%
associate-*l/74.8%
Simplified74.8%
Taylor expanded in z around inf 88.8%
associate--l+88.8%
associate-*r/88.8%
associate-*r/88.8%
div-sub88.8%
distribute-lft-out--88.8%
associate-*r/88.8%
distribute-rgt-out--88.8%
mul-1-neg88.8%
unsub-neg88.8%
associate-/l*87.6%
Simplified87.6%
Taylor expanded in y around inf 83.1%
Taylor expanded in t around 0 75.7%
associate-*r/74.5%
neg-mul-174.5%
distribute-rgt-neg-in74.5%
distribute-neg-frac74.5%
Simplified74.5%
Final simplification74.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))))
(if (<= a -3.4e+125)
(+ x (* t (/ (- y z) a)))
(if (<= a -1.55e-46)
t_1
(if (<= a -3.25e-83)
(* y (/ (- t x) (- a z)))
(if (<= a 1.28e-127)
(+ t (* x (/ y z)))
(if (<= a 4.5e+75) t_1 (+ x (/ y (/ a (- t x)))))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -3.4e+125) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -1.55e-46) {
tmp = t_1;
} else if (a <= -3.25e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 1.28e-127) {
tmp = t + (x * (y / z));
} else if (a <= 4.5e+75) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
if (a <= (-3.4d+125)) then
tmp = x + (t * ((y - z) / a))
else if (a <= (-1.55d-46)) then
tmp = t_1
else if (a <= (-3.25d-83)) then
tmp = y * ((t - x) / (a - z))
else if (a <= 1.28d-127) then
tmp = t + (x * (y / z))
else if (a <= 4.5d+75) then
tmp = t_1
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 t_1 = t * ((y - z) / (a - z));
double tmp;
if (a <= -3.4e+125) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -1.55e-46) {
tmp = t_1;
} else if (a <= -3.25e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 1.28e-127) {
tmp = t + (x * (y / z));
} else if (a <= 4.5e+75) {
tmp = t_1;
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) tmp = 0 if a <= -3.4e+125: tmp = x + (t * ((y - z) / a)) elif a <= -1.55e-46: tmp = t_1 elif a <= -3.25e-83: tmp = y * ((t - x) / (a - z)) elif a <= 1.28e-127: tmp = t + (x * (y / z)) elif a <= 4.5e+75: tmp = t_1 else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) tmp = 0.0 if (a <= -3.4e+125) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / a))); elseif (a <= -1.55e-46) tmp = t_1; elseif (a <= -3.25e-83) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= 1.28e-127) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 4.5e+75) tmp = t_1; else tmp = Float64(x + Float64(y / Float64(a / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); tmp = 0.0; if (a <= -3.4e+125) tmp = x + (t * ((y - z) / a)); elseif (a <= -1.55e-46) tmp = t_1; elseif (a <= -3.25e-83) tmp = y * ((t - x) / (a - z)); elseif (a <= 1.28e-127) tmp = t + (x * (y / z)); elseif (a <= 4.5e+75) tmp = t_1; else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.4e+125], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.55e-46], t$95$1, If[LessEqual[a, -3.25e-83], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.28e-127], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.5e+75], t$95$1, N[(x + N[(y / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a}\\
\mathbf{elif}\;a \leq -1.55 \cdot 10^{-46}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -3.25 \cdot 10^{-83}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 1.28 \cdot 10^{-127}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 4.5 \cdot 10^{+75}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if a < -3.3999999999999999e125Initial program 67.5%
associate-/l*97.0%
Simplified97.0%
Taylor expanded in a around inf 85.9%
Taylor expanded in t around inf 82.5%
associate-/r/82.6%
Applied egg-rr82.6%
if -3.3999999999999999e125 < a < -1.55e-46 or 1.2799999999999999e-127 < a < 4.5000000000000004e75Initial program 63.0%
associate-*l/76.6%
Simplified76.6%
Taylor expanded in x around 0 57.6%
associate-*r/71.1%
Simplified71.1%
if -1.55e-46 < a < -3.25e-83Initial program 64.3%
associate-*l/64.3%
Simplified64.3%
Taylor expanded in y around inf 82.9%
div-sub82.9%
Simplified82.9%
if -3.25e-83 < a < 1.2799999999999999e-127Initial program 69.6%
associate-*l/74.8%
Simplified74.8%
Taylor expanded in z around inf 88.8%
associate--l+88.8%
associate-*r/88.8%
associate-*r/88.8%
div-sub88.8%
distribute-lft-out--88.8%
associate-*r/88.8%
distribute-rgt-out--88.8%
mul-1-neg88.8%
unsub-neg88.8%
associate-/l*87.6%
Simplified87.6%
Taylor expanded in y around inf 83.1%
Taylor expanded in t around 0 75.7%
associate-*r/74.5%
neg-mul-174.5%
distribute-rgt-neg-in74.5%
distribute-neg-frac74.5%
Simplified74.5%
if 4.5000000000000004e75 < a Initial program 74.6%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in z around 0 65.2%
associate-/l*75.2%
Simplified75.2%
Final simplification75.1%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.4e+125)
x
(if (<= a -1.1e-46)
t
(if (<= a 8e-201)
(/ x (/ z y))
(if (<= a 4.15e+58) t (if (<= a 2.3e+116) (* y (/ (- t x) a)) x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.4e+125) {
tmp = x;
} else if (a <= -1.1e-46) {
tmp = t;
} else if (a <= 8e-201) {
tmp = x / (z / y);
} else if (a <= 4.15e+58) {
tmp = t;
} else if (a <= 2.3e+116) {
tmp = y * ((t - x) / a);
} 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 <= (-3.4d+125)) then
tmp = x
else if (a <= (-1.1d-46)) then
tmp = t
else if (a <= 8d-201) then
tmp = x / (z / y)
else if (a <= 4.15d+58) then
tmp = t
else if (a <= 2.3d+116) then
tmp = y * ((t - x) / a)
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 <= -3.4e+125) {
tmp = x;
} else if (a <= -1.1e-46) {
tmp = t;
} else if (a <= 8e-201) {
tmp = x / (z / y);
} else if (a <= 4.15e+58) {
tmp = t;
} else if (a <= 2.3e+116) {
tmp = y * ((t - x) / a);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.4e+125: tmp = x elif a <= -1.1e-46: tmp = t elif a <= 8e-201: tmp = x / (z / y) elif a <= 4.15e+58: tmp = t elif a <= 2.3e+116: tmp = y * ((t - x) / a) else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.4e+125) tmp = x; elseif (a <= -1.1e-46) tmp = t; elseif (a <= 8e-201) tmp = Float64(x / Float64(z / y)); elseif (a <= 4.15e+58) tmp = t; elseif (a <= 2.3e+116) tmp = Float64(y * Float64(Float64(t - x) / a)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.4e+125) tmp = x; elseif (a <= -1.1e-46) tmp = t; elseif (a <= 8e-201) tmp = x / (z / y); elseif (a <= 4.15e+58) tmp = t; elseif (a <= 2.3e+116) tmp = y * ((t - x) / a); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.4e+125], x, If[LessEqual[a, -1.1e-46], t, If[LessEqual[a, 8e-201], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.15e+58], t, If[LessEqual[a, 2.3e+116], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -1.1 \cdot 10^{-46}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 8 \cdot 10^{-201}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 4.15 \cdot 10^{+58}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 2.3 \cdot 10^{+116}:\\
\;\;\;\;y \cdot \frac{t - x}{a}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 2.29999999999999995e116 < a Initial program 70.8%
associate-*l/96.3%
Simplified96.3%
Taylor expanded in a around inf 58.6%
if -3.3999999999999999e125 < a < -1.1e-46 or 7.99999999999999957e-201 < a < 4.1499999999999998e58Initial program 62.0%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in z around inf 43.0%
if -1.1e-46 < a < 7.99999999999999957e-201Initial program 69.5%
associate-*l/72.6%
Simplified72.6%
Taylor expanded in z around inf 84.0%
associate--l+84.0%
associate-*r/84.0%
associate-*r/84.0%
div-sub85.3%
distribute-lft-out--85.3%
associate-*r/85.3%
distribute-rgt-out--85.3%
mul-1-neg85.3%
unsub-neg85.3%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in t around 0 55.7%
associate-/l*57.0%
Simplified57.0%
Taylor expanded in y around inf 51.0%
if 4.1499999999999998e58 < a < 2.29999999999999995e116Initial program 86.1%
associate-*l/99.5%
Simplified99.5%
Taylor expanded in y around inf 67.7%
Taylor expanded in a around inf 49.0%
Final simplification50.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ (- y z) (- a z)))) (t_2 (+ x (* t (/ y a)))))
(if (<= a -3.4e+125)
t_2
(if (<= a -1.25e-44)
t_1
(if (<= a 1.35e-127)
(+ t (* x (/ y z)))
(if (<= a 8.5e+68) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t * (y / a));
double tmp;
if (a <= -3.4e+125) {
tmp = t_2;
} else if (a <= -1.25e-44) {
tmp = t_1;
} else if (a <= 1.35e-127) {
tmp = t + (x * (y / z));
} else if (a <= 8.5e+68) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((y - z) / (a - z))
t_2 = x + (t * (y / a))
if (a <= (-3.4d+125)) then
tmp = t_2
else if (a <= (-1.25d-44)) then
tmp = t_1
else if (a <= 1.35d-127) then
tmp = t + (x * (y / z))
else if (a <= 8.5d+68) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * ((y - z) / (a - z));
double t_2 = x + (t * (y / a));
double tmp;
if (a <= -3.4e+125) {
tmp = t_2;
} else if (a <= -1.25e-44) {
tmp = t_1;
} else if (a <= 1.35e-127) {
tmp = t + (x * (y / z));
} else if (a <= 8.5e+68) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * ((y - z) / (a - z)) t_2 = x + (t * (y / a)) tmp = 0 if a <= -3.4e+125: tmp = t_2 elif a <= -1.25e-44: tmp = t_1 elif a <= 1.35e-127: tmp = t + (x * (y / z)) elif a <= 8.5e+68: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z))) t_2 = Float64(x + Float64(t * Float64(y / a))) tmp = 0.0 if (a <= -3.4e+125) tmp = t_2; elseif (a <= -1.25e-44) tmp = t_1; elseif (a <= 1.35e-127) tmp = Float64(t + Float64(x * Float64(y / z))); elseif (a <= 8.5e+68) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * ((y - z) / (a - z)); t_2 = x + (t * (y / a)); tmp = 0.0; if (a <= -3.4e+125) tmp = t_2; elseif (a <= -1.25e-44) tmp = t_1; elseif (a <= 1.35e-127) tmp = t + (x * (y / z)); elseif (a <= 8.5e+68) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.4e+125], t$95$2, If[LessEqual[a, -1.25e-44], t$95$1, If[LessEqual[a, 1.35e-127], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 8.5e+68], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{y - z}{a - z}\\
t_2 := x + t \cdot \frac{y}{a}\\
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -1.25 \cdot 10^{-44}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 1.35 \cdot 10^{-127}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\mathbf{elif}\;a \leq 8.5 \cdot 10^{+68}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 8.49999999999999966e68 < a Initial program 71.9%
associate-*l/96.7%
Simplified96.7%
Taylor expanded in z around 0 64.6%
associate-/l*75.9%
Simplified75.9%
Taylor expanded in t around inf 60.5%
associate-*r/68.9%
Simplified68.9%
if -3.3999999999999999e125 < a < -1.2500000000000001e-44 or 1.35e-127 < a < 8.49999999999999966e68Initial program 63.7%
associate-*l/76.3%
Simplified76.3%
Taylor expanded in x around 0 58.2%
associate-*r/70.7%
Simplified70.7%
if -1.2500000000000001e-44 < a < 1.35e-127Initial program 68.3%
associate-*l/73.8%
Simplified73.8%
Taylor expanded in z around inf 81.8%
associate--l+81.8%
associate-*r/81.8%
associate-*r/81.8%
div-sub82.9%
distribute-lft-out--82.9%
associate-*r/82.9%
distribute-rgt-out--82.9%
mul-1-neg82.9%
unsub-neg82.9%
associate-/l*83.9%
Simplified83.9%
Taylor expanded in y around inf 78.6%
Taylor expanded in t around 0 71.1%
associate-*r/71.1%
neg-mul-171.1%
distribute-rgt-neg-in71.1%
distribute-neg-frac71.1%
Simplified71.1%
Final simplification70.2%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.5e+125)
(+ x (* t (/ (- y z) a)))
(if (<= a -1.2e-45)
(* t (/ (- y z) (- a z)))
(if (<= a -4.5e-84)
(* y (/ (- t x) (- a z)))
(if (<= a 2.8e+57)
(- t (/ (- t x) (/ z y)))
(+ x (/ y (/ a (- t x)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.5e+125) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -1.2e-45) {
tmp = t * ((y - z) / (a - z));
} else if (a <= -4.5e-84) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 2.8e+57) {
tmp = t - ((t - x) / (z / y));
} 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 <= (-3.5d+125)) then
tmp = x + (t * ((y - z) / a))
else if (a <= (-1.2d-45)) then
tmp = t * ((y - z) / (a - z))
else if (a <= (-4.5d-84)) then
tmp = y * ((t - x) / (a - z))
else if (a <= 2.8d+57) then
tmp = t - ((t - x) / (z / y))
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 <= -3.5e+125) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -1.2e-45) {
tmp = t * ((y - z) / (a - z));
} else if (a <= -4.5e-84) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 2.8e+57) {
tmp = t - ((t - x) / (z / y));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.5e+125: tmp = x + (t * ((y - z) / a)) elif a <= -1.2e-45: tmp = t * ((y - z) / (a - z)) elif a <= -4.5e-84: tmp = y * ((t - x) / (a - z)) elif a <= 2.8e+57: tmp = t - ((t - x) / (z / y)) else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.5e+125) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / a))); elseif (a <= -1.2e-45) tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z))); elseif (a <= -4.5e-84) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= 2.8e+57) tmp = Float64(t - Float64(Float64(t - x) / Float64(z / y))); 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 <= -3.5e+125) tmp = x + (t * ((y - z) / a)); elseif (a <= -1.2e-45) tmp = t * ((y - z) / (a - z)); elseif (a <= -4.5e-84) tmp = y * ((t - x) / (a - z)); elseif (a <= 2.8e+57) tmp = t - ((t - x) / (z / y)); else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.5e+125], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.2e-45], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -4.5e-84], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e+57], N[(t - N[(N[(t - x), $MachinePrecision] / N[(z / y), $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 -3.5 \cdot 10^{+125}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a}\\
\mathbf{elif}\;a \leq -1.2 \cdot 10^{-45}:\\
\;\;\;\;t \cdot \frac{y - z}{a - z}\\
\mathbf{elif}\;a \leq -4.5 \cdot 10^{-84}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{+57}:\\
\;\;\;\;t - \frac{t - x}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if a < -3.50000000000000011e125Initial program 67.5%
associate-/l*97.0%
Simplified97.0%
Taylor expanded in a around inf 85.9%
Taylor expanded in t around inf 82.5%
associate-/r/82.6%
Applied egg-rr82.6%
if -3.50000000000000011e125 < a < -1.19999999999999995e-45Initial program 64.3%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in x around 0 57.9%
associate-*r/69.5%
Simplified69.5%
if -1.19999999999999995e-45 < a < -4.50000000000000016e-84Initial program 64.3%
associate-*l/64.3%
Simplified64.3%
Taylor expanded in y around inf 82.9%
div-sub82.9%
Simplified82.9%
if -4.50000000000000016e-84 < a < 2.8e57Initial program 65.8%
associate-*l/74.9%
Simplified74.9%
Taylor expanded in z around inf 81.2%
associate--l+81.2%
associate-*r/81.2%
associate-*r/81.2%
div-sub81.2%
distribute-lft-out--81.2%
associate-*r/81.2%
distribute-rgt-out--81.2%
mul-1-neg81.2%
unsub-neg81.2%
associate-/l*82.8%
Simplified82.8%
Taylor expanded in y around inf 77.0%
if 2.8e57 < a Initial program 76.3%
associate-*l/96.6%
Simplified96.6%
Taylor expanded in z around 0 65.8%
associate-/l*75.2%
Simplified75.2%
Final simplification76.6%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.4e+125)
(+ x (* t (/ (- y z) a)))
(if (<= a -7.6e-47)
(/ t (/ (- a z) (- y z)))
(if (<= a -4.8e-83)
(* y (/ (- t x) (- a z)))
(if (<= a 2.8e+57)
(- t (/ (- t x) (/ z y)))
(+ x (/ y (/ a (- t x)))))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.4e+125) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -7.6e-47) {
tmp = t / ((a - z) / (y - z));
} else if (a <= -4.8e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 2.8e+57) {
tmp = t - ((t - x) / (z / y));
} 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 <= (-3.4d+125)) then
tmp = x + (t * ((y - z) / a))
else if (a <= (-7.6d-47)) then
tmp = t / ((a - z) / (y - z))
else if (a <= (-4.8d-83)) then
tmp = y * ((t - x) / (a - z))
else if (a <= 2.8d+57) then
tmp = t - ((t - x) / (z / y))
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 <= -3.4e+125) {
tmp = x + (t * ((y - z) / a));
} else if (a <= -7.6e-47) {
tmp = t / ((a - z) / (y - z));
} else if (a <= -4.8e-83) {
tmp = y * ((t - x) / (a - z));
} else if (a <= 2.8e+57) {
tmp = t - ((t - x) / (z / y));
} else {
tmp = x + (y / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.4e+125: tmp = x + (t * ((y - z) / a)) elif a <= -7.6e-47: tmp = t / ((a - z) / (y - z)) elif a <= -4.8e-83: tmp = y * ((t - x) / (a - z)) elif a <= 2.8e+57: tmp = t - ((t - x) / (z / y)) else: tmp = x + (y / (a / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.4e+125) tmp = Float64(x + Float64(t * Float64(Float64(y - z) / a))); elseif (a <= -7.6e-47) tmp = Float64(t / Float64(Float64(a - z) / Float64(y - z))); elseif (a <= -4.8e-83) tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z))); elseif (a <= 2.8e+57) tmp = Float64(t - Float64(Float64(t - x) / Float64(z / y))); 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 <= -3.4e+125) tmp = x + (t * ((y - z) / a)); elseif (a <= -7.6e-47) tmp = t / ((a - z) / (y - z)); elseif (a <= -4.8e-83) tmp = y * ((t - x) / (a - z)); elseif (a <= 2.8e+57) tmp = t - ((t - x) / (z / y)); else tmp = x + (y / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.4e+125], N[(x + N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -7.6e-47], N[(t / N[(N[(a - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -4.8e-83], N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e+57], N[(t - N[(N[(t - x), $MachinePrecision] / N[(z / y), $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 -3.4 \cdot 10^{+125}:\\
\;\;\;\;x + t \cdot \frac{y - z}{a}\\
\mathbf{elif}\;a \leq -7.6 \cdot 10^{-47}:\\
\;\;\;\;\frac{t}{\frac{a - z}{y - z}}\\
\mathbf{elif}\;a \leq -4.8 \cdot 10^{-83}:\\
\;\;\;\;y \cdot \frac{t - x}{a - z}\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{+57}:\\
\;\;\;\;t - \frac{t - x}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if a < -3.3999999999999999e125Initial program 67.5%
associate-/l*97.0%
Simplified97.0%
Taylor expanded in a around inf 85.9%
Taylor expanded in t around inf 82.5%
associate-/r/82.6%
Applied egg-rr82.6%
if -3.3999999999999999e125 < a < -7.60000000000000029e-47Initial program 64.3%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in x around 0 57.9%
associate-/l*69.5%
Simplified69.5%
if -7.60000000000000029e-47 < a < -4.8000000000000002e-83Initial program 64.3%
associate-*l/64.3%
Simplified64.3%
Taylor expanded in y around inf 82.9%
div-sub82.9%
Simplified82.9%
if -4.8000000000000002e-83 < a < 2.8e57Initial program 65.8%
associate-*l/74.9%
Simplified74.9%
Taylor expanded in z around inf 81.2%
associate--l+81.2%
associate-*r/81.2%
associate-*r/81.2%
div-sub81.2%
distribute-lft-out--81.2%
associate-*r/81.2%
distribute-rgt-out--81.2%
mul-1-neg81.2%
unsub-neg81.2%
associate-/l*82.8%
Simplified82.8%
Taylor expanded in y around inf 77.0%
if 2.8e57 < a Initial program 76.3%
associate-*l/96.6%
Simplified96.6%
Taylor expanded in z around 0 65.8%
associate-/l*75.2%
Simplified75.2%
Final simplification76.6%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -1.9e+78) (not (<= z 3.6e+46))) (- t (* x (/ (- a y) z))) (+ x (/ (- y z) (/ a (- t x))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.9e+78) || !(z <= 3.6e+46)) {
tmp = t - (x * ((a - y) / z));
} else {
tmp = x + ((y - z) / (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 ((z <= (-1.9d+78)) .or. (.not. (z <= 3.6d+46))) then
tmp = t - (x * ((a - y) / z))
else
tmp = x + ((y - z) / (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 ((z <= -1.9e+78) || !(z <= 3.6e+46)) {
tmp = t - (x * ((a - y) / z));
} else {
tmp = x + ((y - z) / (a / (t - x)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -1.9e+78) or not (z <= 3.6e+46): tmp = t - (x * ((a - y) / z)) else: tmp = x + ((y - z) / (a / (t - x))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -1.9e+78) || !(z <= 3.6e+46)) tmp = Float64(t - Float64(x * Float64(Float64(a - y) / z))); else tmp = Float64(x + Float64(Float64(y - z) / Float64(a / Float64(t - x)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -1.9e+78) || ~((z <= 3.6e+46))) tmp = t - (x * ((a - y) / z)); else tmp = x + ((y - z) / (a / (t - x))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.9e+78], N[Not[LessEqual[z, 3.6e+46]], $MachinePrecision]], N[(t - N[(x * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y - z), $MachinePrecision] / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.9 \cdot 10^{+78} \lor \neg \left(z \leq 3.6 \cdot 10^{+46}\right):\\
\;\;\;\;t - x \cdot \frac{a - y}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y - z}{\frac{a}{t - x}}\\
\end{array}
\end{array}
if z < -1.9e78 or 3.5999999999999999e46 < z Initial program 40.7%
associate-*l/68.1%
Simplified68.1%
Taylor expanded in z around inf 68.3%
associate--l+68.3%
associate-*r/68.3%
associate-*r/68.3%
div-sub68.3%
distribute-lft-out--68.3%
associate-*r/68.3%
distribute-rgt-out--68.4%
mul-1-neg68.4%
unsub-neg68.4%
associate-/l*81.0%
Simplified81.0%
Taylor expanded in t around 0 72.0%
associate-*r/76.7%
neg-mul-176.7%
distribute-rgt-neg-in76.7%
distribute-neg-frac76.7%
Simplified76.7%
if -1.9e78 < z < 3.5999999999999999e46Initial program 85.0%
associate-/l*89.3%
Simplified89.3%
Taylor expanded in a around inf 72.9%
Final simplification74.4%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -6e+118) (not (<= a 1.24e+58))) (+ x (/ (- y z) (/ a (- t x)))) (+ t (/ (- x t) (/ z (- y a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -6e+118) || !(a <= 1.24e+58)) {
tmp = x + ((y - z) / (a / (t - x)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((a <= (-6d+118)) .or. (.not. (a <= 1.24d+58))) then
tmp = x + ((y - z) / (a / (t - x)))
else
tmp = t + ((x - t) / (z / (y - a)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -6e+118) || !(a <= 1.24e+58)) {
tmp = x + ((y - z) / (a / (t - x)));
} else {
tmp = t + ((x - t) / (z / (y - a)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -6e+118) or not (a <= 1.24e+58): tmp = x + ((y - z) / (a / (t - x))) else: tmp = t + ((x - t) / (z / (y - a))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -6e+118) || !(a <= 1.24e+58)) tmp = Float64(x + Float64(Float64(y - z) / Float64(a / Float64(t - x)))); else tmp = Float64(t + Float64(Float64(x - t) / Float64(z / Float64(y - a)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -6e+118) || ~((a <= 1.24e+58))) tmp = x + ((y - z) / (a / (t - x))); else tmp = t + ((x - t) / (z / (y - a))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -6e+118], N[Not[LessEqual[a, 1.24e+58]], $MachinePrecision]], N[(x + N[(N[(y - z), $MachinePrecision] / N[(a / N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(N[(x - t), $MachinePrecision] / N[(z / N[(y - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6 \cdot 10^{+118} \lor \neg \left(a \leq 1.24 \cdot 10^{+58}\right):\\
\;\;\;\;x + \frac{y - z}{\frac{a}{t - x}}\\
\mathbf{else}:\\
\;\;\;\;t + \frac{x - t}{\frac{z}{y - a}}\\
\end{array}
\end{array}
if a < -6e118 or 1.24000000000000005e58 < a Initial program 72.4%
associate-/l*95.8%
Simplified95.8%
Taylor expanded in a around inf 83.6%
if -6e118 < a < 1.24000000000000005e58Initial program 65.7%
associate-*l/74.2%
Simplified74.2%
Taylor expanded in z around inf 72.2%
associate--l+72.2%
associate-*r/72.2%
associate-*r/72.2%
div-sub74.1%
distribute-lft-out--74.1%
associate-*r/74.1%
distribute-rgt-out--74.1%
mul-1-neg74.1%
unsub-neg74.1%
associate-/l*78.2%
Simplified78.2%
Final simplification80.2%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.4e+125)
x
(if (<= a -6.5e-47)
t
(if (<= a 8.2e-199) (* y (/ x z)) (if (<= a 7.2e+58) t x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.4e+125) {
tmp = x;
} else if (a <= -6.5e-47) {
tmp = t;
} else if (a <= 8.2e-199) {
tmp = y * (x / z);
} else if (a <= 7.2e+58) {
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 <= (-3.4d+125)) then
tmp = x
else if (a <= (-6.5d-47)) then
tmp = t
else if (a <= 8.2d-199) then
tmp = y * (x / z)
else if (a <= 7.2d+58) 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 <= -3.4e+125) {
tmp = x;
} else if (a <= -6.5e-47) {
tmp = t;
} else if (a <= 8.2e-199) {
tmp = y * (x / z);
} else if (a <= 7.2e+58) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.4e+125: tmp = x elif a <= -6.5e-47: tmp = t elif a <= 8.2e-199: tmp = y * (x / z) elif a <= 7.2e+58: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.4e+125) tmp = x; elseif (a <= -6.5e-47) tmp = t; elseif (a <= 8.2e-199) tmp = Float64(y * Float64(x / z)); elseif (a <= 7.2e+58) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.4e+125) tmp = x; elseif (a <= -6.5e-47) tmp = t; elseif (a <= 8.2e-199) tmp = y * (x / z); elseif (a <= 7.2e+58) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.4e+125], x, If[LessEqual[a, -6.5e-47], t, If[LessEqual[a, 8.2e-199], N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7.2e+58], t, x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -6.5 \cdot 10^{-47}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 8.2 \cdot 10^{-199}:\\
\;\;\;\;y \cdot \frac{x}{z}\\
\mathbf{elif}\;a \leq 7.2 \cdot 10^{+58}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 7.19999999999999993e58 < a Initial program 73.1%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in a around inf 52.9%
if -3.3999999999999999e125 < a < -6.5000000000000004e-47 or 8.20000000000000043e-199 < a < 7.19999999999999993e58Initial program 62.0%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in z around inf 43.0%
if -6.5000000000000004e-47 < a < 8.20000000000000043e-199Initial program 69.5%
associate-*l/72.6%
Simplified72.6%
Taylor expanded in z around inf 84.0%
associate--l+84.0%
associate-*r/84.0%
associate-*r/84.0%
div-sub85.3%
distribute-lft-out--85.3%
associate-*r/85.3%
distribute-rgt-out--85.3%
mul-1-neg85.3%
unsub-neg85.3%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in t around 0 55.7%
associate-/l*57.0%
Simplified57.0%
Taylor expanded in y around inf 49.6%
associate-*l/48.9%
*-commutative48.9%
Simplified48.9%
Final simplification48.3%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.4e+125)
x
(if (<= a -8.6e-47)
t
(if (<= a 2e-201) (/ x (/ z y)) (if (<= a 7e+57) t x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.4e+125) {
tmp = x;
} else if (a <= -8.6e-47) {
tmp = t;
} else if (a <= 2e-201) {
tmp = x / (z / y);
} else if (a <= 7e+57) {
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 <= (-3.4d+125)) then
tmp = x
else if (a <= (-8.6d-47)) then
tmp = t
else if (a <= 2d-201) then
tmp = x / (z / y)
else if (a <= 7d+57) 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 <= -3.4e+125) {
tmp = x;
} else if (a <= -8.6e-47) {
tmp = t;
} else if (a <= 2e-201) {
tmp = x / (z / y);
} else if (a <= 7e+57) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.4e+125: tmp = x elif a <= -8.6e-47: tmp = t elif a <= 2e-201: tmp = x / (z / y) elif a <= 7e+57: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.4e+125) tmp = x; elseif (a <= -8.6e-47) tmp = t; elseif (a <= 2e-201) tmp = Float64(x / Float64(z / y)); elseif (a <= 7e+57) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.4e+125) tmp = x; elseif (a <= -8.6e-47) tmp = t; elseif (a <= 2e-201) tmp = x / (z / y); elseif (a <= 7e+57) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.4e+125], x, If[LessEqual[a, -8.6e-47], t, If[LessEqual[a, 2e-201], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7e+57], t, x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq -8.6 \cdot 10^{-47}:\\
\;\;\;\;t\\
\mathbf{elif}\;a \leq 2 \cdot 10^{-201}:\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{elif}\;a \leq 7 \cdot 10^{+57}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 6.9999999999999995e57 < a Initial program 73.1%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in a around inf 52.9%
if -3.3999999999999999e125 < a < -8.5999999999999995e-47 or 1.99999999999999989e-201 < a < 6.9999999999999995e57Initial program 62.0%
associate-*l/75.7%
Simplified75.7%
Taylor expanded in z around inf 43.0%
if -8.5999999999999995e-47 < a < 1.99999999999999989e-201Initial program 69.5%
associate-*l/72.6%
Simplified72.6%
Taylor expanded in z around inf 84.0%
associate--l+84.0%
associate-*r/84.0%
associate-*r/84.0%
div-sub85.3%
distribute-lft-out--85.3%
associate-*r/85.3%
distribute-rgt-out--85.3%
mul-1-neg85.3%
unsub-neg85.3%
associate-/l*86.6%
Simplified86.6%
Taylor expanded in t around 0 55.7%
associate-/l*57.0%
Simplified57.0%
Taylor expanded in y around inf 51.0%
Final simplification48.9%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -1.45e+81) (not (<= z 1.25e+93))) (+ t (/ a (/ z t))) (+ x (* t (/ y a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.45e+81) || !(z <= 1.25e+93)) {
tmp = t + (a / (z / t));
} else {
tmp = x + (t * (y / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-1.45d+81)) .or. (.not. (z <= 1.25d+93))) then
tmp = t + (a / (z / t))
else
tmp = x + (t * (y / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.45e+81) || !(z <= 1.25e+93)) {
tmp = t + (a / (z / t));
} else {
tmp = x + (t * (y / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -1.45e+81) or not (z <= 1.25e+93): tmp = t + (a / (z / t)) else: tmp = x + (t * (y / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -1.45e+81) || !(z <= 1.25e+93)) tmp = Float64(t + Float64(a / Float64(z / t))); else tmp = Float64(x + Float64(t * Float64(y / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -1.45e+81) || ~((z <= 1.25e+93))) tmp = t + (a / (z / t)); else tmp = x + (t * (y / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.45e+81], N[Not[LessEqual[z, 1.25e+93]], $MachinePrecision]], N[(t + N[(a / N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.45 \cdot 10^{+81} \lor \neg \left(z \leq 1.25 \cdot 10^{+93}\right):\\
\;\;\;\;t + \frac{a}{\frac{z}{t}}\\
\mathbf{else}:\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\end{array}
\end{array}
if z < -1.45e81 or 1.25e93 < z Initial program 37.6%
associate-*l/67.5%
Simplified67.5%
Taylor expanded in z around inf 68.6%
associate--l+68.6%
associate-*r/68.6%
associate-*r/68.6%
div-sub68.6%
distribute-lft-out--68.6%
associate-*r/68.6%
distribute-rgt-out--68.7%
mul-1-neg68.7%
unsub-neg68.7%
associate-/l*83.5%
Simplified83.5%
Taylor expanded in y around 0 60.2%
sub-neg60.2%
mul-1-neg60.2%
remove-double-neg60.2%
associate-/l*65.6%
Simplified65.6%
Taylor expanded in t around inf 54.9%
associate-/l*60.3%
Simplified60.3%
if -1.45e81 < z < 1.25e93Initial program 82.9%
associate-*l/89.9%
Simplified89.9%
Taylor expanded in z around 0 59.8%
associate-/l*63.6%
Simplified63.6%
Taylor expanded in t around inf 47.1%
associate-*r/52.6%
Simplified52.6%
Final simplification55.1%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -6e+118) (not (<= a 4.2e+57))) (+ x (* t (/ y a))) (+ t (* x (/ y z)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -6e+118) || !(a <= 4.2e+57)) {
tmp = x + (t * (y / a));
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((a <= (-6d+118)) .or. (.not. (a <= 4.2d+57))) then
tmp = x + (t * (y / a))
else
tmp = t + (x * (y / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -6e+118) || !(a <= 4.2e+57)) {
tmp = x + (t * (y / a));
} else {
tmp = t + (x * (y / z));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -6e+118) or not (a <= 4.2e+57): tmp = x + (t * (y / a)) else: tmp = t + (x * (y / z)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -6e+118) || !(a <= 4.2e+57)) tmp = Float64(x + Float64(t * Float64(y / a))); else tmp = Float64(t + Float64(x * Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -6e+118) || ~((a <= 4.2e+57))) tmp = x + (t * (y / a)); else tmp = t + (x * (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -6e+118], N[Not[LessEqual[a, 4.2e+57]], $MachinePrecision]], N[(x + N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6 \cdot 10^{+118} \lor \neg \left(a \leq 4.2 \cdot 10^{+57}\right):\\
\;\;\;\;x + t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t + x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if a < -6e118 or 4.19999999999999982e57 < a Initial program 72.4%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in z around 0 64.4%
associate-/l*76.1%
Simplified76.1%
Taylor expanded in t around inf 60.5%
associate-*r/69.5%
Simplified69.5%
if -6e118 < a < 4.19999999999999982e57Initial program 65.7%
associate-*l/74.2%
Simplified74.2%
Taylor expanded in z around inf 72.2%
associate--l+72.2%
associate-*r/72.2%
associate-*r/72.2%
div-sub74.1%
distribute-lft-out--74.1%
associate-*r/74.1%
distribute-rgt-out--74.1%
mul-1-neg74.1%
unsub-neg74.1%
associate-/l*78.2%
Simplified78.2%
Taylor expanded in y around inf 70.7%
Taylor expanded in t around 0 60.4%
associate-*r/62.8%
neg-mul-162.8%
distribute-rgt-neg-in62.8%
distribute-neg-frac62.8%
Simplified62.8%
Final simplification65.3%
(FPCore (x y z t a) :precision binary64 (if (<= a -3.4e+125) x (if (<= a 6.1e+59) t x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.4e+125) {
tmp = x;
} else if (a <= 6.1e+59) {
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 <= (-3.4d+125)) then
tmp = x
else if (a <= 6.1d+59) 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 <= -3.4e+125) {
tmp = x;
} else if (a <= 6.1e+59) {
tmp = t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.4e+125: tmp = x elif a <= 6.1e+59: tmp = t else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.4e+125) tmp = x; elseif (a <= 6.1e+59) tmp = t; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.4e+125) tmp = x; elseif (a <= 6.1e+59) tmp = t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.4e+125], x, If[LessEqual[a, 6.1e+59], t, x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.4 \cdot 10^{+125}:\\
\;\;\;\;x\\
\mathbf{elif}\;a \leq 6.1 \cdot 10^{+59}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if a < -3.3999999999999999e125 or 6.09999999999999973e59 < a Initial program 73.1%
associate-*l/96.8%
Simplified96.8%
Taylor expanded in a around inf 52.9%
if -3.3999999999999999e125 < a < 6.09999999999999973e59Initial program 65.4%
associate-*l/74.3%
Simplified74.3%
Taylor expanded in z around inf 35.2%
Final simplification41.8%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 68.2%
associate-*l/82.7%
Simplified82.7%
Taylor expanded in z around inf 27.0%
Final simplification27.0%
(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 2023320
(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))))