
(FPCore (x y z t a b c) :precision binary64 (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)))
double code(double x, double y, double z, double t, double a, double b, double c) {
return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
}
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
code = ((((x * 9.0d0) * y) - (((z * 4.0d0) * t) * a)) + b) / (z * c)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
}
def code(x, y, z, t, a, b, c): return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c)
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(Float64(x * 9.0) * y) - Float64(Float64(Float64(z * 4.0) * t) * a)) + b) / Float64(z * c)) end
function tmp = code(x, y, z, t, a, b, c) tmp = ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(N[(x * 9.0), $MachinePrecision] * y), $MachinePrecision] - N[(N[(N[(z * 4.0), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c) :precision binary64 (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)))
double code(double x, double y, double z, double t, double a, double b, double c) {
return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
}
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
code = ((((x * 9.0d0) * y) - (((z * 4.0d0) * t) * a)) + b) / (z * c)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
}
def code(x, y, z, t, a, b, c): return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c)
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(Float64(x * 9.0) * y) - Float64(Float64(Float64(z * 4.0) * t) * a)) + b) / Float64(z * c)) end
function tmp = code(x, y, z, t, a, b, c) tmp = ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(N[(x * 9.0), $MachinePrecision] * y), $MachinePrecision] - N[(N[(N[(z * 4.0), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c}
\end{array}
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* x 9.0) y)))
(if (<= t_1 -4e+233)
(/ (* 9.0 (/ y (/ c x))) z)
(if (<= t_1 5e+247)
(/ (+ (/ (fma x (* 9.0 y) b) z) (* t (* a -4.0))) c)
(* (/ x z) (/ (* 9.0 y) c))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * 9.0) * y;
double tmp;
if (t_1 <= -4e+233) {
tmp = (9.0 * (y / (c / x))) / z;
} else if (t_1 <= 5e+247) {
tmp = ((fma(x, (9.0 * y), b) / z) + (t * (a * -4.0))) / c;
} else {
tmp = (x / z) * ((9.0 * y) / c);
}
return tmp;
}
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * 9.0) * y) tmp = 0.0 if (t_1 <= -4e+233) tmp = Float64(Float64(9.0 * Float64(y / Float64(c / x))) / z); elseif (t_1 <= 5e+247) tmp = Float64(Float64(Float64(fma(x, Float64(9.0 * y), b) / z) + Float64(t * Float64(a * -4.0))) / c); else tmp = Float64(Float64(x / z) * Float64(Float64(9.0 * y) / c)); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(x * 9.0), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[t$95$1, -4e+233], N[(N[(9.0 * N[(y / N[(c / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[t$95$1, 5e+247], N[(N[(N[(N[(x * N[(9.0 * y), $MachinePrecision] + b), $MachinePrecision] / z), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], N[(N[(x / z), $MachinePrecision] * N[(N[(9.0 * y), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \left(x \cdot 9\right) \cdot y\\
\mathbf{if}\;t_1 \leq -4 \cdot 10^{+233}:\\
\;\;\;\;\frac{9 \cdot \frac{y}{\frac{c}{x}}}{z}\\
\mathbf{elif}\;t_1 \leq 5 \cdot 10^{+247}:\\
\;\;\;\;\frac{\frac{\mathsf{fma}\left(x, 9 \cdot y, b\right)}{z} + t \cdot \left(a \cdot -4\right)}{c}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{z} \cdot \frac{9 \cdot y}{c}\\
\end{array}
\end{array}
if (*.f64 (*.f64 x 9) y) < -3.99999999999999989e233Initial program 61.2%
associate-*l*64.1%
associate-*l*66.8%
Simplified66.8%
Taylor expanded in x around inf 63.4%
*-commutative63.4%
associate-/r*63.7%
associate-*l/63.7%
associate-/l*81.7%
Simplified81.7%
if -3.99999999999999989e233 < (*.f64 (*.f64 x 9) y) < 5.00000000000000023e247Initial program 82.4%
associate-/r*82.2%
Simplified91.4%
if 5.00000000000000023e247 < (*.f64 (*.f64 x 9) y) Initial program 61.5%
associate-*l*61.5%
associate-*l*61.3%
Simplified61.3%
Taylor expanded in x around inf 69.3%
associate-*r/69.3%
associate-*r*69.3%
times-frac96.0%
*-commutative96.0%
Simplified96.0%
Final simplification90.5%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (+ b (- (* (* x 9.0) y) (* a (* t (* z 4.0))))) (* c z))))
(if (<= t_1 -1e-238)
t_1
(if (<= t_1 2e-209)
(/ (+ (* t (* a -4.0)) (* 9.0 (/ (* x y) z))) c)
(if (<= t_1 INFINITY)
(/ (+ b (- (* x (* 9.0 y)) (* 4.0 (* t (* z a))))) (* c z))
(* (* a -4.0) (/ t c)))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z);
double tmp;
if (t_1 <= -1e-238) {
tmp = t_1;
} else if (t_1 <= 2e-209) {
tmp = ((t * (a * -4.0)) + (9.0 * ((x * y) / z))) / c;
} else if (t_1 <= ((double) INFINITY)) {
tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z);
} else {
tmp = (a * -4.0) * (t / c);
}
return tmp;
}
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z);
double tmp;
if (t_1 <= -1e-238) {
tmp = t_1;
} else if (t_1 <= 2e-209) {
tmp = ((t * (a * -4.0)) + (9.0 * ((x * y) / z))) / c;
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z);
} else {
tmp = (a * -4.0) * (t / c);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z) tmp = 0 if t_1 <= -1e-238: tmp = t_1 elif t_1 <= 2e-209: tmp = ((t * (a * -4.0)) + (9.0 * ((x * y) / z))) / c elif t_1 <= math.inf: tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z) else: tmp = (a * -4.0) * (t / c) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(b + Float64(Float64(Float64(x * 9.0) * y) - Float64(a * Float64(t * Float64(z * 4.0))))) / Float64(c * z)) tmp = 0.0 if (t_1 <= -1e-238) tmp = t_1; elseif (t_1 <= 2e-209) tmp = Float64(Float64(Float64(t * Float64(a * -4.0)) + Float64(9.0 * Float64(Float64(x * y) / z))) / c); elseif (t_1 <= Inf) tmp = Float64(Float64(b + Float64(Float64(x * Float64(9.0 * y)) - Float64(4.0 * Float64(t * Float64(z * a))))) / Float64(c * z)); else tmp = Float64(Float64(a * -4.0) * Float64(t / c)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z);
tmp = 0.0;
if (t_1 <= -1e-238)
tmp = t_1;
elseif (t_1 <= 2e-209)
tmp = ((t * (a * -4.0)) + (9.0 * ((x * y) / z))) / c;
elseif (t_1 <= Inf)
tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z);
else
tmp = (a * -4.0) * (t / c);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b + N[(N[(N[(x * 9.0), $MachinePrecision] * y), $MachinePrecision] - N[(a * N[(t * N[(z * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e-238], t$95$1, If[LessEqual[t$95$1, 2e-209], N[(N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] + N[(9.0 * N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(b + N[(N[(x * N[(9.0 * y), $MachinePrecision]), $MachinePrecision] - N[(4.0 * N[(t * N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \frac{b + \left(\left(x \cdot 9\right) \cdot y - a \cdot \left(t \cdot \left(z \cdot 4\right)\right)\right)}{c \cdot z}\\
\mathbf{if}\;t_1 \leq -1 \cdot 10^{-238}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq 2 \cdot 10^{-209}:\\
\;\;\;\;\frac{t \cdot \left(a \cdot -4\right) + 9 \cdot \frac{x \cdot y}{z}}{c}\\
\mathbf{elif}\;t_1 \leq \infty:\\
\;\;\;\;\frac{b + \left(x \cdot \left(9 \cdot y\right) - 4 \cdot \left(t \cdot \left(z \cdot a\right)\right)\right)}{c \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (-.f64 (*.f64 (*.f64 x 9) y) (*.f64 (*.f64 (*.f64 z 4) t) a)) b) (*.f64 z c)) < -9.9999999999999999e-239Initial program 87.8%
if -9.9999999999999999e-239 < (/.f64 (+.f64 (-.f64 (*.f64 (*.f64 x 9) y) (*.f64 (*.f64 (*.f64 z 4) t) a)) b) (*.f64 z c)) < 2.0000000000000001e-209Initial program 45.2%
associate-/r*99.4%
Simplified99.7%
Taylor expanded in x around inf 80.4%
if 2.0000000000000001e-209 < (/.f64 (+.f64 (-.f64 (*.f64 (*.f64 x 9) y) (*.f64 (*.f64 (*.f64 z 4) t) a)) b) (*.f64 z c)) < +inf.0Initial program 87.5%
associate-*l*88.5%
associate-*l*88.5%
Simplified88.5%
Taylor expanded in z around 0 88.5%
associate-*r*88.5%
*-commutative88.5%
associate-*l*85.7%
Simplified85.7%
if +inf.0 < (/.f64 (+.f64 (-.f64 (*.f64 (*.f64 x 9) y) (*.f64 (*.f64 (*.f64 z 4) t) a)) b) (*.f64 z c)) Initial program 0.0%
associate-/r*7.8%
Simplified51.8%
div-inv51.8%
+-commutative51.8%
fma-def51.8%
Applied egg-rr51.8%
Taylor expanded in t around inf 51.6%
associate-*r/51.6%
associate-*r*51.6%
*-commutative51.6%
*-commutative51.6%
associate-*l/77.7%
*-commutative77.7%
*-commutative77.7%
Simplified77.7%
Final simplification85.6%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (+ b (- (* (* x 9.0) y) (* a (* t (* z 4.0))))) (* c z))))
(if (<= t_1 -1e-81)
t_1
(if (<= t_1 INFINITY)
(* (/ 1.0 z) (/ (+ b (- (* x (* 9.0 y)) (* z (* 4.0 (* t a))))) c))
(* (* a -4.0) (/ t c))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z);
double tmp;
if (t_1 <= -1e-81) {
tmp = t_1;
} else if (t_1 <= ((double) INFINITY)) {
tmp = (1.0 / z) * ((b + ((x * (9.0 * y)) - (z * (4.0 * (t * a))))) / c);
} else {
tmp = (a * -4.0) * (t / c);
}
return tmp;
}
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z);
double tmp;
if (t_1 <= -1e-81) {
tmp = t_1;
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = (1.0 / z) * ((b + ((x * (9.0 * y)) - (z * (4.0 * (t * a))))) / c);
} else {
tmp = (a * -4.0) * (t / c);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z) tmp = 0 if t_1 <= -1e-81: tmp = t_1 elif t_1 <= math.inf: tmp = (1.0 / z) * ((b + ((x * (9.0 * y)) - (z * (4.0 * (t * a))))) / c) else: tmp = (a * -4.0) * (t / c) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(b + Float64(Float64(Float64(x * 9.0) * y) - Float64(a * Float64(t * Float64(z * 4.0))))) / Float64(c * z)) tmp = 0.0 if (t_1 <= -1e-81) tmp = t_1; elseif (t_1 <= Inf) tmp = Float64(Float64(1.0 / z) * Float64(Float64(b + Float64(Float64(x * Float64(9.0 * y)) - Float64(z * Float64(4.0 * Float64(t * a))))) / c)); else tmp = Float64(Float64(a * -4.0) * Float64(t / c)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = (b + (((x * 9.0) * y) - (a * (t * (z * 4.0))))) / (c * z);
tmp = 0.0;
if (t_1 <= -1e-81)
tmp = t_1;
elseif (t_1 <= Inf)
tmp = (1.0 / z) * ((b + ((x * (9.0 * y)) - (z * (4.0 * (t * a))))) / c);
else
tmp = (a * -4.0) * (t / c);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b + N[(N[(N[(x * 9.0), $MachinePrecision] * y), $MachinePrecision] - N[(a * N[(t * N[(z * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e-81], t$95$1, If[LessEqual[t$95$1, Infinity], N[(N[(1.0 / z), $MachinePrecision] * N[(N[(b + N[(N[(x * N[(9.0 * y), $MachinePrecision]), $MachinePrecision] - N[(z * N[(4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \frac{b + \left(\left(x \cdot 9\right) \cdot y - a \cdot \left(t \cdot \left(z \cdot 4\right)\right)\right)}{c \cdot z}\\
\mathbf{if}\;t_1 \leq -1 \cdot 10^{-81}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq \infty:\\
\;\;\;\;\frac{1}{z} \cdot \frac{b + \left(x \cdot \left(9 \cdot y\right) - z \cdot \left(4 \cdot \left(t \cdot a\right)\right)\right)}{c}\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (-.f64 (*.f64 (*.f64 x 9) y) (*.f64 (*.f64 (*.f64 z 4) t) a)) b) (*.f64 z c)) < -9.9999999999999996e-82Initial program 87.2%
if -9.9999999999999996e-82 < (/.f64 (+.f64 (-.f64 (*.f64 (*.f64 x 9) y) (*.f64 (*.f64 (*.f64 z 4) t) a)) b) (*.f64 z c)) < +inf.0Initial program 82.6%
associate-*l*83.3%
associate-*l*83.4%
Simplified83.4%
*-un-lft-identity83.4%
times-frac90.4%
associate-*r*89.6%
associate-*r*88.8%
associate-*r*89.6%
associate-*r*90.4%
associate-*l*90.4%
Applied egg-rr90.4%
if +inf.0 < (/.f64 (+.f64 (-.f64 (*.f64 (*.f64 x 9) y) (*.f64 (*.f64 (*.f64 z 4) t) a)) b) (*.f64 z c)) Initial program 0.0%
associate-/r*7.8%
Simplified51.8%
div-inv51.8%
+-commutative51.8%
fma-def51.8%
Applied egg-rr51.8%
Taylor expanded in t around inf 51.6%
associate-*r/51.6%
associate-*r*51.6%
*-commutative51.6%
*-commutative51.6%
associate-*l/77.7%
*-commutative77.7%
*-commutative77.7%
Simplified77.7%
Final simplification87.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* x (/ y z)) (/ 9.0 c))) (t_2 (* 9.0 (/ (* x y) (* c z)))))
(if (<= z -1.05e+200)
(* (* a -4.0) (/ t c))
(if (<= z -5.2e+117)
t_1
(if (<= z -1360.0)
(* -4.0 (* t (/ a c)))
(if (<= z -2e-45)
(* b (/ 1.0 (* c z)))
(if (<= z -3.3e-173)
t_2
(if (<= z 2.25e-281)
(/ (/ b c) z)
(if (<= z 1.85e-185)
t_2
(if (<= z 1.22e-23)
(/ b (* c z))
(if (<= z 9.2e+101) t_1 (/ (* t (* a -4.0)) c))))))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * (y / z)) * (9.0 / c);
double t_2 = 9.0 * ((x * y) / (c * z));
double tmp;
if (z <= -1.05e+200) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -5.2e+117) {
tmp = t_1;
} else if (z <= -1360.0) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -3.3e-173) {
tmp = t_2;
} else if (z <= 2.25e-281) {
tmp = (b / c) / z;
} else if (z <= 1.85e-185) {
tmp = t_2;
} else if (z <= 1.22e-23) {
tmp = b / (c * z);
} else if (z <= 9.2e+101) {
tmp = t_1;
} else {
tmp = (t * (a * -4.0)) / c;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x * (y / z)) * (9.0d0 / c)
t_2 = 9.0d0 * ((x * y) / (c * z))
if (z <= (-1.05d+200)) then
tmp = (a * (-4.0d0)) * (t / c)
else if (z <= (-5.2d+117)) then
tmp = t_1
else if (z <= (-1360.0d0)) then
tmp = (-4.0d0) * (t * (a / c))
else if (z <= (-2d-45)) then
tmp = b * (1.0d0 / (c * z))
else if (z <= (-3.3d-173)) then
tmp = t_2
else if (z <= 2.25d-281) then
tmp = (b / c) / z
else if (z <= 1.85d-185) then
tmp = t_2
else if (z <= 1.22d-23) then
tmp = b / (c * z)
else if (z <= 9.2d+101) then
tmp = t_1
else
tmp = (t * (a * (-4.0d0))) / c
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * (y / z)) * (9.0 / c);
double t_2 = 9.0 * ((x * y) / (c * z));
double tmp;
if (z <= -1.05e+200) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -5.2e+117) {
tmp = t_1;
} else if (z <= -1360.0) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -3.3e-173) {
tmp = t_2;
} else if (z <= 2.25e-281) {
tmp = (b / c) / z;
} else if (z <= 1.85e-185) {
tmp = t_2;
} else if (z <= 1.22e-23) {
tmp = b / (c * z);
} else if (z <= 9.2e+101) {
tmp = t_1;
} else {
tmp = (t * (a * -4.0)) / c;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = (x * (y / z)) * (9.0 / c) t_2 = 9.0 * ((x * y) / (c * z)) tmp = 0 if z <= -1.05e+200: tmp = (a * -4.0) * (t / c) elif z <= -5.2e+117: tmp = t_1 elif z <= -1360.0: tmp = -4.0 * (t * (a / c)) elif z <= -2e-45: tmp = b * (1.0 / (c * z)) elif z <= -3.3e-173: tmp = t_2 elif z <= 2.25e-281: tmp = (b / c) / z elif z <= 1.85e-185: tmp = t_2 elif z <= 1.22e-23: tmp = b / (c * z) elif z <= 9.2e+101: tmp = t_1 else: tmp = (t * (a * -4.0)) / c return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * Float64(y / z)) * Float64(9.0 / c)) t_2 = Float64(9.0 * Float64(Float64(x * y) / Float64(c * z))) tmp = 0.0 if (z <= -1.05e+200) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); elseif (z <= -5.2e+117) tmp = t_1; elseif (z <= -1360.0) tmp = Float64(-4.0 * Float64(t * Float64(a / c))); elseif (z <= -2e-45) tmp = Float64(b * Float64(1.0 / Float64(c * z))); elseif (z <= -3.3e-173) tmp = t_2; elseif (z <= 2.25e-281) tmp = Float64(Float64(b / c) / z); elseif (z <= 1.85e-185) tmp = t_2; elseif (z <= 1.22e-23) tmp = Float64(b / Float64(c * z)); elseif (z <= 9.2e+101) tmp = t_1; else tmp = Float64(Float64(t * Float64(a * -4.0)) / c); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = (x * (y / z)) * (9.0 / c);
t_2 = 9.0 * ((x * y) / (c * z));
tmp = 0.0;
if (z <= -1.05e+200)
tmp = (a * -4.0) * (t / c);
elseif (z <= -5.2e+117)
tmp = t_1;
elseif (z <= -1360.0)
tmp = -4.0 * (t * (a / c));
elseif (z <= -2e-45)
tmp = b * (1.0 / (c * z));
elseif (z <= -3.3e-173)
tmp = t_2;
elseif (z <= 2.25e-281)
tmp = (b / c) / z;
elseif (z <= 1.85e-185)
tmp = t_2;
elseif (z <= 1.22e-23)
tmp = b / (c * z);
elseif (z <= 9.2e+101)
tmp = t_1;
else
tmp = (t * (a * -4.0)) / c;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision] * N[(9.0 / c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(9.0 * N[(N[(x * y), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.05e+200], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -5.2e+117], t$95$1, If[LessEqual[z, -1360.0], N[(-4.0 * N[(t * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2e-45], N[(b * N[(1.0 / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.3e-173], t$95$2, If[LessEqual[z, 2.25e-281], N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 1.85e-185], t$95$2, If[LessEqual[z, 1.22e-23], N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9.2e+101], t$95$1, N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]]]]]]]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \left(x \cdot \frac{y}{z}\right) \cdot \frac{9}{c}\\
t_2 := 9 \cdot \frac{x \cdot y}{c \cdot z}\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{+200}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{elif}\;z \leq -5.2 \cdot 10^{+117}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -1360:\\
\;\;\;\;-4 \cdot \left(t \cdot \frac{a}{c}\right)\\
\mathbf{elif}\;z \leq -2 \cdot 10^{-45}:\\
\;\;\;\;b \cdot \frac{1}{c \cdot z}\\
\mathbf{elif}\;z \leq -3.3 \cdot 10^{-173}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{-281}:\\
\;\;\;\;\frac{\frac{b}{c}}{z}\\
\mathbf{elif}\;z \leq 1.85 \cdot 10^{-185}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 1.22 \cdot 10^{-23}:\\
\;\;\;\;\frac{b}{c \cdot z}\\
\mathbf{elif}\;z \leq 9.2 \cdot 10^{+101}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot \left(a \cdot -4\right)}{c}\\
\end{array}
\end{array}
if z < -1.04999999999999999e200Initial program 36.3%
associate-/r*48.5%
Simplified82.8%
div-inv82.7%
+-commutative82.7%
fma-def82.7%
Applied egg-rr82.7%
Taylor expanded in t around inf 71.9%
associate-*r/71.9%
associate-*r*71.9%
*-commutative71.9%
*-commutative71.9%
associate-*l/75.5%
*-commutative75.5%
*-commutative75.5%
Simplified75.5%
if -1.04999999999999999e200 < z < -5.1999999999999999e117 or 1.22000000000000007e-23 < z < 9.2000000000000005e101Initial program 69.0%
associate-/r*74.1%
Simplified76.6%
div-inv76.5%
+-commutative76.5%
fma-def76.5%
Applied egg-rr76.5%
Taylor expanded in x around inf 40.9%
associate-*r/40.8%
*-commutative40.8%
*-commutative40.8%
*-commutative40.8%
times-frac45.7%
*-commutative45.7%
associate-/l*55.0%
associate-/r/57.3%
Simplified57.3%
if -5.1999999999999999e117 < z < -1360Initial program 81.5%
associate-*l*81.5%
associate-*l*81.6%
Simplified81.6%
Taylor expanded in z around inf 46.7%
*-commutative46.7%
associate-/l*50.0%
associate-/r/46.8%
Simplified46.8%
if -1360 < z < -1.99999999999999997e-45Initial program 99.8%
associate-*l*99.8%
associate-*l*99.7%
Simplified99.7%
Taylor expanded in b around inf 65.6%
div-inv65.7%
*-commutative65.7%
Applied egg-rr65.7%
if -1.99999999999999997e-45 < z < -3.3000000000000003e-173 or 2.24999999999999997e-281 < z < 1.85e-185Initial program 98.3%
associate-*l*98.3%
associate-*l*98.3%
Simplified98.3%
Taylor expanded in x around inf 66.7%
if -3.3000000000000003e-173 < z < 2.24999999999999997e-281Initial program 93.4%
associate-*l*93.4%
associate-*l*87.1%
Simplified87.1%
Taylor expanded in b around inf 64.4%
associate-/r*67.6%
Simplified67.6%
if 1.85e-185 < z < 1.22000000000000007e-23Initial program 99.2%
associate-*l*99.2%
associate-*l*95.5%
Simplified95.5%
Taylor expanded in b around inf 60.1%
if 9.2000000000000005e101 < z Initial program 58.9%
associate-/r*67.2%
Simplified89.3%
Taylor expanded in z around inf 60.8%
associate-*r*60.8%
*-commutative60.8%
*-commutative60.8%
Simplified60.8%
Final simplification62.4%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* 9.0 (/ (* x y) (* c z)))))
(if (<= z -2.5e+193)
(* (* a -4.0) (/ t c))
(if (<= z -2.9e+112)
(* (* x (/ y z)) (/ 9.0 c))
(if (<= z -3.5)
(* -4.0 (* t (/ a c)))
(if (<= z -2.6e-45)
(* b (/ 1.0 (* c z)))
(if (<= z -1e-172)
t_1
(if (<= z 1.22e-281)
(/ (/ b c) z)
(if (<= z 1.05e-175)
t_1
(if (<= z 6.4e-122)
(/ b (* c z))
(if (<= z 4.6e+144)
(* (/ x z) (/ (* 9.0 y) c))
(* (* t (* a -4.0)) (/ 1.0 c)))))))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 9.0 * ((x * y) / (c * z));
double tmp;
if (z <= -2.5e+193) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -2.9e+112) {
tmp = (x * (y / z)) * (9.0 / c);
} else if (z <= -3.5) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2.6e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -1e-172) {
tmp = t_1;
} else if (z <= 1.22e-281) {
tmp = (b / c) / z;
} else if (z <= 1.05e-175) {
tmp = t_1;
} else if (z <= 6.4e-122) {
tmp = b / (c * z);
} else if (z <= 4.6e+144) {
tmp = (x / z) * ((9.0 * y) / c);
} else {
tmp = (t * (a * -4.0)) * (1.0 / c);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: tmp
t_1 = 9.0d0 * ((x * y) / (c * z))
if (z <= (-2.5d+193)) then
tmp = (a * (-4.0d0)) * (t / c)
else if (z <= (-2.9d+112)) then
tmp = (x * (y / z)) * (9.0d0 / c)
else if (z <= (-3.5d0)) then
tmp = (-4.0d0) * (t * (a / c))
else if (z <= (-2.6d-45)) then
tmp = b * (1.0d0 / (c * z))
else if (z <= (-1d-172)) then
tmp = t_1
else if (z <= 1.22d-281) then
tmp = (b / c) / z
else if (z <= 1.05d-175) then
tmp = t_1
else if (z <= 6.4d-122) then
tmp = b / (c * z)
else if (z <= 4.6d+144) then
tmp = (x / z) * ((9.0d0 * y) / c)
else
tmp = (t * (a * (-4.0d0))) * (1.0d0 / c)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 9.0 * ((x * y) / (c * z));
double tmp;
if (z <= -2.5e+193) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -2.9e+112) {
tmp = (x * (y / z)) * (9.0 / c);
} else if (z <= -3.5) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2.6e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -1e-172) {
tmp = t_1;
} else if (z <= 1.22e-281) {
tmp = (b / c) / z;
} else if (z <= 1.05e-175) {
tmp = t_1;
} else if (z <= 6.4e-122) {
tmp = b / (c * z);
} else if (z <= 4.6e+144) {
tmp = (x / z) * ((9.0 * y) / c);
} else {
tmp = (t * (a * -4.0)) * (1.0 / c);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = 9.0 * ((x * y) / (c * z)) tmp = 0 if z <= -2.5e+193: tmp = (a * -4.0) * (t / c) elif z <= -2.9e+112: tmp = (x * (y / z)) * (9.0 / c) elif z <= -3.5: tmp = -4.0 * (t * (a / c)) elif z <= -2.6e-45: tmp = b * (1.0 / (c * z)) elif z <= -1e-172: tmp = t_1 elif z <= 1.22e-281: tmp = (b / c) / z elif z <= 1.05e-175: tmp = t_1 elif z <= 6.4e-122: tmp = b / (c * z) elif z <= 4.6e+144: tmp = (x / z) * ((9.0 * y) / c) else: tmp = (t * (a * -4.0)) * (1.0 / c) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(9.0 * Float64(Float64(x * y) / Float64(c * z))) tmp = 0.0 if (z <= -2.5e+193) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); elseif (z <= -2.9e+112) tmp = Float64(Float64(x * Float64(y / z)) * Float64(9.0 / c)); elseif (z <= -3.5) tmp = Float64(-4.0 * Float64(t * Float64(a / c))); elseif (z <= -2.6e-45) tmp = Float64(b * Float64(1.0 / Float64(c * z))); elseif (z <= -1e-172) tmp = t_1; elseif (z <= 1.22e-281) tmp = Float64(Float64(b / c) / z); elseif (z <= 1.05e-175) tmp = t_1; elseif (z <= 6.4e-122) tmp = Float64(b / Float64(c * z)); elseif (z <= 4.6e+144) tmp = Float64(Float64(x / z) * Float64(Float64(9.0 * y) / c)); else tmp = Float64(Float64(t * Float64(a * -4.0)) * Float64(1.0 / c)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = 9.0 * ((x * y) / (c * z));
tmp = 0.0;
if (z <= -2.5e+193)
tmp = (a * -4.0) * (t / c);
elseif (z <= -2.9e+112)
tmp = (x * (y / z)) * (9.0 / c);
elseif (z <= -3.5)
tmp = -4.0 * (t * (a / c));
elseif (z <= -2.6e-45)
tmp = b * (1.0 / (c * z));
elseif (z <= -1e-172)
tmp = t_1;
elseif (z <= 1.22e-281)
tmp = (b / c) / z;
elseif (z <= 1.05e-175)
tmp = t_1;
elseif (z <= 6.4e-122)
tmp = b / (c * z);
elseif (z <= 4.6e+144)
tmp = (x / z) * ((9.0 * y) / c);
else
tmp = (t * (a * -4.0)) * (1.0 / c);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(9.0 * N[(N[(x * y), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.5e+193], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.9e+112], N[(N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision] * N[(9.0 / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.5], N[(-4.0 * N[(t * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.6e-45], N[(b * N[(1.0 / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1e-172], t$95$1, If[LessEqual[z, 1.22e-281], N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 1.05e-175], t$95$1, If[LessEqual[z, 6.4e-122], N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.6e+144], N[(N[(x / z), $MachinePrecision] * N[(N[(9.0 * y), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / c), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := 9 \cdot \frac{x \cdot y}{c \cdot z}\\
\mathbf{if}\;z \leq -2.5 \cdot 10^{+193}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{elif}\;z \leq -2.9 \cdot 10^{+112}:\\
\;\;\;\;\left(x \cdot \frac{y}{z}\right) \cdot \frac{9}{c}\\
\mathbf{elif}\;z \leq -3.5:\\
\;\;\;\;-4 \cdot \left(t \cdot \frac{a}{c}\right)\\
\mathbf{elif}\;z \leq -2.6 \cdot 10^{-45}:\\
\;\;\;\;b \cdot \frac{1}{c \cdot z}\\
\mathbf{elif}\;z \leq -1 \cdot 10^{-172}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.22 \cdot 10^{-281}:\\
\;\;\;\;\frac{\frac{b}{c}}{z}\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-175}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 6.4 \cdot 10^{-122}:\\
\;\;\;\;\frac{b}{c \cdot z}\\
\mathbf{elif}\;z \leq 4.6 \cdot 10^{+144}:\\
\;\;\;\;\frac{x}{z} \cdot \frac{9 \cdot y}{c}\\
\mathbf{else}:\\
\;\;\;\;\left(t \cdot \left(a \cdot -4\right)\right) \cdot \frac{1}{c}\\
\end{array}
\end{array}
if z < -2.49999999999999986e193Initial program 36.3%
associate-/r*48.5%
Simplified82.8%
div-inv82.7%
+-commutative82.7%
fma-def82.7%
Applied egg-rr82.7%
Taylor expanded in t around inf 71.9%
associate-*r/71.9%
associate-*r*71.9%
*-commutative71.9%
*-commutative71.9%
associate-*l/75.5%
*-commutative75.5%
*-commutative75.5%
Simplified75.5%
if -2.49999999999999986e193 < z < -2.9000000000000002e112Initial program 67.1%
associate-/r*73.7%
Simplified80.5%
div-inv80.5%
+-commutative80.5%
fma-def80.5%
Applied egg-rr80.5%
Taylor expanded in x around inf 41.6%
associate-*r/41.4%
*-commutative41.4%
*-commutative41.4%
*-commutative41.4%
times-frac48.1%
*-commutative48.1%
associate-/l*54.5%
associate-/r/60.8%
Simplified60.8%
if -2.9000000000000002e112 < z < -3.5Initial program 81.5%
associate-*l*81.5%
associate-*l*81.6%
Simplified81.6%
Taylor expanded in z around inf 46.7%
*-commutative46.7%
associate-/l*50.0%
associate-/r/46.8%
Simplified46.8%
if -3.5 < z < -2.59999999999999987e-45Initial program 99.8%
associate-*l*99.8%
associate-*l*99.7%
Simplified99.7%
Taylor expanded in b around inf 65.6%
div-inv65.7%
*-commutative65.7%
Applied egg-rr65.7%
if -2.59999999999999987e-45 < z < -1e-172 or 1.21999999999999996e-281 < z < 1.05e-175Initial program 98.3%
associate-*l*98.3%
associate-*l*98.3%
Simplified98.3%
Taylor expanded in x around inf 66.7%
if -1e-172 < z < 1.21999999999999996e-281Initial program 93.4%
associate-*l*93.4%
associate-*l*87.1%
Simplified87.1%
Taylor expanded in b around inf 64.4%
associate-/r*67.6%
Simplified67.6%
if 1.05e-175 < z < 6.4000000000000004e-122Initial program 100.0%
associate-*l*100.0%
associate-*l*88.9%
Simplified88.9%
Taylor expanded in b around inf 88.9%
if 6.4000000000000004e-122 < z < 4.6000000000000003e144Initial program 78.3%
associate-*l*78.4%
associate-*l*81.9%
Simplified81.9%
Taylor expanded in x around inf 38.5%
associate-*r/38.5%
associate-*r*38.5%
times-frac50.0%
*-commutative50.0%
Simplified50.0%
if 4.6000000000000003e144 < z Initial program 57.3%
associate-/r*68.0%
Simplified91.5%
Taylor expanded in z around inf 70.2%
associate-*r*70.2%
*-commutative70.2%
*-commutative70.2%
Simplified70.2%
div-inv70.2%
Applied egg-rr70.2%
Final simplification63.1%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (* x (* 9.0 y)) (* c z))))
(if (<= z -2.65e+193)
(* (* a -4.0) (/ t c))
(if (<= z -4.2e+116)
(* (* x (/ y z)) (/ 9.0 c))
(if (<= z -3.1)
(* -4.0 (* t (/ a c)))
(if (<= z -2.35e-45)
(* b (/ 1.0 (* c z)))
(if (<= z -5.3e-173)
t_1
(if (<= z 1.15e-279)
(/ (/ b c) z)
(if (<= z 2.2e-171)
t_1
(if (<= z 2.9e-122)
(/ b (* c z))
(if (<= z 1.6e+145)
(* (/ x z) (/ (* 9.0 y) c))
(* (* t (* a -4.0)) (/ 1.0 c)))))))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * (9.0 * y)) / (c * z);
double tmp;
if (z <= -2.65e+193) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -4.2e+116) {
tmp = (x * (y / z)) * (9.0 / c);
} else if (z <= -3.1) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2.35e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -5.3e-173) {
tmp = t_1;
} else if (z <= 1.15e-279) {
tmp = (b / c) / z;
} else if (z <= 2.2e-171) {
tmp = t_1;
} else if (z <= 2.9e-122) {
tmp = b / (c * z);
} else if (z <= 1.6e+145) {
tmp = (x / z) * ((9.0 * y) / c);
} else {
tmp = (t * (a * -4.0)) * (1.0 / c);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: tmp
t_1 = (x * (9.0d0 * y)) / (c * z)
if (z <= (-2.65d+193)) then
tmp = (a * (-4.0d0)) * (t / c)
else if (z <= (-4.2d+116)) then
tmp = (x * (y / z)) * (9.0d0 / c)
else if (z <= (-3.1d0)) then
tmp = (-4.0d0) * (t * (a / c))
else if (z <= (-2.35d-45)) then
tmp = b * (1.0d0 / (c * z))
else if (z <= (-5.3d-173)) then
tmp = t_1
else if (z <= 1.15d-279) then
tmp = (b / c) / z
else if (z <= 2.2d-171) then
tmp = t_1
else if (z <= 2.9d-122) then
tmp = b / (c * z)
else if (z <= 1.6d+145) then
tmp = (x / z) * ((9.0d0 * y) / c)
else
tmp = (t * (a * (-4.0d0))) * (1.0d0 / c)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * (9.0 * y)) / (c * z);
double tmp;
if (z <= -2.65e+193) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -4.2e+116) {
tmp = (x * (y / z)) * (9.0 / c);
} else if (z <= -3.1) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2.35e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -5.3e-173) {
tmp = t_1;
} else if (z <= 1.15e-279) {
tmp = (b / c) / z;
} else if (z <= 2.2e-171) {
tmp = t_1;
} else if (z <= 2.9e-122) {
tmp = b / (c * z);
} else if (z <= 1.6e+145) {
tmp = (x / z) * ((9.0 * y) / c);
} else {
tmp = (t * (a * -4.0)) * (1.0 / c);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = (x * (9.0 * y)) / (c * z) tmp = 0 if z <= -2.65e+193: tmp = (a * -4.0) * (t / c) elif z <= -4.2e+116: tmp = (x * (y / z)) * (9.0 / c) elif z <= -3.1: tmp = -4.0 * (t * (a / c)) elif z <= -2.35e-45: tmp = b * (1.0 / (c * z)) elif z <= -5.3e-173: tmp = t_1 elif z <= 1.15e-279: tmp = (b / c) / z elif z <= 2.2e-171: tmp = t_1 elif z <= 2.9e-122: tmp = b / (c * z) elif z <= 1.6e+145: tmp = (x / z) * ((9.0 * y) / c) else: tmp = (t * (a * -4.0)) * (1.0 / c) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * Float64(9.0 * y)) / Float64(c * z)) tmp = 0.0 if (z <= -2.65e+193) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); elseif (z <= -4.2e+116) tmp = Float64(Float64(x * Float64(y / z)) * Float64(9.0 / c)); elseif (z <= -3.1) tmp = Float64(-4.0 * Float64(t * Float64(a / c))); elseif (z <= -2.35e-45) tmp = Float64(b * Float64(1.0 / Float64(c * z))); elseif (z <= -5.3e-173) tmp = t_1; elseif (z <= 1.15e-279) tmp = Float64(Float64(b / c) / z); elseif (z <= 2.2e-171) tmp = t_1; elseif (z <= 2.9e-122) tmp = Float64(b / Float64(c * z)); elseif (z <= 1.6e+145) tmp = Float64(Float64(x / z) * Float64(Float64(9.0 * y) / c)); else tmp = Float64(Float64(t * Float64(a * -4.0)) * Float64(1.0 / c)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = (x * (9.0 * y)) / (c * z);
tmp = 0.0;
if (z <= -2.65e+193)
tmp = (a * -4.0) * (t / c);
elseif (z <= -4.2e+116)
tmp = (x * (y / z)) * (9.0 / c);
elseif (z <= -3.1)
tmp = -4.0 * (t * (a / c));
elseif (z <= -2.35e-45)
tmp = b * (1.0 / (c * z));
elseif (z <= -5.3e-173)
tmp = t_1;
elseif (z <= 1.15e-279)
tmp = (b / c) / z;
elseif (z <= 2.2e-171)
tmp = t_1;
elseif (z <= 2.9e-122)
tmp = b / (c * z);
elseif (z <= 1.6e+145)
tmp = (x / z) * ((9.0 * y) / c);
else
tmp = (t * (a * -4.0)) * (1.0 / c);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(x * N[(9.0 * y), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.65e+193], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.2e+116], N[(N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision] * N[(9.0 / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.1], N[(-4.0 * N[(t * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.35e-45], N[(b * N[(1.0 / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -5.3e-173], t$95$1, If[LessEqual[z, 1.15e-279], N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 2.2e-171], t$95$1, If[LessEqual[z, 2.9e-122], N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.6e+145], N[(N[(x / z), $MachinePrecision] * N[(N[(9.0 * y), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / c), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \frac{x \cdot \left(9 \cdot y\right)}{c \cdot z}\\
\mathbf{if}\;z \leq -2.65 \cdot 10^{+193}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{elif}\;z \leq -4.2 \cdot 10^{+116}:\\
\;\;\;\;\left(x \cdot \frac{y}{z}\right) \cdot \frac{9}{c}\\
\mathbf{elif}\;z \leq -3.1:\\
\;\;\;\;-4 \cdot \left(t \cdot \frac{a}{c}\right)\\
\mathbf{elif}\;z \leq -2.35 \cdot 10^{-45}:\\
\;\;\;\;b \cdot \frac{1}{c \cdot z}\\
\mathbf{elif}\;z \leq -5.3 \cdot 10^{-173}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.15 \cdot 10^{-279}:\\
\;\;\;\;\frac{\frac{b}{c}}{z}\\
\mathbf{elif}\;z \leq 2.2 \cdot 10^{-171}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 2.9 \cdot 10^{-122}:\\
\;\;\;\;\frac{b}{c \cdot z}\\
\mathbf{elif}\;z \leq 1.6 \cdot 10^{+145}:\\
\;\;\;\;\frac{x}{z} \cdot \frac{9 \cdot y}{c}\\
\mathbf{else}:\\
\;\;\;\;\left(t \cdot \left(a \cdot -4\right)\right) \cdot \frac{1}{c}\\
\end{array}
\end{array}
if z < -2.6499999999999999e193Initial program 36.3%
associate-/r*48.5%
Simplified82.8%
div-inv82.7%
+-commutative82.7%
fma-def82.7%
Applied egg-rr82.7%
Taylor expanded in t around inf 71.9%
associate-*r/71.9%
associate-*r*71.9%
*-commutative71.9%
*-commutative71.9%
associate-*l/75.5%
*-commutative75.5%
*-commutative75.5%
Simplified75.5%
if -2.6499999999999999e193 < z < -4.2000000000000002e116Initial program 67.1%
associate-/r*73.7%
Simplified80.5%
div-inv80.5%
+-commutative80.5%
fma-def80.5%
Applied egg-rr80.5%
Taylor expanded in x around inf 41.6%
associate-*r/41.4%
*-commutative41.4%
*-commutative41.4%
*-commutative41.4%
times-frac48.1%
*-commutative48.1%
associate-/l*54.5%
associate-/r/60.8%
Simplified60.8%
if -4.2000000000000002e116 < z < -3.10000000000000009Initial program 81.5%
associate-*l*81.5%
associate-*l*81.6%
Simplified81.6%
Taylor expanded in z around inf 46.7%
*-commutative46.7%
associate-/l*50.0%
associate-/r/46.8%
Simplified46.8%
if -3.10000000000000009 < z < -2.3499999999999999e-45Initial program 99.8%
associate-*l*99.8%
associate-*l*99.7%
Simplified99.7%
Taylor expanded in b around inf 65.6%
div-inv65.7%
*-commutative65.7%
Applied egg-rr65.7%
if -2.3499999999999999e-45 < z < -5.29999999999999964e-173 or 1.14999999999999998e-279 < z < 2.2000000000000001e-171Initial program 98.3%
associate-*l*98.3%
associate-*l*98.3%
Simplified98.3%
Taylor expanded in x around inf 66.7%
associate-*r/66.7%
associate-*r*66.8%
times-frac53.0%
*-commutative53.0%
Simplified53.0%
frac-times66.8%
Applied egg-rr66.8%
if -5.29999999999999964e-173 < z < 1.14999999999999998e-279Initial program 93.4%
associate-*l*93.4%
associate-*l*87.1%
Simplified87.1%
Taylor expanded in b around inf 64.4%
associate-/r*67.6%
Simplified67.6%
if 2.2000000000000001e-171 < z < 2.9000000000000002e-122Initial program 100.0%
associate-*l*100.0%
associate-*l*88.9%
Simplified88.9%
Taylor expanded in b around inf 88.9%
if 2.9000000000000002e-122 < z < 1.60000000000000004e145Initial program 78.3%
associate-*l*78.4%
associate-*l*81.9%
Simplified81.9%
Taylor expanded in x around inf 38.5%
associate-*r/38.5%
associate-*r*38.5%
times-frac50.0%
*-commutative50.0%
Simplified50.0%
if 1.60000000000000004e145 < z Initial program 57.3%
associate-/r*68.0%
Simplified91.5%
Taylor expanded in z around inf 70.2%
associate-*r*70.2%
*-commutative70.2%
*-commutative70.2%
Simplified70.2%
div-inv70.2%
Applied egg-rr70.2%
Final simplification63.1%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(if (<= z -1e+200)
(* (* a -4.0) (/ t c))
(if (<= z -1.55e+117)
(* (* 9.0 (/ y (/ z x))) (/ 1.0 c))
(if (<= z -225.0)
(* -4.0 (* t (/ a c)))
(if (<= z -2.6e-45)
(* b (/ 1.0 (* c z)))
(if (<= z -3e-172)
(/ (* 9.0 (/ y (/ c x))) z)
(if (<= z 2.1e-281)
(/ (/ b c) z)
(if (<= z 9.5e-183)
(/ (* x (* 9.0 y)) (* c z))
(if (<= z 2.5e-127)
(/ b (* c z))
(if (<= z 3.7e+143)
(* (/ x z) (/ (* 9.0 y) c))
(* (* t (* a -4.0)) (/ 1.0 c))))))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (z <= -1e+200) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -1.55e+117) {
tmp = (9.0 * (y / (z / x))) * (1.0 / c);
} else if (z <= -225.0) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2.6e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -3e-172) {
tmp = (9.0 * (y / (c / x))) / z;
} else if (z <= 2.1e-281) {
tmp = (b / c) / z;
} else if (z <= 9.5e-183) {
tmp = (x * (9.0 * y)) / (c * z);
} else if (z <= 2.5e-127) {
tmp = b / (c * z);
} else if (z <= 3.7e+143) {
tmp = (x / z) * ((9.0 * y) / c);
} else {
tmp = (t * (a * -4.0)) * (1.0 / c);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (z <= (-1d+200)) then
tmp = (a * (-4.0d0)) * (t / c)
else if (z <= (-1.55d+117)) then
tmp = (9.0d0 * (y / (z / x))) * (1.0d0 / c)
else if (z <= (-225.0d0)) then
tmp = (-4.0d0) * (t * (a / c))
else if (z <= (-2.6d-45)) then
tmp = b * (1.0d0 / (c * z))
else if (z <= (-3d-172)) then
tmp = (9.0d0 * (y / (c / x))) / z
else if (z <= 2.1d-281) then
tmp = (b / c) / z
else if (z <= 9.5d-183) then
tmp = (x * (9.0d0 * y)) / (c * z)
else if (z <= 2.5d-127) then
tmp = b / (c * z)
else if (z <= 3.7d+143) then
tmp = (x / z) * ((9.0d0 * y) / c)
else
tmp = (t * (a * (-4.0d0))) * (1.0d0 / c)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (z <= -1e+200) {
tmp = (a * -4.0) * (t / c);
} else if (z <= -1.55e+117) {
tmp = (9.0 * (y / (z / x))) * (1.0 / c);
} else if (z <= -225.0) {
tmp = -4.0 * (t * (a / c));
} else if (z <= -2.6e-45) {
tmp = b * (1.0 / (c * z));
} else if (z <= -3e-172) {
tmp = (9.0 * (y / (c / x))) / z;
} else if (z <= 2.1e-281) {
tmp = (b / c) / z;
} else if (z <= 9.5e-183) {
tmp = (x * (9.0 * y)) / (c * z);
} else if (z <= 2.5e-127) {
tmp = b / (c * z);
} else if (z <= 3.7e+143) {
tmp = (x / z) * ((9.0 * y) / c);
} else {
tmp = (t * (a * -4.0)) * (1.0 / c);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): tmp = 0 if z <= -1e+200: tmp = (a * -4.0) * (t / c) elif z <= -1.55e+117: tmp = (9.0 * (y / (z / x))) * (1.0 / c) elif z <= -225.0: tmp = -4.0 * (t * (a / c)) elif z <= -2.6e-45: tmp = b * (1.0 / (c * z)) elif z <= -3e-172: tmp = (9.0 * (y / (c / x))) / z elif z <= 2.1e-281: tmp = (b / c) / z elif z <= 9.5e-183: tmp = (x * (9.0 * y)) / (c * z) elif z <= 2.5e-127: tmp = b / (c * z) elif z <= 3.7e+143: tmp = (x / z) * ((9.0 * y) / c) else: tmp = (t * (a * -4.0)) * (1.0 / c) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) tmp = 0.0 if (z <= -1e+200) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); elseif (z <= -1.55e+117) tmp = Float64(Float64(9.0 * Float64(y / Float64(z / x))) * Float64(1.0 / c)); elseif (z <= -225.0) tmp = Float64(-4.0 * Float64(t * Float64(a / c))); elseif (z <= -2.6e-45) tmp = Float64(b * Float64(1.0 / Float64(c * z))); elseif (z <= -3e-172) tmp = Float64(Float64(9.0 * Float64(y / Float64(c / x))) / z); elseif (z <= 2.1e-281) tmp = Float64(Float64(b / c) / z); elseif (z <= 9.5e-183) tmp = Float64(Float64(x * Float64(9.0 * y)) / Float64(c * z)); elseif (z <= 2.5e-127) tmp = Float64(b / Float64(c * z)); elseif (z <= 3.7e+143) tmp = Float64(Float64(x / z) * Float64(Float64(9.0 * y) / c)); else tmp = Float64(Float64(t * Float64(a * -4.0)) * Float64(1.0 / c)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
tmp = 0.0;
if (z <= -1e+200)
tmp = (a * -4.0) * (t / c);
elseif (z <= -1.55e+117)
tmp = (9.0 * (y / (z / x))) * (1.0 / c);
elseif (z <= -225.0)
tmp = -4.0 * (t * (a / c));
elseif (z <= -2.6e-45)
tmp = b * (1.0 / (c * z));
elseif (z <= -3e-172)
tmp = (9.0 * (y / (c / x))) / z;
elseif (z <= 2.1e-281)
tmp = (b / c) / z;
elseif (z <= 9.5e-183)
tmp = (x * (9.0 * y)) / (c * z);
elseif (z <= 2.5e-127)
tmp = b / (c * z);
elseif (z <= 3.7e+143)
tmp = (x / z) * ((9.0 * y) / c);
else
tmp = (t * (a * -4.0)) * (1.0 / c);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[z, -1e+200], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.55e+117], N[(N[(9.0 * N[(y / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -225.0], N[(-4.0 * N[(t * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.6e-45], N[(b * N[(1.0 / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3e-172], N[(N[(9.0 * N[(y / N[(c / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 2.1e-281], N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 9.5e-183], N[(N[(x * N[(9.0 * y), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.5e-127], N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.7e+143], N[(N[(x / z), $MachinePrecision] * N[(N[(9.0 * y), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / c), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \cdot 10^{+200}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{elif}\;z \leq -1.55 \cdot 10^{+117}:\\
\;\;\;\;\left(9 \cdot \frac{y}{\frac{z}{x}}\right) \cdot \frac{1}{c}\\
\mathbf{elif}\;z \leq -225:\\
\;\;\;\;-4 \cdot \left(t \cdot \frac{a}{c}\right)\\
\mathbf{elif}\;z \leq -2.6 \cdot 10^{-45}:\\
\;\;\;\;b \cdot \frac{1}{c \cdot z}\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-172}:\\
\;\;\;\;\frac{9 \cdot \frac{y}{\frac{c}{x}}}{z}\\
\mathbf{elif}\;z \leq 2.1 \cdot 10^{-281}:\\
\;\;\;\;\frac{\frac{b}{c}}{z}\\
\mathbf{elif}\;z \leq 9.5 \cdot 10^{-183}:\\
\;\;\;\;\frac{x \cdot \left(9 \cdot y\right)}{c \cdot z}\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{-127}:\\
\;\;\;\;\frac{b}{c \cdot z}\\
\mathbf{elif}\;z \leq 3.7 \cdot 10^{+143}:\\
\;\;\;\;\frac{x}{z} \cdot \frac{9 \cdot y}{c}\\
\mathbf{else}:\\
\;\;\;\;\left(t \cdot \left(a \cdot -4\right)\right) \cdot \frac{1}{c}\\
\end{array}
\end{array}
if z < -9.9999999999999997e199Initial program 36.3%
associate-/r*48.5%
Simplified82.8%
div-inv82.7%
+-commutative82.7%
fma-def82.7%
Applied egg-rr82.7%
Taylor expanded in t around inf 71.9%
associate-*r/71.9%
associate-*r*71.9%
*-commutative71.9%
*-commutative71.9%
associate-*l/75.5%
*-commutative75.5%
*-commutative75.5%
Simplified75.5%
if -9.9999999999999997e199 < z < -1.54999999999999988e117Initial program 67.1%
associate-/r*73.7%
Simplified80.5%
div-inv80.5%
+-commutative80.5%
fma-def80.5%
Applied egg-rr80.5%
Taylor expanded in x around inf 48.1%
associate-/l*54.5%
Simplified54.5%
if -1.54999999999999988e117 < z < -225Initial program 81.5%
associate-*l*81.5%
associate-*l*81.6%
Simplified81.6%
Taylor expanded in z around inf 46.7%
*-commutative46.7%
associate-/l*50.0%
associate-/r/46.8%
Simplified46.8%
if -225 < z < -2.59999999999999987e-45Initial program 99.8%
associate-*l*99.8%
associate-*l*99.7%
Simplified99.7%
Taylor expanded in b around inf 65.6%
div-inv65.7%
*-commutative65.7%
Applied egg-rr65.7%
if -2.59999999999999987e-45 < z < -2.99999999999999984e-172Initial program 99.7%
associate-*l*99.7%
associate-*l*99.7%
Simplified99.7%
Taylor expanded in x around inf 64.2%
*-commutative64.2%
associate-/r*64.3%
associate-*l/64.4%
associate-/l*64.4%
Simplified64.4%
if -2.99999999999999984e-172 < z < 2.0999999999999999e-281Initial program 93.4%
associate-*l*93.4%
associate-*l*87.1%
Simplified87.1%
Taylor expanded in b around inf 64.4%
associate-/r*67.6%
Simplified67.6%
if 2.0999999999999999e-281 < z < 9.5000000000000008e-183Initial program 95.0%
associate-*l*95.0%
associate-*l*95.0%
Simplified95.0%
Taylor expanded in x around inf 72.6%
associate-*r/72.6%
associate-*r*72.7%
times-frac41.8%
*-commutative41.8%
Simplified41.8%
frac-times72.7%
Applied egg-rr72.7%
if 9.5000000000000008e-183 < z < 2.4999999999999999e-127Initial program 100.0%
associate-*l*100.0%
associate-*l*88.9%
Simplified88.9%
Taylor expanded in b around inf 88.9%
if 2.4999999999999999e-127 < z < 3.7000000000000002e143Initial program 78.3%
associate-*l*78.4%
associate-*l*81.9%
Simplified81.9%
Taylor expanded in x around inf 38.5%
associate-*r/38.5%
associate-*r*38.5%
times-frac50.0%
*-commutative50.0%
Simplified50.0%
if 3.7000000000000002e143 < z Initial program 57.3%
associate-/r*68.0%
Simplified91.5%
Taylor expanded in z around inf 70.2%
associate-*r*70.2%
*-commutative70.2%
*-commutative70.2%
Simplified70.2%
div-inv70.2%
Applied egg-rr70.2%
Final simplification62.7%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (/ b c) z)))
(if (<= x -1.05e+29)
(/ (* x (/ 9.0 (/ c y))) z)
(if (<= x -1e-164)
t_1
(if (<= x -1.15e-218)
(* -4.0 (* t (/ a c)))
(if (<= x -3.9e-286)
(/ (/ b z) c)
(if (<= x 5.3e-253)
(* -4.0 (/ a (/ c t)))
(if (<= x 2.6e-122)
t_1
(if (<= x 1.06e-89)
(* (* a -4.0) (/ t c))
(* (* x (/ y z)) (/ 9.0 c)))))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b / c) / z;
double tmp;
if (x <= -1.05e+29) {
tmp = (x * (9.0 / (c / y))) / z;
} else if (x <= -1e-164) {
tmp = t_1;
} else if (x <= -1.15e-218) {
tmp = -4.0 * (t * (a / c));
} else if (x <= -3.9e-286) {
tmp = (b / z) / c;
} else if (x <= 5.3e-253) {
tmp = -4.0 * (a / (c / t));
} else if (x <= 2.6e-122) {
tmp = t_1;
} else if (x <= 1.06e-89) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = (x * (y / z)) * (9.0 / c);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: tmp
t_1 = (b / c) / z
if (x <= (-1.05d+29)) then
tmp = (x * (9.0d0 / (c / y))) / z
else if (x <= (-1d-164)) then
tmp = t_1
else if (x <= (-1.15d-218)) then
tmp = (-4.0d0) * (t * (a / c))
else if (x <= (-3.9d-286)) then
tmp = (b / z) / c
else if (x <= 5.3d-253) then
tmp = (-4.0d0) * (a / (c / t))
else if (x <= 2.6d-122) then
tmp = t_1
else if (x <= 1.06d-89) then
tmp = (a * (-4.0d0)) * (t / c)
else
tmp = (x * (y / z)) * (9.0d0 / c)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b / c) / z;
double tmp;
if (x <= -1.05e+29) {
tmp = (x * (9.0 / (c / y))) / z;
} else if (x <= -1e-164) {
tmp = t_1;
} else if (x <= -1.15e-218) {
tmp = -4.0 * (t * (a / c));
} else if (x <= -3.9e-286) {
tmp = (b / z) / c;
} else if (x <= 5.3e-253) {
tmp = -4.0 * (a / (c / t));
} else if (x <= 2.6e-122) {
tmp = t_1;
} else if (x <= 1.06e-89) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = (x * (y / z)) * (9.0 / c);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = (b / c) / z tmp = 0 if x <= -1.05e+29: tmp = (x * (9.0 / (c / y))) / z elif x <= -1e-164: tmp = t_1 elif x <= -1.15e-218: tmp = -4.0 * (t * (a / c)) elif x <= -3.9e-286: tmp = (b / z) / c elif x <= 5.3e-253: tmp = -4.0 * (a / (c / t)) elif x <= 2.6e-122: tmp = t_1 elif x <= 1.06e-89: tmp = (a * -4.0) * (t / c) else: tmp = (x * (y / z)) * (9.0 / c) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(b / c) / z) tmp = 0.0 if (x <= -1.05e+29) tmp = Float64(Float64(x * Float64(9.0 / Float64(c / y))) / z); elseif (x <= -1e-164) tmp = t_1; elseif (x <= -1.15e-218) tmp = Float64(-4.0 * Float64(t * Float64(a / c))); elseif (x <= -3.9e-286) tmp = Float64(Float64(b / z) / c); elseif (x <= 5.3e-253) tmp = Float64(-4.0 * Float64(a / Float64(c / t))); elseif (x <= 2.6e-122) tmp = t_1; elseif (x <= 1.06e-89) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); else tmp = Float64(Float64(x * Float64(y / z)) * Float64(9.0 / c)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = (b / c) / z;
tmp = 0.0;
if (x <= -1.05e+29)
tmp = (x * (9.0 / (c / y))) / z;
elseif (x <= -1e-164)
tmp = t_1;
elseif (x <= -1.15e-218)
tmp = -4.0 * (t * (a / c));
elseif (x <= -3.9e-286)
tmp = (b / z) / c;
elseif (x <= 5.3e-253)
tmp = -4.0 * (a / (c / t));
elseif (x <= 2.6e-122)
tmp = t_1;
elseif (x <= 1.06e-89)
tmp = (a * -4.0) * (t / c);
else
tmp = (x * (y / z)) * (9.0 / c);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision]}, If[LessEqual[x, -1.05e+29], N[(N[(x * N[(9.0 / N[(c / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[x, -1e-164], t$95$1, If[LessEqual[x, -1.15e-218], N[(-4.0 * N[(t * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.9e-286], N[(N[(b / z), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[x, 5.3e-253], N[(-4.0 * N[(a / N[(c / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.6e-122], t$95$1, If[LessEqual[x, 1.06e-89], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision] * N[(9.0 / c), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \frac{\frac{b}{c}}{z}\\
\mathbf{if}\;x \leq -1.05 \cdot 10^{+29}:\\
\;\;\;\;\frac{x \cdot \frac{9}{\frac{c}{y}}}{z}\\
\mathbf{elif}\;x \leq -1 \cdot 10^{-164}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq -1.15 \cdot 10^{-218}:\\
\;\;\;\;-4 \cdot \left(t \cdot \frac{a}{c}\right)\\
\mathbf{elif}\;x \leq -3.9 \cdot 10^{-286}:\\
\;\;\;\;\frac{\frac{b}{z}}{c}\\
\mathbf{elif}\;x \leq 5.3 \cdot 10^{-253}:\\
\;\;\;\;-4 \cdot \frac{a}{\frac{c}{t}}\\
\mathbf{elif}\;x \leq 2.6 \cdot 10^{-122}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 1.06 \cdot 10^{-89}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot \frac{y}{z}\right) \cdot \frac{9}{c}\\
\end{array}
\end{array}
if x < -1.0500000000000001e29Initial program 67.6%
associate-*l*67.6%
associate-*l*67.6%
Simplified67.6%
Taylor expanded in x around inf 41.6%
associate-*r/41.6%
associate-*r*41.6%
times-frac55.7%
*-commutative55.7%
Simplified55.7%
associate-*l/57.5%
associate-/l*57.5%
Applied egg-rr57.5%
if -1.0500000000000001e29 < x < -9.99999999999999962e-165 or 5.3000000000000002e-253 < x < 2.59999999999999975e-122Initial program 89.3%
associate-*l*89.3%
associate-*l*87.8%
Simplified87.8%
Taylor expanded in b around inf 50.8%
associate-/r*52.2%
Simplified52.2%
if -9.99999999999999962e-165 < x < -1.14999999999999997e-218Initial program 89.1%
associate-*l*89.3%
associate-*l*89.3%
Simplified89.3%
Taylor expanded in z around inf 37.9%
*-commutative37.9%
associate-/l*38.1%
associate-/r/37.9%
Simplified37.9%
if -1.14999999999999997e-218 < x < -3.89999999999999995e-286Initial program 55.4%
associate-/r*73.0%
Simplified91.0%
Taylor expanded in x around 0 91.0%
associate-*r*91.0%
*-commutative91.0%
*-commutative91.0%
Simplified91.0%
Taylor expanded in b around inf 38.0%
if -3.89999999999999995e-286 < x < 5.3000000000000002e-253Initial program 80.3%
associate-*l*80.3%
associate-*l*91.7%
Simplified91.7%
Taylor expanded in z around inf 41.5%
*-commutative41.5%
associate-/l*38.1%
Simplified38.1%
if 2.59999999999999975e-122 < x < 1.0600000000000001e-89Initial program 67.0%
associate-/r*67.6%
Simplified83.9%
div-inv83.9%
+-commutative83.9%
fma-def83.9%
Applied egg-rr83.9%
Taylor expanded in t around inf 36.6%
associate-*r/36.6%
associate-*r*36.6%
*-commutative36.6%
*-commutative36.6%
associate-*l/52.7%
*-commutative52.7%
*-commutative52.7%
Simplified52.7%
if 1.0600000000000001e-89 < x Initial program 76.7%
associate-/r*73.6%
Simplified83.2%
div-inv83.1%
+-commutative83.1%
fma-def83.1%
Applied egg-rr83.1%
Taylor expanded in x around inf 49.9%
associate-*r/49.9%
*-commutative49.9%
*-commutative49.9%
*-commutative49.9%
times-frac47.7%
*-commutative47.7%
associate-/l*54.7%
associate-/r/54.8%
Simplified54.8%
Final simplification51.6%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (/ b c) z)))
(if (<= x -2.7e+28)
(/ (* 9.0 (/ y (/ c x))) z)
(if (<= x -1.1e-164)
t_1
(if (<= x -4.8e-219)
(* -4.0 (* t (/ a c)))
(if (<= x -4.5e-285)
(/ (/ b z) c)
(if (<= x 1e-249)
(* -4.0 (/ a (/ c t)))
(if (<= x 2.5e-122)
t_1
(if (<= x 1.9e-90)
(* (* a -4.0) (/ t c))
(* (* x (/ y z)) (/ 9.0 c)))))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b / c) / z;
double tmp;
if (x <= -2.7e+28) {
tmp = (9.0 * (y / (c / x))) / z;
} else if (x <= -1.1e-164) {
tmp = t_1;
} else if (x <= -4.8e-219) {
tmp = -4.0 * (t * (a / c));
} else if (x <= -4.5e-285) {
tmp = (b / z) / c;
} else if (x <= 1e-249) {
tmp = -4.0 * (a / (c / t));
} else if (x <= 2.5e-122) {
tmp = t_1;
} else if (x <= 1.9e-90) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = (x * (y / z)) * (9.0 / c);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: tmp
t_1 = (b / c) / z
if (x <= (-2.7d+28)) then
tmp = (9.0d0 * (y / (c / x))) / z
else if (x <= (-1.1d-164)) then
tmp = t_1
else if (x <= (-4.8d-219)) then
tmp = (-4.0d0) * (t * (a / c))
else if (x <= (-4.5d-285)) then
tmp = (b / z) / c
else if (x <= 1d-249) then
tmp = (-4.0d0) * (a / (c / t))
else if (x <= 2.5d-122) then
tmp = t_1
else if (x <= 1.9d-90) then
tmp = (a * (-4.0d0)) * (t / c)
else
tmp = (x * (y / z)) * (9.0d0 / c)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b / c) / z;
double tmp;
if (x <= -2.7e+28) {
tmp = (9.0 * (y / (c / x))) / z;
} else if (x <= -1.1e-164) {
tmp = t_1;
} else if (x <= -4.8e-219) {
tmp = -4.0 * (t * (a / c));
} else if (x <= -4.5e-285) {
tmp = (b / z) / c;
} else if (x <= 1e-249) {
tmp = -4.0 * (a / (c / t));
} else if (x <= 2.5e-122) {
tmp = t_1;
} else if (x <= 1.9e-90) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = (x * (y / z)) * (9.0 / c);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = (b / c) / z tmp = 0 if x <= -2.7e+28: tmp = (9.0 * (y / (c / x))) / z elif x <= -1.1e-164: tmp = t_1 elif x <= -4.8e-219: tmp = -4.0 * (t * (a / c)) elif x <= -4.5e-285: tmp = (b / z) / c elif x <= 1e-249: tmp = -4.0 * (a / (c / t)) elif x <= 2.5e-122: tmp = t_1 elif x <= 1.9e-90: tmp = (a * -4.0) * (t / c) else: tmp = (x * (y / z)) * (9.0 / c) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(b / c) / z) tmp = 0.0 if (x <= -2.7e+28) tmp = Float64(Float64(9.0 * Float64(y / Float64(c / x))) / z); elseif (x <= -1.1e-164) tmp = t_1; elseif (x <= -4.8e-219) tmp = Float64(-4.0 * Float64(t * Float64(a / c))); elseif (x <= -4.5e-285) tmp = Float64(Float64(b / z) / c); elseif (x <= 1e-249) tmp = Float64(-4.0 * Float64(a / Float64(c / t))); elseif (x <= 2.5e-122) tmp = t_1; elseif (x <= 1.9e-90) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); else tmp = Float64(Float64(x * Float64(y / z)) * Float64(9.0 / c)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = (b / c) / z;
tmp = 0.0;
if (x <= -2.7e+28)
tmp = (9.0 * (y / (c / x))) / z;
elseif (x <= -1.1e-164)
tmp = t_1;
elseif (x <= -4.8e-219)
tmp = -4.0 * (t * (a / c));
elseif (x <= -4.5e-285)
tmp = (b / z) / c;
elseif (x <= 1e-249)
tmp = -4.0 * (a / (c / t));
elseif (x <= 2.5e-122)
tmp = t_1;
elseif (x <= 1.9e-90)
tmp = (a * -4.0) * (t / c);
else
tmp = (x * (y / z)) * (9.0 / c);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision]}, If[LessEqual[x, -2.7e+28], N[(N[(9.0 * N[(y / N[(c / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[x, -1.1e-164], t$95$1, If[LessEqual[x, -4.8e-219], N[(-4.0 * N[(t * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4.5e-285], N[(N[(b / z), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[x, 1e-249], N[(-4.0 * N[(a / N[(c / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.5e-122], t$95$1, If[LessEqual[x, 1.9e-90], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision] * N[(9.0 / c), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \frac{\frac{b}{c}}{z}\\
\mathbf{if}\;x \leq -2.7 \cdot 10^{+28}:\\
\;\;\;\;\frac{9 \cdot \frac{y}{\frac{c}{x}}}{z}\\
\mathbf{elif}\;x \leq -1.1 \cdot 10^{-164}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq -4.8 \cdot 10^{-219}:\\
\;\;\;\;-4 \cdot \left(t \cdot \frac{a}{c}\right)\\
\mathbf{elif}\;x \leq -4.5 \cdot 10^{-285}:\\
\;\;\;\;\frac{\frac{b}{z}}{c}\\
\mathbf{elif}\;x \leq 10^{-249}:\\
\;\;\;\;-4 \cdot \frac{a}{\frac{c}{t}}\\
\mathbf{elif}\;x \leq 2.5 \cdot 10^{-122}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 1.9 \cdot 10^{-90}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot \frac{y}{z}\right) \cdot \frac{9}{c}\\
\end{array}
\end{array}
if x < -2.7000000000000002e28Initial program 67.6%
associate-*l*67.6%
associate-*l*67.6%
Simplified67.6%
Taylor expanded in x around inf 41.6%
*-commutative41.6%
associate-/r*46.1%
associate-*l/46.2%
associate-/l*57.4%
Simplified57.4%
if -2.7000000000000002e28 < x < -1.09999999999999994e-164 or 1.00000000000000005e-249 < x < 2.4999999999999999e-122Initial program 89.3%
associate-*l*89.3%
associate-*l*87.8%
Simplified87.8%
Taylor expanded in b around inf 50.8%
associate-/r*52.2%
Simplified52.2%
if -1.09999999999999994e-164 < x < -4.80000000000000028e-219Initial program 89.1%
associate-*l*89.3%
associate-*l*89.3%
Simplified89.3%
Taylor expanded in z around inf 37.9%
*-commutative37.9%
associate-/l*38.1%
associate-/r/37.9%
Simplified37.9%
if -4.80000000000000028e-219 < x < -4.5000000000000002e-285Initial program 55.4%
associate-/r*73.0%
Simplified91.0%
Taylor expanded in x around 0 91.0%
associate-*r*91.0%
*-commutative91.0%
*-commutative91.0%
Simplified91.0%
Taylor expanded in b around inf 38.0%
if -4.5000000000000002e-285 < x < 1.00000000000000005e-249Initial program 80.3%
associate-*l*80.3%
associate-*l*91.7%
Simplified91.7%
Taylor expanded in z around inf 41.5%
*-commutative41.5%
associate-/l*38.1%
Simplified38.1%
if 2.4999999999999999e-122 < x < 1.9e-90Initial program 67.0%
associate-/r*67.6%
Simplified83.9%
div-inv83.9%
+-commutative83.9%
fma-def83.9%
Applied egg-rr83.9%
Taylor expanded in t around inf 36.6%
associate-*r/36.6%
associate-*r*36.6%
*-commutative36.6%
*-commutative36.6%
associate-*l/52.7%
*-commutative52.7%
*-commutative52.7%
Simplified52.7%
if 1.9e-90 < x Initial program 76.7%
associate-/r*73.6%
Simplified83.2%
div-inv83.1%
+-commutative83.1%
fma-def83.1%
Applied egg-rr83.1%
Taylor expanded in x around inf 49.9%
associate-*r/49.9%
*-commutative49.9%
*-commutative49.9%
*-commutative49.9%
times-frac47.7%
*-commutative47.7%
associate-/l*54.7%
associate-/r/54.8%
Simplified54.8%
Final simplification51.6%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(if (<= z -7.6e+202)
(* (* a -4.0) (/ t c))
(if (<= z 5.2e+143)
(/ (+ b (- (* x (* 9.0 y)) (* 4.0 (* t (* z a))))) (* c z))
(/ (+ (* t (* a -4.0)) (/ b z)) c))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (z <= -7.6e+202) {
tmp = (a * -4.0) * (t / c);
} else if (z <= 5.2e+143) {
tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z);
} else {
tmp = ((t * (a * -4.0)) + (b / z)) / c;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (z <= (-7.6d+202)) then
tmp = (a * (-4.0d0)) * (t / c)
else if (z <= 5.2d+143) then
tmp = (b + ((x * (9.0d0 * y)) - (4.0d0 * (t * (z * a))))) / (c * z)
else
tmp = ((t * (a * (-4.0d0))) + (b / z)) / c
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (z <= -7.6e+202) {
tmp = (a * -4.0) * (t / c);
} else if (z <= 5.2e+143) {
tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z);
} else {
tmp = ((t * (a * -4.0)) + (b / z)) / c;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): tmp = 0 if z <= -7.6e+202: tmp = (a * -4.0) * (t / c) elif z <= 5.2e+143: tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z) else: tmp = ((t * (a * -4.0)) + (b / z)) / c return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) tmp = 0.0 if (z <= -7.6e+202) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); elseif (z <= 5.2e+143) tmp = Float64(Float64(b + Float64(Float64(x * Float64(9.0 * y)) - Float64(4.0 * Float64(t * Float64(z * a))))) / Float64(c * z)); else tmp = Float64(Float64(Float64(t * Float64(a * -4.0)) + Float64(b / z)) / c); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
tmp = 0.0;
if (z <= -7.6e+202)
tmp = (a * -4.0) * (t / c);
elseif (z <= 5.2e+143)
tmp = (b + ((x * (9.0 * y)) - (4.0 * (t * (z * a))))) / (c * z);
else
tmp = ((t * (a * -4.0)) + (b / z)) / c;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[z, -7.6e+202], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.2e+143], N[(N[(b + N[(N[(x * N[(9.0 * y), $MachinePrecision]), $MachinePrecision] - N[(4.0 * N[(t * N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] + N[(b / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.6 \cdot 10^{+202}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{+143}:\\
\;\;\;\;\frac{b + \left(x \cdot \left(9 \cdot y\right) - 4 \cdot \left(t \cdot \left(z \cdot a\right)\right)\right)}{c \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot \left(a \cdot -4\right) + \frac{b}{z}}{c}\\
\end{array}
\end{array}
if z < -7.6000000000000001e202Initial program 36.3%
associate-/r*48.5%
Simplified82.8%
div-inv82.7%
+-commutative82.7%
fma-def82.7%
Applied egg-rr82.7%
Taylor expanded in t around inf 71.9%
associate-*r/71.9%
associate-*r*71.9%
*-commutative71.9%
*-commutative71.9%
associate-*l/75.5%
*-commutative75.5%
*-commutative75.5%
Simplified75.5%
if -7.6000000000000001e202 < z < 5.1999999999999998e143Initial program 87.3%
associate-*l*87.3%
associate-*l*86.8%
Simplified86.8%
Taylor expanded in z around 0 87.3%
associate-*r*86.8%
*-commutative86.8%
associate-*l*87.8%
Simplified87.8%
if 5.1999999999999998e143 < z Initial program 57.3%
associate-/r*68.0%
Simplified91.5%
Taylor expanded in x around 0 81.9%
associate-*r*81.9%
*-commutative81.9%
*-commutative81.9%
Simplified81.9%
Final simplification85.6%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (+ b (* 9.0 (* x y))) (* c z))))
(if (<= a -205.0)
(* (* a -4.0) (/ t c))
(if (<= a 7e+92)
t_1
(if (<= a 3.5e+146)
(* (* t (* a -4.0)) (/ 1.0 c))
(if (<= a 5.4e+162) t_1 (* -4.0 (/ a (/ c t)))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b + (9.0 * (x * y))) / (c * z);
double tmp;
if (a <= -205.0) {
tmp = (a * -4.0) * (t / c);
} else if (a <= 7e+92) {
tmp = t_1;
} else if (a <= 3.5e+146) {
tmp = (t * (a * -4.0)) * (1.0 / c);
} else if (a <= 5.4e+162) {
tmp = t_1;
} else {
tmp = -4.0 * (a / (c / t));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: tmp
t_1 = (b + (9.0d0 * (x * y))) / (c * z)
if (a <= (-205.0d0)) then
tmp = (a * (-4.0d0)) * (t / c)
else if (a <= 7d+92) then
tmp = t_1
else if (a <= 3.5d+146) then
tmp = (t * (a * (-4.0d0))) * (1.0d0 / c)
else if (a <= 5.4d+162) then
tmp = t_1
else
tmp = (-4.0d0) * (a / (c / t))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (b + (9.0 * (x * y))) / (c * z);
double tmp;
if (a <= -205.0) {
tmp = (a * -4.0) * (t / c);
} else if (a <= 7e+92) {
tmp = t_1;
} else if (a <= 3.5e+146) {
tmp = (t * (a * -4.0)) * (1.0 / c);
} else if (a <= 5.4e+162) {
tmp = t_1;
} else {
tmp = -4.0 * (a / (c / t));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = (b + (9.0 * (x * y))) / (c * z) tmp = 0 if a <= -205.0: tmp = (a * -4.0) * (t / c) elif a <= 7e+92: tmp = t_1 elif a <= 3.5e+146: tmp = (t * (a * -4.0)) * (1.0 / c) elif a <= 5.4e+162: tmp = t_1 else: tmp = -4.0 * (a / (c / t)) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(b + Float64(9.0 * Float64(x * y))) / Float64(c * z)) tmp = 0.0 if (a <= -205.0) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); elseif (a <= 7e+92) tmp = t_1; elseif (a <= 3.5e+146) tmp = Float64(Float64(t * Float64(a * -4.0)) * Float64(1.0 / c)); elseif (a <= 5.4e+162) tmp = t_1; else tmp = Float64(-4.0 * Float64(a / Float64(c / t))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = (b + (9.0 * (x * y))) / (c * z);
tmp = 0.0;
if (a <= -205.0)
tmp = (a * -4.0) * (t / c);
elseif (a <= 7e+92)
tmp = t_1;
elseif (a <= 3.5e+146)
tmp = (t * (a * -4.0)) * (1.0 / c);
elseif (a <= 5.4e+162)
tmp = t_1;
else
tmp = -4.0 * (a / (c / t));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b + N[(9.0 * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -205.0], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 7e+92], t$95$1, If[LessEqual[a, 3.5e+146], N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.4e+162], t$95$1, N[(-4.0 * N[(a / N[(c / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \frac{b + 9 \cdot \left(x \cdot y\right)}{c \cdot z}\\
\mathbf{if}\;a \leq -205:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{elif}\;a \leq 7 \cdot 10^{+92}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 3.5 \cdot 10^{+146}:\\
\;\;\;\;\left(t \cdot \left(a \cdot -4\right)\right) \cdot \frac{1}{c}\\
\mathbf{elif}\;a \leq 5.4 \cdot 10^{+162}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;-4 \cdot \frac{a}{\frac{c}{t}}\\
\end{array}
\end{array}
if a < -205Initial program 74.2%
associate-/r*71.7%
Simplified79.1%
div-inv79.0%
+-commutative79.0%
fma-def79.1%
Applied egg-rr79.1%
Taylor expanded in t around inf 43.1%
associate-*r/43.1%
associate-*r*43.1%
*-commutative43.1%
*-commutative43.1%
associate-*l/48.9%
*-commutative48.9%
*-commutative48.9%
Simplified48.9%
if -205 < a < 6.99999999999999972e92 or 3.5000000000000001e146 < a < 5.4000000000000003e162Initial program 80.7%
associate-*l*81.3%
associate-*l*85.1%
Simplified85.1%
Taylor expanded in x around inf 71.0%
if 6.99999999999999972e92 < a < 3.5000000000000001e146Initial program 79.2%
associate-/r*68.8%
Simplified78.2%
Taylor expanded in z around inf 46.3%
associate-*r*46.3%
*-commutative46.3%
*-commutative46.3%
Simplified46.3%
div-inv46.5%
Applied egg-rr46.5%
if 5.4000000000000003e162 < a Initial program 68.4%
associate-*l*68.4%
associate-*l*65.4%
Simplified65.4%
Taylor expanded in z around inf 77.4%
*-commutative77.4%
associate-/l*74.6%
Simplified74.6%
Final simplification65.1%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* 9.0 (/ (* x y) (* c z)))))
(if (<= b -6.4e+49)
(/ (/ b z) c)
(if (<= b -3.2e-194)
t_1
(if (<= b -2.3e-264)
(* -4.0 (/ a (/ c t)))
(if (<= b -2.4e-293)
t_1
(if (<= b 3e+69) (* (* a -4.0) (/ t c)) (/ b (* c z)))))))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 9.0 * ((x * y) / (c * z));
double tmp;
if (b <= -6.4e+49) {
tmp = (b / z) / c;
} else if (b <= -3.2e-194) {
tmp = t_1;
} else if (b <= -2.3e-264) {
tmp = -4.0 * (a / (c / t));
} else if (b <= -2.4e-293) {
tmp = t_1;
} else if (b <= 3e+69) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = b / (c * z);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: tmp
t_1 = 9.0d0 * ((x * y) / (c * z))
if (b <= (-6.4d+49)) then
tmp = (b / z) / c
else if (b <= (-3.2d-194)) then
tmp = t_1
else if (b <= (-2.3d-264)) then
tmp = (-4.0d0) * (a / (c / t))
else if (b <= (-2.4d-293)) then
tmp = t_1
else if (b <= 3d+69) then
tmp = (a * (-4.0d0)) * (t / c)
else
tmp = b / (c * z)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 9.0 * ((x * y) / (c * z));
double tmp;
if (b <= -6.4e+49) {
tmp = (b / z) / c;
} else if (b <= -3.2e-194) {
tmp = t_1;
} else if (b <= -2.3e-264) {
tmp = -4.0 * (a / (c / t));
} else if (b <= -2.4e-293) {
tmp = t_1;
} else if (b <= 3e+69) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = b / (c * z);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = 9.0 * ((x * y) / (c * z)) tmp = 0 if b <= -6.4e+49: tmp = (b / z) / c elif b <= -3.2e-194: tmp = t_1 elif b <= -2.3e-264: tmp = -4.0 * (a / (c / t)) elif b <= -2.4e-293: tmp = t_1 elif b <= 3e+69: tmp = (a * -4.0) * (t / c) else: tmp = b / (c * z) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(9.0 * Float64(Float64(x * y) / Float64(c * z))) tmp = 0.0 if (b <= -6.4e+49) tmp = Float64(Float64(b / z) / c); elseif (b <= -3.2e-194) tmp = t_1; elseif (b <= -2.3e-264) tmp = Float64(-4.0 * Float64(a / Float64(c / t))); elseif (b <= -2.4e-293) tmp = t_1; elseif (b <= 3e+69) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); else tmp = Float64(b / Float64(c * z)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = 9.0 * ((x * y) / (c * z));
tmp = 0.0;
if (b <= -6.4e+49)
tmp = (b / z) / c;
elseif (b <= -3.2e-194)
tmp = t_1;
elseif (b <= -2.3e-264)
tmp = -4.0 * (a / (c / t));
elseif (b <= -2.4e-293)
tmp = t_1;
elseif (b <= 3e+69)
tmp = (a * -4.0) * (t / c);
else
tmp = b / (c * z);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(9.0 * N[(N[(x * y), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6.4e+49], N[(N[(b / z), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[b, -3.2e-194], t$95$1, If[LessEqual[b, -2.3e-264], N[(-4.0 * N[(a / N[(c / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -2.4e-293], t$95$1, If[LessEqual[b, 3e+69], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := 9 \cdot \frac{x \cdot y}{c \cdot z}\\
\mathbf{if}\;b \leq -6.4 \cdot 10^{+49}:\\
\;\;\;\;\frac{\frac{b}{z}}{c}\\
\mathbf{elif}\;b \leq -3.2 \cdot 10^{-194}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -2.3 \cdot 10^{-264}:\\
\;\;\;\;-4 \cdot \frac{a}{\frac{c}{t}}\\
\mathbf{elif}\;b \leq -2.4 \cdot 10^{-293}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 3 \cdot 10^{+69}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{else}:\\
\;\;\;\;\frac{b}{c \cdot z}\\
\end{array}
\end{array}
if b < -6.40000000000000028e49Initial program 80.0%
associate-/r*81.7%
Simplified90.5%
Taylor expanded in x around 0 76.3%
associate-*r*76.3%
*-commutative76.3%
*-commutative76.3%
Simplified76.3%
Taylor expanded in b around inf 55.1%
if -6.40000000000000028e49 < b < -3.2000000000000003e-194 or -2.30000000000000012e-264 < b < -2.3999999999999999e-293Initial program 81.8%
associate-*l*81.8%
associate-*l*81.7%
Simplified81.7%
Taylor expanded in x around inf 55.7%
if -3.2000000000000003e-194 < b < -2.30000000000000012e-264Initial program 73.3%
associate-*l*73.3%
associate-*l*79.7%
Simplified79.7%
Taylor expanded in z around inf 67.3%
*-commutative67.3%
associate-/l*67.4%
Simplified67.4%
if -2.3999999999999999e-293 < b < 2.99999999999999983e69Initial program 74.9%
associate-/r*77.3%
Simplified89.7%
div-inv89.7%
+-commutative89.7%
fma-def89.7%
Applied egg-rr89.7%
Taylor expanded in t around inf 50.8%
associate-*r/50.8%
associate-*r*50.8%
*-commutative50.8%
*-commutative50.8%
associate-*l/48.5%
*-commutative48.5%
*-commutative48.5%
Simplified48.5%
if 2.99999999999999983e69 < b Initial program 75.6%
associate-*l*75.6%
associate-*l*79.3%
Simplified79.3%
Taylor expanded in b around inf 59.6%
Final simplification54.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* t (* a -4.0))))
(if (<= x -2.5e+37)
(/ (+ t_1 (* 9.0 (/ (* x y) z))) c)
(if (<= x 4.5e-90)
(/ (+ t_1 (/ b z)) c)
(/ (+ (/ b z) (* 9.0 (/ y (/ z x)))) c)))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = t * (a * -4.0);
double tmp;
if (x <= -2.5e+37) {
tmp = (t_1 + (9.0 * ((x * y) / z))) / c;
} else if (x <= 4.5e-90) {
tmp = (t_1 + (b / z)) / c;
} else {
tmp = ((b / z) + (9.0 * (y / (z / x)))) / c;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: tmp
t_1 = t * (a * (-4.0d0))
if (x <= (-2.5d+37)) then
tmp = (t_1 + (9.0d0 * ((x * y) / z))) / c
else if (x <= 4.5d-90) then
tmp = (t_1 + (b / z)) / c
else
tmp = ((b / z) + (9.0d0 * (y / (z / x)))) / c
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = t * (a * -4.0);
double tmp;
if (x <= -2.5e+37) {
tmp = (t_1 + (9.0 * ((x * y) / z))) / c;
} else if (x <= 4.5e-90) {
tmp = (t_1 + (b / z)) / c;
} else {
tmp = ((b / z) + (9.0 * (y / (z / x)))) / c;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): t_1 = t * (a * -4.0) tmp = 0 if x <= -2.5e+37: tmp = (t_1 + (9.0 * ((x * y) / z))) / c elif x <= 4.5e-90: tmp = (t_1 + (b / z)) / c else: tmp = ((b / z) + (9.0 * (y / (z / x)))) / c return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) t_1 = Float64(t * Float64(a * -4.0)) tmp = 0.0 if (x <= -2.5e+37) tmp = Float64(Float64(t_1 + Float64(9.0 * Float64(Float64(x * y) / z))) / c); elseif (x <= 4.5e-90) tmp = Float64(Float64(t_1 + Float64(b / z)) / c); else tmp = Float64(Float64(Float64(b / z) + Float64(9.0 * Float64(y / Float64(z / x)))) / c); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
t_1 = t * (a * -4.0);
tmp = 0.0;
if (x <= -2.5e+37)
tmp = (t_1 + (9.0 * ((x * y) / z))) / c;
elseif (x <= 4.5e-90)
tmp = (t_1 + (b / z)) / c;
else
tmp = ((b / z) + (9.0 * (y / (z / x)))) / c;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.5e+37], N[(N[(t$95$1 + N[(9.0 * N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[x, 4.5e-90], N[(N[(t$95$1 + N[(b / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], N[(N[(N[(b / z), $MachinePrecision] + N[(9.0 * N[(y / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := t \cdot \left(a \cdot -4\right)\\
\mathbf{if}\;x \leq -2.5 \cdot 10^{+37}:\\
\;\;\;\;\frac{t_1 + 9 \cdot \frac{x \cdot y}{z}}{c}\\
\mathbf{elif}\;x \leq 4.5 \cdot 10^{-90}:\\
\;\;\;\;\frac{t_1 + \frac{b}{z}}{c}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{b}{z} + 9 \cdot \frac{y}{\frac{z}{x}}}{c}\\
\end{array}
\end{array}
if x < -2.49999999999999994e37Initial program 65.9%
associate-/r*72.5%
Simplified77.6%
Taylor expanded in x around inf 67.6%
if -2.49999999999999994e37 < x < 4.50000000000000009e-90Initial program 83.4%
associate-/r*80.6%
Simplified90.1%
Taylor expanded in x around 0 81.4%
associate-*r*81.4%
*-commutative81.4%
*-commutative81.4%
Simplified81.4%
if 4.50000000000000009e-90 < x Initial program 76.7%
associate-/r*73.6%
Simplified83.2%
Taylor expanded in t around 0 64.5%
associate-/l*70.3%
Simplified70.3%
Final simplification74.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c)
:precision binary64
(if (<= a -200.0)
(* (* a -4.0) (/ t c))
(if (<= a 2.7e+67)
(/ (+ b (* 9.0 (* x y))) (* c z))
(/ (+ (* t (* a -4.0)) (/ b z)) c))))assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (a <= -200.0) {
tmp = (a * -4.0) * (t / c);
} else if (a <= 2.7e+67) {
tmp = (b + (9.0 * (x * y))) / (c * z);
} else {
tmp = ((t * (a * -4.0)) + (b / z)) / c;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (a <= (-200.0d0)) then
tmp = (a * (-4.0d0)) * (t / c)
else if (a <= 2.7d+67) then
tmp = (b + (9.0d0 * (x * y))) / (c * z)
else
tmp = ((t * (a * (-4.0d0))) + (b / z)) / c
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (a <= -200.0) {
tmp = (a * -4.0) * (t / c);
} else if (a <= 2.7e+67) {
tmp = (b + (9.0 * (x * y))) / (c * z);
} else {
tmp = ((t * (a * -4.0)) + (b / z)) / c;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): tmp = 0 if a <= -200.0: tmp = (a * -4.0) * (t / c) elif a <= 2.7e+67: tmp = (b + (9.0 * (x * y))) / (c * z) else: tmp = ((t * (a * -4.0)) + (b / z)) / c return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) tmp = 0.0 if (a <= -200.0) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); elseif (a <= 2.7e+67) tmp = Float64(Float64(b + Float64(9.0 * Float64(x * y))) / Float64(c * z)); else tmp = Float64(Float64(Float64(t * Float64(a * -4.0)) + Float64(b / z)) / c); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
tmp = 0.0;
if (a <= -200.0)
tmp = (a * -4.0) * (t / c);
elseif (a <= 2.7e+67)
tmp = (b + (9.0 * (x * y))) / (c * z);
else
tmp = ((t * (a * -4.0)) + (b / z)) / c;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[a, -200.0], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.7e+67], N[(N[(b + N[(9.0 * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] + N[(b / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -200:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{+67}:\\
\;\;\;\;\frac{b + 9 \cdot \left(x \cdot y\right)}{c \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot \left(a \cdot -4\right) + \frac{b}{z}}{c}\\
\end{array}
\end{array}
if a < -200Initial program 74.2%
associate-/r*71.7%
Simplified79.1%
div-inv79.0%
+-commutative79.0%
fma-def79.1%
Applied egg-rr79.1%
Taylor expanded in t around inf 43.1%
associate-*r/43.1%
associate-*r*43.1%
*-commutative43.1%
*-commutative43.1%
associate-*l/48.9%
*-commutative48.9%
*-commutative48.9%
Simplified48.9%
if -200 < a < 2.6999999999999999e67Initial program 82.9%
associate-*l*83.0%
associate-*l*87.2%
Simplified87.2%
Taylor expanded in x around inf 74.3%
if 2.6999999999999999e67 < a Initial program 67.6%
associate-/r*64.5%
Simplified78.5%
Taylor expanded in x around 0 74.6%
associate-*r*74.6%
*-commutative74.6%
*-commutative74.6%
Simplified74.6%
Final simplification68.0%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a b c) :precision binary64 (if (<= b -4.3e+38) (/ (/ b z) c) (if (<= b 4e+68) (* (* a -4.0) (/ t c)) (/ b (* c z)))))
assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (b <= -4.3e+38) {
tmp = (b / z) / c;
} else if (b <= 4e+68) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = b / (c * z);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= (-4.3d+38)) then
tmp = (b / z) / c
else if (b <= 4d+68) then
tmp = (a * (-4.0d0)) * (t / c)
else
tmp = b / (c * z)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (b <= -4.3e+38) {
tmp = (b / z) / c;
} else if (b <= 4e+68) {
tmp = (a * -4.0) * (t / c);
} else {
tmp = b / (c * z);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): tmp = 0 if b <= -4.3e+38: tmp = (b / z) / c elif b <= 4e+68: tmp = (a * -4.0) * (t / c) else: tmp = b / (c * z) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) tmp = 0.0 if (b <= -4.3e+38) tmp = Float64(Float64(b / z) / c); elseif (b <= 4e+68) tmp = Float64(Float64(a * -4.0) * Float64(t / c)); else tmp = Float64(b / Float64(c * z)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a, b, c)
tmp = 0.0;
if (b <= -4.3e+38)
tmp = (b / z) / c;
elseif (b <= 4e+68)
tmp = (a * -4.0) * (t / c);
else
tmp = b / (c * z);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[b, -4.3e+38], N[(N[(b / z), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[b, 4e+68], N[(N[(a * -4.0), $MachinePrecision] * N[(t / c), $MachinePrecision]), $MachinePrecision], N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4.3 \cdot 10^{+38}:\\
\;\;\;\;\frac{\frac{b}{z}}{c}\\
\mathbf{elif}\;b \leq 4 \cdot 10^{+68}:\\
\;\;\;\;\left(a \cdot -4\right) \cdot \frac{t}{c}\\
\mathbf{else}:\\
\;\;\;\;\frac{b}{c \cdot z}\\
\end{array}
\end{array}
if b < -4.2999999999999997e38Initial program 79.7%
associate-/r*81.2%
Simplified91.0%
Taylor expanded in x around 0 74.7%
associate-*r*74.7%
*-commutative74.7%
*-commutative74.7%
Simplified74.7%
Taylor expanded in b around inf 54.8%
if -4.2999999999999997e38 < b < 3.99999999999999981e68Initial program 77.1%
associate-/r*76.4%
Simplified84.2%
div-inv84.2%
+-commutative84.2%
fma-def84.9%
Applied egg-rr84.9%
Taylor expanded in t around inf 45.5%
associate-*r/45.5%
associate-*r*45.5%
*-commutative45.5%
*-commutative45.5%
associate-*l/44.9%
*-commutative44.9%
*-commutative44.9%
Simplified44.9%
if 3.99999999999999981e68 < b Initial program 75.6%
associate-*l*75.6%
associate-*l*79.3%
Simplified79.3%
Taylor expanded in b around inf 59.6%
Final simplification50.5%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a b c) :precision binary64 (/ b (* c z)))
assert(x < y);
double code(double x, double y, double z, double t, double a, double b, double c) {
return b / (c * z);
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
code = b / (c * z)
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return b / (c * z);
}
[x, y] = sort([x, y]) def code(x, y, z, t, a, b, c): return b / (c * z)
x, y = sort([x, y]) function code(x, y, z, t, a, b, c) return Float64(b / Float64(c * z)) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z, t, a, b, c)
tmp = b / (c * z);
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_] := N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{b}{c \cdot z}
\end{array}
Initial program 77.5%
associate-*l*77.9%
associate-*l*79.0%
Simplified79.0%
Taylor expanded in b around inf 35.6%
Final simplification35.6%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ b (* c z)))
(t_2 (* 4.0 (/ (* a t) c)))
(t_3 (* (* x 9.0) y))
(t_4 (+ (- t_3 (* (* (* z 4.0) t) a)) b))
(t_5 (/ t_4 (* z c)))
(t_6 (/ (+ (- t_3 (* (* z 4.0) (* t a))) b) (* z c))))
(if (< t_5 -1.100156740804105e-171)
t_6
(if (< t_5 0.0)
(/ (/ t_4 z) c)
(if (< t_5 1.1708877911747488e-53)
t_6
(if (< t_5 2.876823679546137e+130)
(- (+ (* (* 9.0 (/ y c)) (/ x z)) t_1) t_2)
(if (< t_5 1.3838515042456319e+158)
t_6
(- (+ (* 9.0 (* (/ y (* c z)) x)) t_1) t_2))))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = b / (c * z);
double t_2 = 4.0 * ((a * t) / c);
double t_3 = (x * 9.0) * y;
double t_4 = (t_3 - (((z * 4.0) * t) * a)) + b;
double t_5 = t_4 / (z * c);
double t_6 = ((t_3 - ((z * 4.0) * (t * a))) + b) / (z * c);
double tmp;
if (t_5 < -1.100156740804105e-171) {
tmp = t_6;
} else if (t_5 < 0.0) {
tmp = (t_4 / z) / c;
} else if (t_5 < 1.1708877911747488e-53) {
tmp = t_6;
} else if (t_5 < 2.876823679546137e+130) {
tmp = (((9.0 * (y / c)) * (x / z)) + t_1) - t_2;
} else if (t_5 < 1.3838515042456319e+158) {
tmp = t_6;
} else {
tmp = ((9.0 * ((y / (c * z)) * x)) + t_1) - t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: t_6
real(8) :: tmp
t_1 = b / (c * z)
t_2 = 4.0d0 * ((a * t) / c)
t_3 = (x * 9.0d0) * y
t_4 = (t_3 - (((z * 4.0d0) * t) * a)) + b
t_5 = t_4 / (z * c)
t_6 = ((t_3 - ((z * 4.0d0) * (t * a))) + b) / (z * c)
if (t_5 < (-1.100156740804105d-171)) then
tmp = t_6
else if (t_5 < 0.0d0) then
tmp = (t_4 / z) / c
else if (t_5 < 1.1708877911747488d-53) then
tmp = t_6
else if (t_5 < 2.876823679546137d+130) then
tmp = (((9.0d0 * (y / c)) * (x / z)) + t_1) - t_2
else if (t_5 < 1.3838515042456319d+158) then
tmp = t_6
else
tmp = ((9.0d0 * ((y / (c * z)) * x)) + t_1) - t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = b / (c * z);
double t_2 = 4.0 * ((a * t) / c);
double t_3 = (x * 9.0) * y;
double t_4 = (t_3 - (((z * 4.0) * t) * a)) + b;
double t_5 = t_4 / (z * c);
double t_6 = ((t_3 - ((z * 4.0) * (t * a))) + b) / (z * c);
double tmp;
if (t_5 < -1.100156740804105e-171) {
tmp = t_6;
} else if (t_5 < 0.0) {
tmp = (t_4 / z) / c;
} else if (t_5 < 1.1708877911747488e-53) {
tmp = t_6;
} else if (t_5 < 2.876823679546137e+130) {
tmp = (((9.0 * (y / c)) * (x / z)) + t_1) - t_2;
} else if (t_5 < 1.3838515042456319e+158) {
tmp = t_6;
} else {
tmp = ((9.0 * ((y / (c * z)) * x)) + t_1) - t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = b / (c * z) t_2 = 4.0 * ((a * t) / c) t_3 = (x * 9.0) * y t_4 = (t_3 - (((z * 4.0) * t) * a)) + b t_5 = t_4 / (z * c) t_6 = ((t_3 - ((z * 4.0) * (t * a))) + b) / (z * c) tmp = 0 if t_5 < -1.100156740804105e-171: tmp = t_6 elif t_5 < 0.0: tmp = (t_4 / z) / c elif t_5 < 1.1708877911747488e-53: tmp = t_6 elif t_5 < 2.876823679546137e+130: tmp = (((9.0 * (y / c)) * (x / z)) + t_1) - t_2 elif t_5 < 1.3838515042456319e+158: tmp = t_6 else: tmp = ((9.0 * ((y / (c * z)) * x)) + t_1) - t_2 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(b / Float64(c * z)) t_2 = Float64(4.0 * Float64(Float64(a * t) / c)) t_3 = Float64(Float64(x * 9.0) * y) t_4 = Float64(Float64(t_3 - Float64(Float64(Float64(z * 4.0) * t) * a)) + b) t_5 = Float64(t_4 / Float64(z * c)) t_6 = Float64(Float64(Float64(t_3 - Float64(Float64(z * 4.0) * Float64(t * a))) + b) / Float64(z * c)) tmp = 0.0 if (t_5 < -1.100156740804105e-171) tmp = t_6; elseif (t_5 < 0.0) tmp = Float64(Float64(t_4 / z) / c); elseif (t_5 < 1.1708877911747488e-53) tmp = t_6; elseif (t_5 < 2.876823679546137e+130) tmp = Float64(Float64(Float64(Float64(9.0 * Float64(y / c)) * Float64(x / z)) + t_1) - t_2); elseif (t_5 < 1.3838515042456319e+158) tmp = t_6; else tmp = Float64(Float64(Float64(9.0 * Float64(Float64(y / Float64(c * z)) * x)) + t_1) - t_2); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = b / (c * z); t_2 = 4.0 * ((a * t) / c); t_3 = (x * 9.0) * y; t_4 = (t_3 - (((z * 4.0) * t) * a)) + b; t_5 = t_4 / (z * c); t_6 = ((t_3 - ((z * 4.0) * (t * a))) + b) / (z * c); tmp = 0.0; if (t_5 < -1.100156740804105e-171) tmp = t_6; elseif (t_5 < 0.0) tmp = (t_4 / z) / c; elseif (t_5 < 1.1708877911747488e-53) tmp = t_6; elseif (t_5 < 2.876823679546137e+130) tmp = (((9.0 * (y / c)) * (x / z)) + t_1) - t_2; elseif (t_5 < 1.3838515042456319e+158) tmp = t_6; else tmp = ((9.0 * ((y / (c * z)) * x)) + t_1) - t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x * 9.0), $MachinePrecision] * y), $MachinePrecision]}, Block[{t$95$4 = N[(N[(t$95$3 - N[(N[(N[(z * 4.0), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$4 / N[(z * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(N[(N[(t$95$3 - N[(N[(z * 4.0), $MachinePrecision] * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision]}, If[Less[t$95$5, -1.100156740804105e-171], t$95$6, If[Less[t$95$5, 0.0], N[(N[(t$95$4 / z), $MachinePrecision] / c), $MachinePrecision], If[Less[t$95$5, 1.1708877911747488e-53], t$95$6, If[Less[t$95$5, 2.876823679546137e+130], N[(N[(N[(N[(9.0 * N[(y / c), $MachinePrecision]), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] - t$95$2), $MachinePrecision], If[Less[t$95$5, 1.3838515042456319e+158], t$95$6, N[(N[(N[(9.0 * N[(N[(y / N[(c * z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] - t$95$2), $MachinePrecision]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{b}{c \cdot z}\\
t_2 := 4 \cdot \frac{a \cdot t}{c}\\
t_3 := \left(x \cdot 9\right) \cdot y\\
t_4 := \left(t_3 - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b\\
t_5 := \frac{t_4}{z \cdot c}\\
t_6 := \frac{\left(t_3 - \left(z \cdot 4\right) \cdot \left(t \cdot a\right)\right) + b}{z \cdot c}\\
\mathbf{if}\;t_5 < -1.100156740804105 \cdot 10^{-171}:\\
\;\;\;\;t_6\\
\mathbf{elif}\;t_5 < 0:\\
\;\;\;\;\frac{\frac{t_4}{z}}{c}\\
\mathbf{elif}\;t_5 < 1.1708877911747488 \cdot 10^{-53}:\\
\;\;\;\;t_6\\
\mathbf{elif}\;t_5 < 2.876823679546137 \cdot 10^{+130}:\\
\;\;\;\;\left(\left(9 \cdot \frac{y}{c}\right) \cdot \frac{x}{z} + t_1\right) - t_2\\
\mathbf{elif}\;t_5 < 1.3838515042456319 \cdot 10^{+158}:\\
\;\;\;\;t_6\\
\mathbf{else}:\\
\;\;\;\;\left(9 \cdot \left(\frac{y}{c \cdot z} \cdot x\right) + t_1\right) - t_2\\
\end{array}
\end{array}
herbie shell --seed 2023176
(FPCore (x y z t a b c)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, J"
:precision binary64
:herbie-target
(if (< (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)) -1.100156740804105e-171) (/ (+ (- (* (* x 9.0) y) (* (* z 4.0) (* t a))) b) (* z c)) (if (< (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)) 0.0) (/ (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) z) c) (if (< (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)) 1.1708877911747488e-53) (/ (+ (- (* (* x 9.0) y) (* (* z 4.0) (* t a))) b) (* z c)) (if (< (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)) 2.876823679546137e+130) (- (+ (* (* 9.0 (/ y c)) (/ x z)) (/ b (* c z))) (* 4.0 (/ (* a t) c))) (if (< (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)) 1.3838515042456319e+158) (/ (+ (- (* (* x 9.0) y) (* (* z 4.0) (* t a))) b) (* z c)) (- (+ (* 9.0 (* (/ y (* c z)) x)) (/ b (* c z))) (* 4.0 (/ (* a t) c))))))))
(/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)))